CTF-RE 从0到N:汇编层函数调用

windows

在 Windows 平台上的汇编语言中，调用函数的方式通常遵循特定的调用约定（Calling Convention）。最常见的调用约定包括：

• cdecl: C 默认调用约定，调用者清理堆栈。
• stdcall: Windows API 默认调用约定，被调用者清理堆栈。
• fastcall: 使用寄存器传递前两个参数，其余参数通过堆栈传递。
• x64: 在 64 位系统上，使用寄存器传递前四个参数，其余参数通过堆栈传递。

1. cdecl 调用约定

在 cdecl 调用约定中，函数参数从右到左推入堆栈，函数返回后由调用者清理堆栈。

; 函数原型: int add(int a, int b);
push    dword ptr [b]   ; 将参数 b 推入堆栈
push    dword ptr [a]   ; 将参数 a 推入堆栈
call    add             ; 调用函数 add
add     esp, 8          ; 调用者清理堆栈 (2 * 4 bytes)

2. stdcall 调用约定

在 stdcall 调用约定中，函数参数同样从右到左推入堆栈，但由被调用者清理堆栈。

; 函数原型: int add(int a, int b);
push    dword ptr [b]   ; 将参数 b 推入堆栈
push    dword ptr [a]   ; 将参数 a 推入堆栈
call    add             ; 调用函数 add
; 不需要清理堆栈，因为被调用者会清理堆栈

3. fastcall 调用约定

在 fastcall 调用约定中，前两个参数通过寄存器传递（ECX 和 EDX），其余参数通过堆栈传递。

; 函数原型: int add(int a, int b);
mov     ecx, dword ptr [a]   ; 将参数 a 放入 ECX 寄存器
mov     edx, dword ptr [b]   ; 将参数 b 放入 EDX 寄存器
call    add                  ; 调用函数 add
; 不需要清理堆栈，因为被调用者会清理寄存器

4. x64 调用约定

在 64 位系统的 Windows 上，前四个参数通过寄存器传递，后续参数通过堆栈传递。惯例使用的寄存器是：RCX、RDX、R8 和 R9。

; 函数原型: int add(int a, int b, int c, int d);
mov     ecx, dword ptr [a]   ; 将参数 a 放入 RCX 寄存器
mov     edx, dword ptr [b]   ; 将参数 b 放入 RDX 寄存器
mov     r8d, dword ptr [c]   ; 将参数 c 放入 R8 寄存器
mov     r9d, dword ptr [d]   ; 将参数 d 放入 R9 寄存器
call    add                  ; 调用函数 add
; 返回值在 RAX 寄存器中

具体例子

假设我们有一个简单的 C 函数：

int add(int a, int b) {return a + b;
}

使用 cdecl 调用约定的实现：

section .dataa dd 5b dd 10section .textextern addglobal _start_start:push    dword [b]       ; 推入参数 bpush    dword [a]       ; 推入参数 acall    add             ; 调用函数 addadd     esp, 8          ; 清理堆栈mov     ebx, eax        ; 将返回值存入 EBX（假设退出码）mov     eax, 1          ; 系统调用号 (sys_exit)int     0x80            ; 调用内核

使用 x64 调用约定的实现：

section .dataa dd 5b dd 10section .textextern addglobal _start_start:mov     ecx, dword [a]  ; 将参数 a 放入 RCXmov     edx, dword [b]  ; 将参数 b 放入 RDXcall    add             ; 调用函数 add; 返回值在 RAX 寄存器中mov     edi, eax        ; 将返回值存入 EDI（假设退出码）mov     eax, 60         ; 系统调用号 (sys_exit)syscall                 ; 调用内核

linux

基本

在汇编语言中，调用函数的过程涉及多个步骤，包括参数传递、调用指令、堆栈管理和返回值处理。下面详细解释在x86架构的汇编语言中，调用函数的过程，特别是基于C语言的函数调用约定。

函数调用约定

函数调用约定定义了如何在汇编中传递参数、管理堆栈以及返回值。不同系统和编译器有不同的调用约定，如cdecl、stdcall、fastcall 等。我们以最常见的cdecl调用约定为例。

函数调用的主要步骤

1. 参数压栈：

   • 在调用函数前，参数按照从右到左的顺序压入栈中。
   • 这意味着第一个参数最后压栈，最后一个参数最先压栈。

2. 调用指令 call：

   • 使用 call 指令调用函数。call指令会做两件事：
     1. 将下一条指令（即函数调用后紧跟的指令地址）压入栈中，作为返回地址。
     2. 跳转到被调用函数的地址。

3. 函数内部处理：

   • 进入函数后，通常会创建一个新的栈帧，通过 push ebp 保存调用者的栈帧指针，然后 mov ebp, esp 设置当前栈帧指针。
   • 函数从栈中读取参数，并执行操作。

4. 返回值：

   • 返回值通常存储在 eax 寄存器中。

5. 清理栈：

   • 函数返回后，调用者负责清理栈上压入的参数。对于 cdecl 调用约定，调用者负责清理栈。
   • 对于 stdcall 调用约定，函数自己清理参数。

汇编代码中的调用过程

我们通过一个具体的汇编调用过程来解释：

push    arg2    ; 第二个参数压栈
push    arg1    ; 第一个参数压栈
call    function_name ; 调用函数
add     esp, 8  ; 调用者清理栈上的参数 (两个参数，每个参数4字节，总共8字节)

具体例子

假设我们有一个简单的 C 函数：

int add(int a, int b) {return a + b;
}int main() {int result = add(3, 4);return 0;
}

对应的汇编代码（简化版）可能如下：

; 在 main 函数中：
push    4               ; 第二个参数 b = 4 压栈
push    3               ; 第一个参数 a = 3 压栈
call    add             ; 调用 add 函数
add     esp, 8          ; 清理栈（2个参数，每个4字节）
mov     [ebp-4], eax    ; 将结果存入局部变量 result; 在 add 函数中：
add procpush    ebp         ; 保存调用者的栈帧mov     ebp, esp    ; 设置当前栈帧mov     eax, [ebp+8] ; 加载第一个参数 amov     ecx, [ebp+12] ; 加载第二个参数 badd     eax, ecx    ; 执行加法pop     ebp         ; 恢复调用者的栈帧ret                 ; 返回，结果在 eax 中
add endp

详细步骤说明

1. 参数压栈：

   • push 4 和 push 3 将两个参数 4 和 3 压入栈，按照从右到左的顺序。

2. 调用函数：

   • call add 调用 add 函数。call 指令会将下一条指令的地址压入栈中，作为返回地址，并跳转到 add 函数的地址执行。

3. 函数栈帧设置：

   • 在 add 函数中，push ebp 将调用者的栈帧指针保存到栈中。
   • mov ebp, esp 设置当前函数的栈帧指针，使得栈指针 esp 成为当前函数的栈帧基准。
   • mov eax, [ebp+8] 加载第一个参数 a，它位于栈中距离 ebp 8 个字节的位置（4字节是保存的 ebp，再往上是返回地址）。
   • mov ecx, [ebp+12] 加载第二个参数 b，它位于 ebp+12 位置。

4. 执行加法：

   • add eax, ecx 将参数 a 和 b 相加，结果存入 eax 寄存器。

5. 函数返回：

   • pop ebp 恢复调用者的栈帧。
   • ret 从函数返回，eax 中的值作为返回值传递回调用者。

6. 调用者清理栈：

   • add esp, 8 调用者负责清理栈上压入的两个参数，共8个字节。

总结

函数调用在汇编中的实现依赖于：

• 参数压栈：参数按从右到左顺序压入栈中。
• 调用函数：call 指令将返回地址压栈并跳转到函数地址。
• 栈帧管理：函数通常会创建自己的栈帧，使用 ebp 寄存器管理。
• 返回值传递：返回值通常存储在 eax 寄存器中。
• 清理栈：根据调用约定，调用者或被调用者负责清理栈上的参数。

通过这个过程，我们可以理解函数在低级汇编语言中的调用机制如何运作。

拥有可变参数的函数

对于可变参数函数（例如 C 语言中的 printf），在汇编中调用可变参数函数的过程与普通函数调用稍有不同，因为需要处理不确定数量的参数。stdarg.h 中的宏（例如 va_start, va_arg, va_end）用于处理这些可变参数。

我们以 int a(char *Format, ...) 这种可变参数函数为例，来说明汇编中如何处理可变参数函数。

可变参数的处理

当一个函数定义为可变参数（即包含 ...），在汇编中，通常需要根据栈的布局和函数的调用约定手动管理这些参数。x86 调用约定（例如 cdecl）中，可变参数会和固定参数一起压入栈中。

以 int a(char *Format, ...) 为例，它的汇编调用流程与普通函数类似，但需要特别处理可变参数。

函数调用过程

参数压栈

调用函数时，已知的参数（如 Format）按照普通参数顺序压栈，之后才压入可变参数。可变参数通过栈传递。

例如，假设我们调用如下的 C 代码：

int a(char *Format, ...) {// 实现略
}int main() {a("%d %s", 42, "example");
}

在汇编中，参数传递的顺序如下（以 cdecl 调用约定为例）：

push    offset string_example  ; 可变参数 "example"
push    42                     ; 可变参数 42
push    offset format_string   ; 固定参数 Format
call    a                      ; 调用可变参数函数
add     esp, 12                ; 清理栈（3个参数，每个4字节，共12字节）

函数内部处理

函数在内部使用 va_start 等宏来访问可变参数，这在汇编中是通过对栈指针的操作来完成的。

以下是可能的汇编流程：

1. 设置栈帧：

   • 和普通函数一样，先保存调用者的栈帧，设置当前栈帧：

     push    ebp
     mov     ebp, esp
     

2. 访问固定参数：

   • 在栈中，Format 是第一个参数，位于 [ebp + 8] 处。

     mov     eax, [ebp + 8]     ; 获取 Format 参数
     

3. 初始化可变参数列表：

   • 使用 lea（Load Effective Address）指令计算可变参数列表的起始地址。通常第一个可变参数位于 [ebp + 12]，即在第一个固定参数之后：

     lea     ecx, [ebp + 12]    ; 计算可变参数列表的地址
     

4. 调用处理函数：

   • 将 Format 和可变参数列表的地址传递给实际处理函数，类似于 vprintf 这样的函数。

     push    ecx                ; 压入可变参数地址
     push    eax                ; 压入 Format 字符串
     call    vprintf            ; 调用变参处理函数
     

5. 清理栈并返回：

   • 函数执行完毕后，需要恢复栈指针并返回。

     pop     ebp
     ret
     

完整的汇编示例

假设我们要实现一个简单的 int a(char *Format, ...) 函数，它只将格式化字符串和可变参数传递给 vprintf。以下是它的汇编实现的简化版本：

a procpush    ebp                ; 保存调用者的栈帧mov     ebp, esp           ; 设置当前栈帧mov     eax, [ebp + 8]     ; 获取第一个参数 Format（位于栈中第一个固定参数位置）lea     ecx, [ebp + 12]    ; 获取可变参数列表的地址push    ecx                ; 将可变参数地址压栈push    eax                ; 将 Format 压栈call    vprintf            ; 调用 vprintf 函数pop     ebp                ; 恢复栈帧ret                        ; 返回a endp

对应的 C 实现

对应的 C 实现如下所示，使用 va_start、va_end 等标准宏来处理可变参数：

#include <stdio.h>
#include <stdarg.h>int a(const char *Format, ...) {va_list args;va_start(args, Format);     // 初始化可变参数列表int result = vprintf(Format, args);  // 将 Format 和可变参数传递给 vprintfva_end(args);               // 清理可变参数列表return result;
}int main() {a("%d %s\n", 42, "example");return 0;
}

总结

在可变参数函数的汇编实现中：

1. 参数传递：

   • 固定参数（如 Format）和可变参数按顺序压入栈中。
   • 可变参数通过栈传递，函数内部通过栈指针访问这些参数。

2. 处理可变参数：

   • 函数通过计算堆栈中的地址来获取可变参数列表的起始位置（通常通过 [ebp + offset] 来计算）。

3. 调用内部的处理函数：

   • 使用汇编中的 lea 指令计算可变参数列表的地址，并传递给诸如 vprintf 这样的变参处理函数。