【好玩】缓冲区溢出攻击实验

converse

这是出自《深入理解计算机系统》的一道题目：

1. 
   
2. /* Bomb program that is solved using a buffer overflow attack */
   
3. 
   
4. #include <stdio.h>;
   
5. #include <stdlib.h>;
   
6. #include <ctype.h>;
   
7. 
   
8. /* Like gets, except that characters are typed as pairs of hex digits.
   
9.    Nondigit characters are ignored.  Stops when encounters newline */
   
10. char *getxs(char *dest)
    
11. {
    
12.   int c;
    
13.   int even = 1; /* Have read even number of digits */
    
14.   int otherd = 0; /* Other hex digit of pair */
    
15.   char *sp = dest;
    
16.   while ((c = getchar()) != EOF && c != '\n') {
    
17.     if (isxdigit(c)) {
    
18.       int val;
    
19.       if ('0' <= c && c <= '9')
    
20.         val = c - '0';
    
21.       else if ('A' <= c && c <= 'F')
    
22.         val = c - 'A' + 10;
    
23.       else
    
24.         val = c - 'a' + 10;
    
25.       if (even) {
    
26.         otherd = val;
    
27.         even = 0;
    
28.       } else {
    
29.         *sp++ = otherd * 16 + val;
    
30.         even = 1;
    
31.       }
    
32.     }
    
33.   }
    
34.   *sp++ = '\0';
    
35.   return dest;
    
36. }
    
37. 
    
38. /* $begin getbuf-c */
    
39. int getbuf()
    
40. {
    
41.     char buf[12];
    
42.     getxs(buf);
    
43.     return 1;
    
44. }
    
45. 
    
46. void test()
    
47. {
    
48.   int val;
    
49.   printf("Type Hex string:");
    
50.   val = getbuf();
    
51.   printf("getbuf returned 0x%x\n", val);
    
52. }
    
53. /* $end getbuf-c */
    
54. 
    
55. int main()
    
56. {
    
57. 
    
58.   int buf[16];
    
59.   /* This little hack is an attempt to get the stack to be in a
    
60.      stable position
    
61.   */
    
62.   int offset = (((int) buf) & 0xFFF);
    
63.   int *space = (int *) alloca(offset);
    
64.   *space = 0; /* So that don't get complaint of unused variable */
    
65.   test();
    
66.   return 0;
    
67. }
    

复制代码

题目的要求是，在getbuf函数中也许“显然”地会返回1，通过输入一个数据使这个函数返回0xdeadbeef，就是在test函数中地printf中打印地是0xdeadbeef.

我大概有了思路，做着玩玩，晚上回来再说。

FreeGnu

要是能来篇
堆的溢出或shellcode的编写就更好了
期望中......

converse

思路已经想到了，还没有时间实践，分析如下：
当函数test在调用getbuf的时候，栈的分布情况大致如下：

1. 
   
2. |                                    |     <- test的栈帧  （地址在高位）
   
3. |为局部变量分配空间（val）      |
   
4. |   其他的一些空间        |
   
5. |   返回地址                     |
   
6. |                                    |     <-getbuf的栈帧 （地址在低位）
   
7. |为局部变量分配空间(buf变量) |
   
8. |   其他的一些空间        |
   
9. |   返回地址              |
   
10. |                                    |
    

复制代码

而getbuf中的局部变量buf数组就是紧靠着getbuf栈帧的数据空间，当这个空间溢出的时候，数据就会跑到test函数的栈帧中。
看下面的test函数的汇编代码：

1. 
   
2. 00000115 <_test>;:
   
3. 115:        55                           push   %ebp
   
4. 116:        89 e5                        mov    %esp,%ebp
   
5. 118:        83 ec 18                     sub    $0x18,%esp
   
6. 11b:        c7 04 24 ee 00 00 00         movl   $0xee,(%esp)
   
7. 122:        e8 00 00 00 00               call   127 <_test+0x12>;
   
8. 127:        e8 aa ff ff ff               call   d6 <_getbuf>;
   
9. 12c:        89 45 fc                     mov    %eax,0xfffffffc(%ebp)
   
10. 12f:        8b 45 fc                     mov    0xfffffffc(%ebp),%eax
    
11. 132:        89 44 24 04                  mov    %eax,0x4(%esp)
    
12. 136:        c7 04 24 ff 00 00 00         movl   $0xff,(%esp)
    
13. 13d:        e8 00 00 00 00               call   142 <_test+0x2d>;
    
14. 142:        c9                           leave  
    
15. 143:        c3                           ret   
    

复制代码

注意到12c那一行，是把调用getbuf函数的返回值传到局部变量0xfffffffc(%ebp)中，就是val，接下来的一行就是把这个局部变量传到eax寄存器再由寄存器传到test栈帧的后面然后再调用printf函数。

我的修改思路如下，反汇编出从getbuf函数的栈帧中buf数组那部分直到test中val变量之间的代码，其他的部分不改变，改变的只有以下两个部分：
1）修改test函数的返回地址，使这个地址指向12f那一行，就是说把
mov    %eax,0xfffffffc(%ebp)这一行跳过，直接把变量val的值传到printf中
2）找到val在栈帧所在的位置，把这个位置的代码改为我们所要的，也就是0xdeadbeef.

思路大致如上面所说，明天有时间实践看看。

不知道说清楚没有，大家给点意见。

converse

简而言之,修改后的test函数是这样的:

1. 
   
2. void test()
   
3. {
   
4.   int val = 0xdeadbeef;                  //把val变量改为我们需要的值
   
5.   printf("Type Hex string:");
   
6.   //val = getbuf();                          //单独调用getbuf函数,不把返回值放在val中
   
7.   getbuf();
   
8.   printf("getbuf returned 0x%x\n", val);
   
9. }
   
10. 
    

复制代码

aero

在《黑客就这么几招》中有很详细的缓冲区溢出漏洞的原理和shellcode的编写。

^_^，当初在书店看到这书，本来打算翻开嘲笑一翻，因为这个名字太张扬了。不过，看了却发现，有很多废话（教授工具和讲述历史）以外，还是有些内容的。尤其将缓冲区溢出漏洞和格式化字符串漏洞的原理讲述的尤为详细。

aero

converse，你的思路错了。题目的意思，不是想让你覆盖val的值，这样做没有什么意义。而是想让你通过getbuf函数返回一个地址。这才是有用的。

我们能控制它返回一个值，我们就能进一步让这个值覆盖getbuf函数返回时要执行的指令。如果我们在我们控制的这个返回值的地址上，放上一个shellcode。那么就能让程序“脱轨”，而进入我们设定的“轨道”。

converse

是的，现在这样看应该有很多办法实现，因为既然找到了覆盖返回时执行指令的办法就可以为所欲为了，我晚上再做做看吧。

aero

converse兄，你的思路还是正确的，偶刚才说错了，^_^，莫怪。

呵呵，刚才深入搞了一下，这个还真不简单。这个题要求我们溢出，让程序“脱轨”一段后，还要回到原来的“轨道”上去，继续打印出val的值。不能是像平常的溢出攻击一样，让它“脱轨”，走我们设定的“轨道”就好了。所以想了一下，要做的事情有4步：

1、计算出getbuf函数下一条指令（给val赋值）的下一条指令的地址：A。
2、计算出getbuf函数返回的栈帧的地址：B。B中原来存放的是getbuf函数下一条指令（给val赋值）的地址：C。
3、通过输入精心设计的输入串，将A（内容）写入B（地址），即用A，覆盖C，使函数返回的时候跳过给val赋值的部分。使火车“脱轨”，绕过一个“站点”后，继续回到原来的铁路上。
4、精心设计的输入串，同时也要用0x覆盖val变量，就像converse说的。

关键就在于计算A和B。A要计算出绝对的数值，B起码要计算出相对的数值。A的计算，单从程序上看，实在想不出什么办法。莫非要去分析gcc将每条指令都翻译成了什么，占多少字节？B的计算，相对比较容易，可以从在栈上分配的空间计算出来，可是，汇编了C程序分析了一下。gcc总是在分配空间的时候很“大方”，总是多让出一些字节（防止溢出攻击？），而且，郁闷的是，让出的这些空间，大小不是固定的。有的函数是8个字节，有的函数是12个字节，真是找不到规律。难道要去读gcc的源码？

搞了一上午，不能搞了。今天任务要完不成了。得去工作了。唉，晚上回来在说吧。

win_hate

aero

哈哈哈，好啊，好啊。来，来，讲讲原理。讲讲怎么做的。