Windows下x64反汇编参数传递约定,一句话,调用顺序为从左到右, Function( rcx, rdx, r8,r9, [rsp+0x20], [rsp+0x28], [rsp+0x30]..

发布于:2022-11-09 ⋅ 阅读:(14) ⋅ 点赞:(0) ⋅ 评论:(0)

Windows下x64反汇编参数传递约定

一句话,调用顺序为从左到右,  Function( rcx, rdx, r8,r9, [rsp+0x20], [rsp+0x28], [rsp+0x30], [rsp+0x38], [rsp+0x40], [rsp+0x48], [rsp+0x50], [rsp+0x58], [rsp+0x60] ...)

x64 体系结构

x64 体系结构是 x86 的向后兼容扩展。 它提供与 x86 相同的旧 32 位模式,以及新的 64 位模式。

术语"x64"包括 AMD 64 和 Intel64。 指令集接近相同。

寄存 器

x64 将 x86 的 8 个常规用途寄存器扩展为 64 位,并添加了 8 个新的 64 位寄存器。 64 位寄存器的名称以"r"开头,因此例如, eax 的 64 位扩展名为 rax。 新寄存器的名称为 r8 到 r15

每个寄存器的低 32 位、16 位和 8 位可直接在操作数中处理。 这包括寄存器,如 esi,其低 8 位以前不可处理。 下表为 64 位寄存器的下半部分指定汇编语言名称。

64 位寄存器 低 32 位 低 16 位 低 8 位

rax

eax

ax

rbx

ebx

bx

bl

rcx

ecx

残雪

Cl

rdx

edx

Dx

Dl

rsi

Esi

Sil

rdi

Edi

di

dil

rbp

Ebp

Bp

bpl

粒子

Esp

sp

Spl

r8

r8d

r8w

r8b

r9

r9d

r9w

r9b

r10

r10d

r10w

r10b

r11

r11d

r11w

r11b

r12

r12d

r12w

r12b

r13

r13d

r13w

r13b

r14

r14d

r14w

r14b

r15

r15d

r15w

r15b

输出到 32 位子注册的操作会自动零扩展为整个 64 位寄存器。 输出到 8 位或 16 位子注册的操作不是零扩展 (这是兼容的 x86 行为) 。

axbxcx 和 dx 的高 8 位仍可作为 ahbhchdh 进行地址处理,但不能用于所有类型的操作数。

指令指针、eip 和标志寄存器已分别扩展到 (和 rflags) 64 位。

x64 处理器还提供多组浮点寄存器:

  • 八个 80 位 x87 寄存器。

  • 八个 64 位 MMX 寄存器。 (与 x87 registers.)

  • 8 个 128 位 SSE 寄存器的原始集增加到 16 个。

调用约定

与 x86 不同,C/C++ 编译器仅支持 x64 上的一个调用约定。 此调用约定利用 x64 上可用的寄存器数增加:

  • 前四个整数或指针参数在 rcx、 rdx、 r8 和 r9 寄存器中传递。

  • 前四个浮点参数在前四个 SSE 寄存器 xmm0xmm3-中传递

  • 调用方在堆栈上为寄存器中传递的参数保留空间。 被调用的函数可以使用此空间将寄存器的内容溢出到堆栈。

  • 任何其他参数在堆栈上传递。

  • 在 rax 寄存器中返回整数或指针返回值,而浮点返回值在 xmm0 中返回

  • raxrcxrdxr8r11- 是可变的。

  • rbxrbprdi、rsir12r15- 是非易失性。

C++ 的调用约定非常相似:  指针作为隐式第一个参数传递。 接下来的三个参数在剩余的寄存器中传递,其余参数在堆栈上传递。

寻址模式

64 位模式下的寻址模式类似于 x86,但不完全相同。

  • 引用 64 位寄存器的说明以 64 位精度自动执行。 (例如 mov rax,[rbx] 从 rbx 开始将 8 个字节移动到 rax.)

  • 为 64 位即时常量或常量地址添加了一种特殊形式的 mov 指令。 对于所有其他指令,即时常量或常量地址仍为 32 位。

  • x64 提供新的 与元寻址相关的寻址模式。 引用单个常量地址的指令编码为从进行翻录的 偏移量。 例如,mov rax,[addr] 指令从 addrrip + 开始将 8 个字节移动到 rax

隐式引用指令指针的指令(如 jmp、 调用、 推送和 pop)和堆栈指针将它们视为 x64 上的 64 位寄存器。

在 Win64 下的 registers 用途

Register

Status

Use

RAX Volatile Return value register
RCX Volatile First integer argument
RDX Volatile Second integer argument
R8 Volatile Third integer argument
R9 Volatile Fourth integer argument
R10:R11 Volatile Must be preserved as needed by caller; used in syscall/sysret instructions
R12:R15 Nonvolatile Must be preserved by callee
RDI Nonvolatile Must be preserved by callee
RSI Nonvolatile Must be preserved by callee
RBX Nonvolatile Must be preserved by callee
RBP Nonvolatile May be used as a frame pointer; must be preserved by callee
RSP Nonvolatile Stack pointer
XMM0 Volatile First FP argument
XMM1 Volatile Second FP argument
XMM2 Volatile Third FP argument
XMM3 Volatile Fourth FP argument
XMM4:XMM5 Volatile Must be preserved as needed by caller
XMM6:XMM15 Nonvolatile Must be preserved as needed by callee.

1. 传递参数

在 Win64 里使用下面寄存器来传递参数:

  • rcx - 第 1 个参数
  • rdx - 第 2 个参数
  • r8 - 第 3 个参数
  • r9 - 第 4 个参数

其它多出来的参数通过 stack 传递。

使用下面寄存器来传递浮数数:

  • xmm0 - 第 1 个参数
  • xmm1 - 第 2 个参数
  • xmm2 - 第 3 个参数
  • xmm3 - 第 4 个参数

下面的代码:

void EditTextFile(HWND hEdit, LPCTSTR szFileName)
{
        HANDLE hFile;
        DWORD dwFileSize;
        DWORD dwFileSizeHigh;
        LPTSTR lpFileText;
        LPTSTR lpFileTextW;
        WORD wSignature;
        DWORD dwReadSize;

        hFile = CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

        ... ...

}

CreateFile() 的参数有 7 个,那么看看 VC 是怎样安排参数传递:

void EditTextFile(HWND hEdit, LPCTSTR szFileName)
{
000000013F791570 40 56                push        rsi  
000000013F791572 41 54                push        r12  
000000013F791574 41 55                push        r13  
000000013F791576 48 83 EC 50          sub         rsp,50h  
000000013F79157A 48 8B C2             mov         rax,rdx  
        HANDLE hFile;
        DWORD dwFileSize;
        DWORD dwFileSizeHigh;
        LPTSTR lpFileText;
        LPTSTR lpFileTextW;
        WORD wSignature;
        DWORD dwReadSize;

        hFile = CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
000000013F79157D 45 33 ED             xor         r13d,r13d  
000000013F791580 4C 8B E1             mov         r12,rcx  
000000013F791583 4C 89 6C 24 30       mov         qword ptr [rsp+30h],r13       // 第 7 个参数  
000000013F791588 45 8D 45 01          lea         r8d,[r13+1]                   // 第 3 个参数
000000013F79158C 45 33 C9             xor         r9d,r9d                       // 第 4 个参数
000000013F79158F BA 00 00 00 80       mov         edx,80000000h                 // 第 2 个参数
000000013F791594 48 8B C8             mov         rcx,rax                       // 第 1 个参数  
000000013F791597 C7 44 24 28 80 00 00 00 mov      dword ptr [rsp+28h],80h       // 第 6 个参数
000000013F79159F C7 44 24 20 03 00 00 00 mov      dword ptr [rsp+20h>],3         // 第 5 个参数
000000013F7915A7 FF 15 2B 0B 00 00    call        qword ptr [__imp_CreateFileW (13F7920D8h)]  
000000013F7915AD 48 8B F0             mov         rsi,rax 

        ... ...

上面已经对 7 个参数的传递进行了标注,前 4 个参数通过 rcx,rdx,r8 以及 r9 寄存器传递,后 3 个参数确实通过 stack 传递。

可是,事情并没有这么简单:

在 Win64 下,会为每个参数保留一份用来传递的 stack 空间,以便回写 caller 的 stack

在上面的例子中:

  • [rsp+20h] - 第 5 个参数
  • [rsp+28h] - 第 6 个参数
  • [rsp+30h] - 第 7 个参数

实际上已经为前面 4 个参数保留了 stack 空间,分别是:

  • [rsp] - 第 1 个参数(使用 rcx 代替)
  • [rsp+08h] - 第 2 个参数(使用 rdx 代替)
  • [rsp+10h] - 第 3 个参数(使用 r8 代替)
  • [rsp+18h] - 第 4 个参数(使用 r9 代替)

虽然是使用了 registers 来传递参数,然而还是保留了 stack 空间。接下着就是 [rsp+20h][rsp+28h] 以及[rsp+30h] 对应的 4,5,个参数

2. 回写 caller stack

VC 使用了下面编译参数来实现回写 caller stack

/homeparams

当使用了这个编译选项或者在 Debug 版下,它强制将 registers 里的值写回 stack 中

正如下面的代码:

CreateFileWImplementation:
0000000076EC2A30 48 89 5C 24 08       mov         qword ptr [rsp+8],rbx             // 回写 caller stack
0000000076EC2A35 48 89 6C 24 10       mov         qword ptr [rsp+10h],rbp           // 回写 caller stack
0000000076EC2A3A 48 89 74 24 18       mov         qword ptr [rsp+18h],rsi           // 回写 caller stack
0000000076EC2A3F 57                   push        rdi  
0000000076EC2A40 48 83 EC 50          sub         rsp,50h  
0000000076EC2A44 8B DA                mov         ebx,edx  
0000000076EC2A46 48 8B F9             mov         rdi,rcx  
0000000076EC2A49 48 8B D1             mov         rdx,rcx  
0000000076EC2A4C 48 8D 4C 24 40       lea         rcx,[rsp+40h]  
0000000076EC2A51 49 8B F1             mov         rsi,r9  
0000000076EC2A54 41 8B E8             mov         ebp,r8d  
0000000076EC2A57 FF 15 33 A1 08 00    call        qword ptr [__imp_RtlInitUnicodeStringEx (76F4CB90h)] 

上面所显示的是 CreateFile() 在 kernel32.dll 模块里的实现代码,上面对回写机制进行了标注,回写的 stack 正好是 caller 调用时未参数所保留的 stack 空间,上面的代码并不是那么直观。

下面我演示一下使用 /homeparams 选项来编译代码。

上面的 EditTextFile() 函数结果如下:

void EditTextFile(HWND hEdit, LPCTSTR szFileName)
{
000000013F6A15C0 48 89 54 24 10       mov         qword ptr [rsp+10h],rdx          // 第 2 个参数回写
000000013F6A15C5 48 89 4C 24 08       mov         qword ptr [rsp+8],rcx            // 第 1 个参数回写
000000013F6A15CA 56                   push        rsi  
000000013F6A15CB 41 54                push        r12  
000000013F6A15CD 48 83 EC 58          sub         rsp,58h  
 HANDLE hFile;
 DWORD dwFileSize;
 DWORD dwFileSizeHigh;
 LPTSTR lpFileText;
 LPTSTR lpFileTextW;
 WORD wSignature;
 DWORD dwReadSize;

 hFile = CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
000000013F6A15D1 48 8B 4C 24 78       mov         rcx,qword ptr [szFileName]  
000000013F6A15D6 45 33 E4             xor         r12d,r12d  
000000013F6A15D9 45 33 C9             xor         r9d,r9d  
000000013F6A15DC 4C 89 64 24 30       mov         qword ptr [rsp+30h],r12  
000000013F6A15E1 45 8D 44 24 01       lea         r8d,[r12+1]  
000000013F6A15E6 BA 00 00 00 80       mov         edx,80000000h  
000000013F6A15EB C7 44 24 28 80 00 00 00 mov         dword ptr [rsp+28h],80h  
000000013F6A15F3 C7 44 24 20 03 00 00 00 mov         dword ptr [rsp+20h],3  
000000013F6A15FB FF 15 D7 1A 00 00    call        qword ptr [__imp_CreateFileW (13F6A30D8h)]

第 1 个参数回写 [rsp+8] 处,第 2 个参数回写 [rsp+10h] 处。

注意这里的 stack 就是对应 caller 调用时的 stack,经过调用后 [rsp] 是返回地址值,因此,在 callee 里设置:

  • callee 写 [rsp+8] = caller 的 [rsp]
  • callee 写 [rsp+10h] = caller 的 [rsp+8]
  • callee 的 [rsp] = return address

上面很直观地显示了使用 /homeparams 选项时的效果,对比前一段没有使用 /homeparams 选项编译时的结果,很容易发现这个机制。

回写 caller stack 机制目的是为了 Debug 所需。

3. 由 callee 保存

在一个程序里应尽量使用 registers,在 x64 里有 16 个通用寄存器和 16 个 xmm 寄存器,可是一些 registers 在使用前必须保存原来值,以防丢失原来值。

因此,在 callee 使用它们时会将原值压入栈中保存,在 Win64 里,下面 registers 由 callee 负责保存:

  • rbxrbprsirdi
  • r12 - r15
  • xmm6 - xmm15

每进入一个 callee,在使用它们之前都保存起来,返回 caller 之前,恢复原来值。因此这些寄存器的值是保持恒定的。

void EditTextFile(HWND hEdit, LPCTSTR szFileName)
{
000000013F9115C0 48 89 54 24 10       mov         qword ptr [rsp+10h],rdx  
000000013F9115C5 48 89 4C 24 08       mov         qword ptr [rsp+8],rcx  
000000013F9115CA 56                   push        rsi                     // 保存
000000013F9115CB 41 54                push        r12                     // 保存
000000013F9115CD 48 83 EC 58          sub         rsp,58h  
        HANDLE hFile;
        DWORD dwFileSize;

... ...


000000013F911708 48 83 C4 58          add         rsp,58h  
000000013F91170C 41 5C                pop         r12                    // 恢复
000000013F91170E 5E                   pop         rsi                    // 恢复
000000013F91170F C3                   ret

4. stack frame 结构

进入每个 callee 时,都会生成属于自己的 stack frame 结构,返回时会注销自己的 stack frame

  • rbp
  • rsp

由这两个 registers 来构造 stack frame 结构,rbp  stack frame pointerrsp 是 stack pointer

可是,在 Win64 里,似乎不使用 stack frame 结构,VC 不会为每个函数创建 stack frame 结构

在 Win64 里,始终在使用动态使用 rsp 来维护 stack

void EditTextFile(HWND hEdit, LPCTSTR szFileName)
{
000000013F9115C0 48 89 54 24 10       mov         qword ptr [rsp+10h],rdx  
000000013F9115C5 48 89 4C 24 08       mov         qword ptr [rsp+8],rcx  
000000013F9115CA 56                   push        rsi                    
000000013F9115CB 41 54                push        r12                     
000000013F9115CD 48 83 EC 58          sub         rsp,58h             // 为 callee 分配 stack
        HANDLE hFile;
        DWORD dwFileSize;

... ...


000000013F911708 48 83 C4 58          add         rsp,58h            // 注销 callee stack 结构
000000013F91170C 41 5C                pop         r12                    
000000013F91170E 5E                   pop         rsi                   
000000013F91170F C3 

VC 不会生成 x86 下典型的 stack frame 结构,始终由 rsp 维护 stack,/Gd 编译选项在 Win64 下会被忽略,rbp 被保留起来

在 Win64 里,rdi 寄存器的角色变得很微妙,在某些场合下它充当了一部分 stack frame pointer 的角色。

5. r11 与 rcx 以及 r10

在 64 位模式下,在 sysret 指令返回时,将从 rcx 处得到返回地址,从 r11 处得到 rflags 值,因此在进入 system services routine(系统服务例程)前,或者在系统服务例程中的第1个任务是 rcx 与 r11 寄存器,以便 sysret 返回。

在 Win64 里,r10 寄存器充当保存 rcx 值的作用,如下:

NtCallbackReturn:
00000000770FFDA0 4C 8B D1             mov         r10,rcx  
00000000770FFDA3 B8 02 00 00 00       mov         eax,2  
00000000770FFDA8 0F 05                syscall  
00000000770FFDAA C3                   ret 

在进入 system call 之前,保存 rcx 的值。

x86:又名 x32 ,表示 Intel x86 架构,即 Intel 的32位 80386 汇编指令集。

x64:表示 AMD64 和 Intel 的 EM64T ,而不包括 IA64 。至于三者间的区别,可自行搜索。

x64 跟 x86 相比寄存器的变化,如图:

从图上可以看到,X64架构相对于X86架构的主要变化,是将原来所有的寄存器都扩大了一倍,例如EAX现在扩充成RAX,同时,又新增加了从R8~R15这8个64位的寄位器,有点RISC的味道(RISC特点就是寄存器多)。

然后还有下面的一些改变:

  • x64上面默认的函数调用约定是 fast call ,也就是 ABI 是 fast call ;
  • 一个函数在调用时,前四个参数是从左至右依次存放于RCX、RDX、R8、R9寄存器里面,剩下的参数从左至右顺序入栈;
  • 调用者负责在栈上分配32字节的“shadow space”,用于存放那四个存放调用参数的寄存器的值(亦即前四个调用参数);
  • 小于64位(bit)的参数传递时高位并不填充零(例如只传递ecx),大于64位需要按照地址传递;
  • 被调用函数的返回值是整数时,则返回值会被存放于RAX;
  • 被调用函数不负责清栈,调用者负责清理栈;
  • RAX,RCX,RDX,R8,R9,R10,R11是“易挥发”的,不用特别保护,其余寄存器需要保护。(x86下只有eax, ecx, edx是易挥发的)
  • 栈需要16字节对齐,“call”指令会入栈一个8字节的返回值(注:即函数调用前原来的RIP指令寄存器的值),这样一来,栈就对不齐了(因为RCX、RDX、R8、R9四个寄存器刚好是32个字节,是16字节对齐的,现在多出来了8个字节)。所以,所有非叶子结点调用的函数,都必须调整栈RSP的地址为16n+8,来使栈对齐。
  • 对于 R8~R15 寄存器,我们可以使用 r8, r8d, r8w, r8b 分别代表 r8 寄存器的64位、低32位、低16位和低8位。

一些其他要注意的小问题:

  • 另外一些小问题要注意,AMD64不支持 push 32bit 寄存器的指令,最好的方法就是 push 和 pop 都用64位寄存器,即 push rbx ,不要使用 push ebx 。
  • 另外要补充的一点是,在一般情况下,X64 平台的 RBP 栈基指针被废弃掉,只作为普通寄存器来用,所有的栈操作都通过 RSP 指针来完成。

遗留问题

  以上都是关于 Windows 上的调用约定,即 Visual Studio 上使用的调用约定,至于 GCC 的函数调用约定是否一致,还不清楚,有知道的请指点一下,我从 asmlib 的64位汇编看,GCC 好像第一个参数用的是 rdi ,而不是 rcx 。

示例:

; 示例代码 1.asm

; 语法:GoASM

DATA SECTION

text     db 'Hello x64!',

caption  db 'My First x64 Application',

CODE SECTION

START:

sub rsp, 28h           ; 堆栈预留 shadow space (40 + 8)字节

xor r9d, r9d           ; r9

lea r8, caption        ; r8

lea rdx, text          ; rdx

xor rcx, rcx           ; rcx

call MessageBoxA

add rsp, 28h           ; 调用者自己恢复堆栈

ret