pwn

栈操作

The Stack Operation

PROCESSOR’S STACK: TRACING THE ACTION

函数调用和栈可以总结如下：

  1. 将参数压入栈中

  2. 调用函数（压入函数返回地址）

  3. （内置函数）为局部变量和缓冲区存储设置栈帧

  4. 在函数返回之前，调整栈帧来解除局部变量和缓冲区存储的分配

  5. 返回（弹出返回地址）并且调整栈来移除函数参数

一个C程序如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
int TestFunc(int parameter1,int parameter2,char parameter3)
{
int y = 3, z = 4;
char buff[7] = "ABCDEF";
// function's task code here
return 0;
}

int main(int argc, char *argv[ ])
{
TestFunc(1, 2, 'A');
return 0;
}

先进行编译

1
gcc -o testprog5 testprog5.c

使用 gdb 查看

main 部分汇编

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
(gdb) break main

Breakpoint 1 at 0x8048388: file testprog5.c, line 14.

(gdb) disass main

Dump of assembler code for function main:

0x0804836c <main+0>:    push   %ebp                   ;main stack frame

0x0804836d <main+1>:    mov    %esp, %ebp

0x0804836f <main+3>:    sub    $0x8, %esp

0x08048372 <main+6>:    and    $0xfffffff0, %esp

0x08048375 <main+9>:    mov    $0x0, %eax

0x0804837a <main+14>:   add    $0xf, %eax

0x0804837d <main+17>:   add    $0xf, %eax

0x08048380 <main+20>:   shr    $0x4, %eax

0x08048383 <main+23>:   shl    $0x4, %eax

0x08048386 <main+26>:   sub    %eax, %esp

0x08048388 <main+28>:   movb   $0x41, 0xffffffff(%ebp) ;prepare the byte of ‘A’

0x0804838c <main+32>:   movsbl 0xffffffff(%ebp), %eax  ;put into eax

0x08048390 <main+36>:   push   %eax           ;push the third parameter, ‘A’ prepared in eax onto the stack, [ebp+16]

0x08048391 <main+37>:   push   $0x2            ;push the second parameter, 2 onto the stack, [ebp+12]

0x08048393 <main+39>:   push   $0x1            ;push the first parameter, 1 onto the stack, [ebp+8]

------------------------------------------------

0x08048395 <main+41>:   call   0x8048334 <TestFunc>   ;function call. Push the return address [0x0804839a] onto the stack, [ebp+4]

------------------------------------------------

0x0804839a <main+46>:   add    $0xc, %esp      ;cleanup the 3 parameters pushed on the stack at [ebp+8], [ebp+12] and [ebp+16] total up 12 bytes

0x0804839d <main+49>:   mov    $0x0, %eax

0x080483a2 <main+54>:   leave

0x080483a3 <main+55>:   ret

End of assembler dump.

TestFunc 部分汇编

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
(gdb) break TestFunc

Breakpoint 2 at 0x8048342: file testprog5.c, line 5.

(gdb) disass TestFunc

Dump of assembler code for function TestFunc:

0x08048334 <TestFunc+0>:        push   %ebp                 ;push the previous stack frame pointer onto the stack, [ebp+0]

0x08048335 <TestFunc+1>:        mov    %esp, %ebp      ;copy the ebp into esp, now the ebp and esp are pointing at the same address, creating new stack frame [ebp+0]

0x08048337 <TestFunc+3>:        push   %edi                   ;save/push edi register, [ebp-4]

0x08048338 <TestFunc+4>:        push   %esi                   ;save/push esi register, [ebp-8]

0x08048339 <TestFunc+5>:        sub    $0x20, %esp       ;subtract esp by 32 bytes for local variable and buffer if any, go to [ebp-40]

0x0804833c <TestFunc+8>:        mov    0x10(%ebp), %eax      ;move by pointer, [ebp+16] into the eax,[ebp+16]à ‘A’?

0x0804833f <TestFunc+11>:       mov    %al, 0xfffffff7(%ebp)     ;move by pointer, byte of al into [ebp-9]
0x08048342 <TestFunc+14>:       movl   $0x3, 0xfffffff0(%ebp)  ;move by pointer, 3 into [ebp-16]
0x08048349 <TestFunc+21>:       movl   $0x4, 0xffffffec(%ebp) ;move by pointer, 4 into [ebp-20]

0x08048350 <TestFunc+28>:       lea    0xffffffd8(%ebp), %edi  ;load address [ebp-40] into edi

0x08048353 <TestFunc+31>:       mov    $0x8048484, %esi     ;move string into esi

0x08048358 <TestFunc+36>:       cld                                            ;clear direction flag

0x08048359 <TestFunc+37>:       mov    $0x7, %ecx                  ;move 7 into ecx as counter for the array

0x0804835e <TestFunc+42>:       repz movsb %ds:(%esi), %es:(%edi)    ;start copy by pointer from esi to edi register

0x08048360 <TestFunc+44>:       mov    $0x0, %eax                   ;move return value into eax, 0 in this case, no return value

0x08048365 <TestFunc+49>:       add    $0x20, %esp                 ;add 32 bytes to esp, back to [ebp-8]

0x08048368 <TestFunc+52>:       pop    %esi                         ;restore the esi, [ebp-4]

0x08048369 <TestFunc+53>:       pop    %edi                         ;restore the edi, [ebp+0]

0x0804836a <TestFunc+54>:       leave          ;restoring the ebp to the previous stack frame, [ebp+4]

0x0804836b <TestFunc+55>:       ret               ;transfer control back to calling function using the saved return address at [ebp+8]

End of assembler dump.

​ 这里使用的约定是允许被调用者在返回之前弄乱 EAX、ECX 和 EDX 寄存器的值。 因此，如果调用者想要保留 EAX、ECX 和 EDX 的值，则调用者必须在进行函数调用之前将它们显式保存在堆栈中。 另一方面，被调用者必须恢复 EBX、ESI 和 EDI 寄存器的值。 如果被调用者对这些寄存器进行了更改，则被调用者还必须将受影响的寄存器保存在堆栈中，并在稍后返回之前恢复原始值。

​ 4 个字节或更少的返回值存储在 EAX 寄存器中。 如果需要超过 4 个字节的返回值，则调用者将额外的第一个参数传递给被调用者。 这个额外的参数是应该存储返回值的位置的地址。 例如，对于 C 函数调用： 

1
x = TestFunc(a, b, c);

将会被转化成如下的样子：

1
TestFunc(&x, a, b, c);

请注意，这只发生在返回超过 4 个字节的函数调用中。 在我们的示例中，调用者是 main() 函数，即将调用函数 TestFunc()，即被调用者。 在函数调用之前，main() 将 ESP 和 EBP 寄存器用于其自己的堆栈帧。 首先，main() 将寄存器 EAX、ECX 和 EDX 的内容压入堆栈（如果有）（图中未显示）。 这是一个可选步骤，仅当需要保留这三个寄存器的内容时才执行。

第一步：将参数按照从右到左的顺序压入栈中

1
2
3
4
5
6
7
8
9
TestFunc(1, 2, 'A');
0x08048388 <main+28>:   movb   $0x41, 0xffffffff(%ebp);prepare the byte of ‘A’
0x0804838c <main+32>:   movsbl 0xffffffff(%ebp), %eax ;put into eax

0x08048390 <main+36>:   push   %eax                   ;push the third parameter, ‘A’ prepared in eax onto the stack, [ebp+16]

0x08048391 <main+37>:   push   $0x2                   ;push the second parameter, 2 onto the stack [ebp+12]

0x08048393 <main+39>:   push   $0x1                   ;push the first parameter, 1 ont the stack, [ebp+8]

栈变化如图

之前：

Initial state of the stack

之后：

Pushing the parameters on the stack from right to left

第二步：调用 TestFunc()，将函数返回地址，即 CALL 指令之后的地址压入堆栈。

1
0x08048395 <main+41>:   call   0x8048334 <TestFunc>   ;function call.Push the return address [0x0804839a] onto the stack, [ebp+4]

该指令调用函数TestFunc()，其开头位于地址0x8048334。

当执行 CALL 指令时，EIP 寄存器的内容被压入堆栈。 EIP 寄存器包含紧跟在 CALL 指令之后的指令的偏移量，供以后用作函数的返回地址。 由于 EIP 寄存器指向 main() 中的下一条指令，因此返回地址现在位于堆栈顶部。 在 CALL 指令之后，下一个执行周期从名为 TestFunc 的标签开始。

之前：

Ready to call a function, operation transferred to the function

之后：

Push the function return address onto the stack

第三步：设置堆栈帧，保存寄存器，为局部变量和缓冲区分配存储空间。

当在函数 TestFunc() 中，被调用者获得程序的控制权时，它必须做 3 件事：建立自己的堆栈帧，根据需要保存寄存器 EBX、ESI 和 EDI 的内容并为本地存储分配空间（ 局部变量和缓冲区）。 这称为function prolog，TestFunc() 的示例如下所示

1
2
3
4
5
6
7
8
9
0x08048334 <TestFunc+0>:        push   %ebp        ;push the previous stack frame pointer onto the stack, [ebp+0]

0x08048335 <TestFunc+1>:        mov    %esp, %ebp   ;copy the ebp into esp, now the ebp and esp are pointing at the same address,creating new stack frame [ebp+0]

0x08048337 <TestFunc+3>:        push   %edi        ;save/push edi register, [ebp-4]

0x08048338 <TestFunc+4>:        push   %esi        ;save/push esi register, [ebp-8]

0x08048339 <TestFunc+5>:        sub    $0x20, %esp  ;subtract esp by 32 bytes for local variable and buffer if any, go to [ebp-40]

EBP 寄存器当前指向 main() 堆栈帧中的位置。 必须保留此值。 因此，EBP 被压入堆栈。 然后ESP的内容被传送到EBP。 这允许函数的参数被引用为 EBP 的偏移量，并释放堆栈寄存器-ESP 来做其他事情。

Pushing the EBP onto the stack, saving the previous stack frame

因此，几乎所有的 C 函数都会以以下两条汇编指令开始：

1
2
0x08048334 <TestFunc+0>:        push   %ebp
0x08048335 <TestFunc+1>:        mov    %esp, %ebp

在函数内部，参数从基指针 (EBP) 的正偏移量访问，局部变量作为基指针的负偏移量访问。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
push        ebp                ; Save ebp, the previous frame
mov         ebp, esp           ; Set the new stack frame pointer
sub         esp, localbytes    ; Allocate space for locals
push        <registers>        ; Optionally, save registers if any

e.g.

00411A30  push        ebp        ; Save ebp

00411A31  mov         ebp, esp   ; Set the new stack frame pointer

00411A33  sub         esp, 0C0h  ; Allocate space for locals

00411A39  push        ebx        ; optionally, save register if any

00411A3A  push        esi        ; save register if any

00411A3B  push        edi        ; save register if any

localbytes 变量表示局部变量所需的堆栈上的字节数，而 变量是一个占位符，表示要保存在堆栈上的寄存器列表（如果有）。 压入寄存器后，您可以将任何其他适当的数据放在堆栈中。 在 Linux/Intel 中，最后两条指令的顺序互换，如下面的代码所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
push        %ebp                ; Save ebp
mov         %ebp, %esp          ; Set stack frame pointer
push        <registers>         ; optionally, save registers if any
sub         localbytes, %esp    ; Allocate space for locals

e.g.

push   %ebp         ;push the previous stack frame pointer onto the stack, [ebp+0]

mov    %esp, %ebp    ;copy the ebp into esp, now the ebp and esp are pointing at the same address, creating new stack frame [ebp+0]

push   %edi         ;save/push edi register, [ebp-4]

push   %esi         ;save/push esi register, [ebp-8]

sub    $0x20, %esp   ;subtracts esp by 32 bytes for local variable and buffer if any, go to [ebp-40]

在我们的程序示例中，看起来 ESI 和 EDI 寄存器的内容已被保留，这意味着 TestFunc() 将使用这些寄存器。 这就是为什么这些寄存器被压入堆栈的原因。

1
2
3
0x08048337 <TestFunc+3>:    push   %edi  ;save/push edi register, [ebp-4]

0x08048338 <TestFunc+4>:    push   %esi  ;save/push esi register, [ebp-8]

然后，TestFunc() 必须为其局部变量分配空间。 它还必须为它可能需要的任何临时存储（缓冲区）分配空间。 例如，TestFunc() 中的一些 C 语句可能有表达式来完成函数的任务。 在表达式/语句操作期间，可能存在必须存储在某处的中间值。 这些位置通常称为缓冲区，因为它们可以重用于下一个表达式、动态分配和释放的数据。 在这个程序示例中，从堆栈指针中减去了 32 (0x20) 个字节，即局部变量的 esp：

1
0x08048339 <TestFunc+5>:    sub    $0x20, %esp     ;subtract esp by 32 bytes for local variable and buffer if any, go to [ebp-40]

然后将局部变量压入堆栈。 请记住，TestFunc() 不执行任何操作，因此没有用于函数操作的缓冲区。 这里的操作似乎是假的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
0x0804833c <TestFunc+8>:    mov    0x10(%ebp), %eax       ;move by pointer, [ebp+16] into the eax, [ebp+16]à‘A’?

0x0804833f <TestFunc+11>:   mov    %al, 0xfffffff7(%ebp) ;move by pointer, byte of al into [ebp-9]

0x08048342 <TestFunc+14>:   movl   $0x3, 0xfffffff0(%ebp);move by pointer, 3 into [ebp-16]

0x08048349 <TestFunc+21>:   movl   $0x4, 0xffffffec(%ebp);move by pointer, 4 into [ebp-20]

0x08048350 <TestFunc+28>:   lea    0xffffffd8(%ebp), %edi ;load address [ebp-40] into edi

0x08048353 <TestFunc+31>:   mov    $0x8048484, %esi       ;move string into esi

0x08048358 <TestFunc+36>:   cld                          ;clear direction flag

0x08048359 <TestFunc+37>:   mov    $0x7, %ecx         ;move 7 into ecx as counter for the array

0x0804835e <TestFunc+42>:   repz movsb %ds:(%esi), %es:(%edi) ;start copy by pointer from esi to edi register

现在可以执行函数 TestFunc() 的主体。 这可能涉及推入和弹出堆栈。 因此，堆栈指针 ESP 可能会上下移动，但 EBP 寄存器保持固定。 这很方便，因为这意味着我们始终可以将第一个函数参数称为 [EBP + 8]，而不管函数中进行了多少推入和弹出。 函数 TestFunc() 的执行也可能涉及其他函数调用，甚至对 TestFunc() 的递归调用。 但是，只要在从这些调用返回时恢复 EBP 寄存器，对参数、局部变量和缓冲区的引用就可以继续作为 EBP 的偏移量进行。 不同的汇编语言/编译器之间的过程序言非常一致，因为它们可能使用相同的函数调用约定。

之前：

Set up the stack frame, save registers, allocates storage for local variables and the buffer

之后：

Set up the stack frame, save registers, allocates storage for local variables and the buffer and processing happens

​ 堆栈总是向下增长（从高内存地址到低内存地址）。 要访问局部变量，请通过从 ebp 中减去适当的值以及从 ebp 开始从 [ebp+8] 开始的具有正偏移量的参数来计算 ebp 的负偏移量。

​ 如果有的话，在将控制权返回给调用者之前，被调用者 TestFunc() 必须首先安排将返回值存储在 EAX 寄存器中。 我们已经讨论了带返回值的函数调用如何存储值。 在我们的程序示例中，0 被移动到 EAX，因为没有返回值。

1
0x08048360 <TestFunc+44>:    mov    $0x0, %eax   ;move return value into eax,0 in this case, no return value

第四步：拆除堆栈帧（释放局部变量和缓冲区的存储空间）

这一步称为function epilog。 以下是我们的 Linux/Intel程序示例，它使用 __cdelc 函数调用约定，其中堆栈清理由调用者完成。 在此之前，预拆解是由被调用方完成的：

1
2
3
4
5
0x08048365 <TestFunc+49>:   add    $0x20, %esp     ;add 32 bytes to esp, back to [ebp-8]

0x08048368 <TestFunc+52>:   pop    %esi           ;restore the esi, [ebp-4]

0x08048369 <TestFunc+53>:   pop    %edi           ;restore the edi, [ebp+0]

32 字节被添加到 esp，然后 esp 现在指向 [ebp-8] 以便破坏局部变量和缓冲区。 然后 esi ([ebp-4]) 和 edi ([ebp-8]) 从堆栈中弹出。 esp and ebp 现在指向之前保存的 ebp [ebp+0]。

不同的汇编语言/编译器之间的函数结语不一致，原因之一是如前所述使用的不同函数调用约定。 以下是使用 __cdecl 的函数结语代码示例（Windows/Intel），其中堆栈清理由调用者完成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
...

pop         <registers>   ; Restore registers

mov         esp, ebp      ; Restore stack pointer

pop         ebp           ; Restore ebp

ret                      ; Return from function

--------Back to the calling function------------

add         esp, <localbytes>     ; cleanup the parameters

...

e.g

...

00411A6A  pop         edi

00411A6B  pop         esi

00411A6C  pop         ebx

00411A6D  mov         esp, ebp

00411A6F  pop         ebp

00411A70  ret

----------Back to the calling function------------

00411AB9  add         esp, 8

...

之前：

Dismantling the stack frame

之后：

Dismantling the stack frame, restore the previous stack frame

STEP 5：函数调用返回，紧接CALL指令后进入下一条指令

1
2
3
4
0x0804836a <TestFunc+54>:    leave   ;restoring the ebp to the previous stack frame, [ebp+4]

0x0804836b <TestFunc+55>:    ret     ;transfer control back to calling function using the saved return address at [ebp+8]

旧的帧指针 B（保存的前一个 EBP）然后从堆栈帧中弹出。 实际上，这会将 EBP 移回前一个调用者堆栈帧 (B) 的底部，并且 esp 现在指向返回地址。 然后返回地址被弹出并加载到 EIP 中。 控制权现在转移到 main()。 main() 中的以下代码表明已经从 esp 中减去了 12 个字节

1
0x0804839a <main+46>:   add    $0xc, %esp   ;cleanup the 3 parameters pushed on the stack at [ebp+8], [ebp+12] and [ebp+16]total up is 12 bytes = 0xc

这使得三个参数离开堆栈（4 字节 x 3 = 12 字节）并且 esp 现在指向前一个堆栈帧 (T) 的顶部。 此时TestFunc()栈帧已经被拆除，栈帧的状态已经恢复到前一栈帧，如步骤1。

之前：

Return from function call

之后：

Return from function call, the stack has been destroyed back to the initial state

本节的主要目的是演示函数调用过程中栈帧的构造和销毁。