堆栈溢出技术从入门到精通

helendcany

堆栈溢出技术从入门到精通

虽然溢出在程序开发过程中不可完全避免，但溢出对系统的威胁是巨大的，由于系统的特殊性，溢出发生时攻击者可以利用其漏洞来获取系统的高级权限root，因此本文将详细介绍堆栈溢出技术……

在您开始了解堆栈溢出前，首先你应该了解win32汇编语言，熟悉寄存器的组成和功能。你必须有堆栈和存储分配方面的基础知识，有关这方面的计算机书籍很多，我将只是简单阐述原理，着重在应用。其次，你应该了解linux，本讲中我们的例子将在linux上开发。

1、首先复习一下基础知识。

从物理上讲，堆栈是就是一段连续分配的内存空间。在一个程序中，会声明各种变量。静态全局变量是位于数据段并且在程序开始运行的时候被加载。而程序的动态的局部变量则分配在堆栈里面。

从操作上来讲，堆栈是一个先入后出的队列。他的生长方向与内存的生长方向正好相反。我们规定内存的生长方向为向上，则栈的生长方向为向下。压栈的操作push=ESP-4，出栈的操作是pop=ESP+4.换句话说，堆栈中老的值，其内存地址，反而比新的值要大。请牢牢记住这一点，因为这是堆栈溢出的基本理论依据。

在一次函数调用中，堆栈中将被依次压入：参数，返回地址，EBP。如果函数有局部变量，接下来，就在堆栈中开辟相应的空间以构造变量。函数执行结束，这些局部变量的内容将被丢失。但是不被清除。在函数返回的时候，弹出EBP，恢复堆栈到函数调用的地址,弹出返回地址到EIP以继续执行程序。

在C语言程序中，参数的压栈顺序是反向的。比如func(a,b,c)。在参数入栈的时候，是：先压c，再压b,最后a。在取参数的时候，由于栈的先入后出，先取栈顶的a，再取b,最后取c。这些是汇编语言的基础知识，用户在开始前必须要了解这些知识。

2、现在我们来看一看什么是堆栈溢出。

运行时的堆栈分配

堆栈溢出就是不顾堆栈中数据块大小，向该数据块写入了过多的数据，导致数据越界，结果覆盖了老的堆栈数据。

例如程序一：

#include   int main ( ) ) {+ a0 k  `8 C# ~1 T/ h! g% X% F{ 8 E8 Q0 ^1 y2 V/ l  nchar name[8]; - X, m, b6 {! M/ Q. P- nprintf("Please type your name: "); 0 q; |8 c8 ~8 [/ N* H' t% X6 {4 D( ^gets(name);   P; _, x, h  Y6 j; O! @printf("Hello, %s!", name); 3 O, ~8 y9 F( V& Zreturn 0; $ m, I: ?! F5 K2 D, A% s}

编译并且执行，我们输入ipxodi,就会输出Hello,ipxodi!。程序运行中，堆栈是怎么操作的呢?

在main函数开始运行的时候，堆栈里面将被依次放入返回地址，EBP。

我们用gcc -S 来获得汇编语言输出，可以看到main函数的开头部分对应如下语句：

pushl %ebp movl %esp,%ebp subl $8,%esp

首先他把EBP保存下来，，然后EBP等于现在的ESP，这样EBP就可以用来访问本函数的局部变量。之后ESP减8，就是堆栈向上增长8个字节，用来存放name[]数组。最后，main返回，弹出ret里的地址，赋值给EIP，CPU继续执行EIP所指向的指令。

堆栈溢出

现在我们再执行一次，输入ipxodiAAAAAAAAAAAAAAA,执行完gets(name)之后，由于我们输入的name字符串太长，name数组容纳不下，只好向内存顶部继续写‘A’。由于堆栈的生长方向与内存的生长方向相反，这些‘A’覆盖了堆栈的老的元素。 我们可以发现，EBP，ret都已经被‘A’覆盖了。在main返回的时候，就会把‘AAAA’的ASCII码：0x41414141作为返回地址，CPU会试图执行0x41414141处的指令，结果出现错误。这就是一次堆栈溢出。

3、如何利用堆栈溢出

我们已经制造了一次堆栈溢出。其原理可以概括为：由于字符串处理函数(gets，strcpy等等)没有对数组越界加以监视和限制，我们利用字符数组写越界，覆盖堆栈中的老元素的值，就可以修改返回地址。

在上面的例子中，这导致CPU去访问一个不存在的指令，结果出错。事实上，当堆栈溢出的时候，我们已经完全的控制了这个程序下一步的动作。如果我们用一个实际存在指令地址来覆盖这个返回地址，CPU就会转而执行我们的指令。

在UINX/linux系统中，我们的指令可以执行一个shell，这个shell将获得和被我们堆栈溢出的程序相同的权限。如果这个程序是setuid的，那么我们就可以获得root shell。下一讲将叙述如何书写一个shell code。

如何书写一个shell code

一：shellcode基本算法分析

在程序中，执行一个shell的程序是这样写的：

shellcode.c ------------------------------------------------------------------------ / ?+ _6 F  l  x/ x#include   ) G4 l2 U& x2 Pvoid main() { char *name[2]; 9 i% ]& ?8 C7 M! m+ Cname[0] = "/bin/sh" name[1] = NULL; execve(name[0], name, NULL); / @* ~3 u" L% k. H} : t4 l! r& _* W% k. _------------------------------------------------------------------------

execve函数将执行一个程序。他需要程序的名字地址作为第一个参数。一个内容为该程序的argv(argv[n-1]=0)的指针数组作为第二个参数，以及(char*) 0作为第三个参数。

我们来看以看execve的汇编代码：

[nkl10]$Content$nbsp;gcc -o shellcode -static shellcode.c , Y, {9 ?% ?% B7 ^[nkl10]$Content$nbsp;gdb shellcode (gdb) disassemble __execve Dump of assembler code for function __execve: 0x80002bc <__execve>: pushl %ebp ; ! {! M% L& {  P: T. p9 x0x80002bd <__execve+1>: movl %esp,%ebp , t; k; m0 W2 z) j8 M6 V;上面是函数头。 0x80002bf <__execve+3>: pushl %ebx ;保存ebx 0 G/ w5 s9 ~+ p0x80002c0 <__execve+4>: movl $0xb,%eax # l( r, w, w2 [  ~3 a! F;eax=0xb，eax指明第几号系统调用。 0x80002c5 <__execve+9>: movl 0x8(%ebp),%ebx : J' `# J  v+ u, C! U# P. h. A$ c;ebp+8是第一个参数"/bin/sh\0" 6 ]# W/ b4 J/ v/ |0 h: f0x80002c8 <__execve+12>: movl 0xc(%ebp),%ecx , ]( x! s, I3 A: h4 \6 C/ ]5 C;ebp+12是第二个参数name数组的地址 1 }8 {% l% U! O+ t. Q$ j0x80002cb <__execve+15>: movl 0x10(%ebp),%edx ; m. K# W7 x$ P3 N2 F# V1 X;ebp+16是第三个参数空指针的地址。 ;name[2-1]内容为NULL，用来存放返回值。 9 a5 S7 ^" g% W; B" X0x80002ce <__execve+18>: int $0x80 ;执行0xb号系统调用(execve) * I4 j8 |) C% ]4 G* [0x80002d0 <__execve+20>: movl %eax,%edx ;下面是返回值的处理就没有用了。 0x80002d2 <__execve+22>: testl %edx,%edx 0x80002d4 <__execve+24>: jnl 0x80002e6 <__execve+42> % D$ \6 \1 h1 w. G0x80002d6 <__execve+26>: negl %edx ; g  b9 c7 U: g; [, X9 w5 u* q0x80002d8 <__execve+28>: pushl %edx 0x80002d9 <__execve+29>: call 0x8001a34 # r3 c5 i, V/ L& I2 r+ [<__normal_errno_location> 0x80002de <__execve+34>: popl %edx 2 `8 A0 _! H& w0x80002df <__execve+35>: movl %edx,(%eax) 0x80002e1 <__execve+37>: movl $0xffffffff,%eax ' r0 k' R$ k1 A- r8 U3 ]) f0 j* j0x80002e6 <__execve+42>: popl %ebx - S. T8 L$ S, _* r5 m: U- w0x80002e7 <__execve+43>: movl %ebp,%esp 0x80002e9 <__execve+45>: popl %ebp 0x80002ea <__execve+46>: ret . [& i  o1 X( |; P, H0 D0x80002eb <__execve+47>: nop End of assembler dump.

经过以上的分析，可以得到如下的精简指令算法：

movl $execve的系统调用号,%eax movl "bin/sh\0"的地址,%ebx . l( \* g: Q' mmovl name数组的地址,%ecx movl name[n-1]的地址,%edx , S- t- A# F! Y+ H9 bint $0x80 ;执行系统调用(execve)

当execve执行成功后，程序shellcode就会退出，/bin/sh将作为子进程继续执行。可是，如果我们的execve执行失败，(比如没有/bin/sh这个文件)，CPU就会继续执行后续的指令，结果不知道跑到哪里去了。所以必须再执行一个exit()系统调用，结束shellcode.c的执行。

我们来看以看exit(0)的汇编代码：

(gdb) disassemble _exit Dump of assembler code for function _exit: 0x800034c <_exit>: pushl %ebp 0x800034d <_exit+1>: movl %esp,%ebp 0x800034f <_exit+3>: pushl %ebx 0x8000350 <_exit+4>: movl $0x1,%eax ;1号系统调用 0x8000355 <_exit+9>: movl 0x8(%ebp),%ebx ;ebx为参数0 3 D8 S6 S! D* }+ ^4 O! z4 V  m- f6 h0x8000358 <_exit+12>: int $0x80 ;引发系统调用 0x800035a <_exit+14>: movl 0xfffffffc(%ebp),%ebx . k, z  h: i+ ?! {0 Z0x800035d <_exit+17>: movl %ebp,%esp / B/ Y  b4 t$ J# J' N+ G. [0x800035f <_exit+19>: popl %ebp 0x8000360 <_exit+20>: ret * b& Y( \1 t0 d- F0x8000361 <_exit+21>: nop ! V5 J+ j1 P7 t8 n& |' X! h0x8000362 <_exit+22>: nop ) V) U5 x2 {# @# R& {! Y# N0x8000363 <_exit+23>: nop , Z; T2 b( A* x. z  fEnd of assembler dump.

看来exit(0)〕的汇编代码更加简单：

movl $0x1,%eax ;1号系统调用 9 A" `! n5 w' d; Imovl 0,%ebx ;ebx为exit的参数0 int $0x80 ;引发系统调用

那么总结一下，合成的汇编代码为：

movl $execve的系统调用号,%eax # z8 n2 V( [, v$ q8 h/ ~- u- @movl "bin/sh\0"的地址,%ebx movl name数组的地址,%ecx movl name[n-1]的地址,%edx int $0x80 ;执行系统调用(execve) movl $0x1,%eax ;1号系统调用 6 D0 g( [7 `& g+ s* R- A% jmovl 0,%ebx ;ebx为exit的参数0 int $0x80 ;执行系统调用(exit)

; j& O$ ~4 ]1 u0 Y$ @  B+ _; a  l, c5 w

cj223356

学习一下，谢谢楼主分享、