数学建模社区-数学中国

标题: 最详细的黑客教程25 [打印本页]
作者: 韩冰    时间: 2004-10-6 23:32
标题: 最详细的黑客教程25

第二十五章------溢出　

4 h- g3 @9 o( h7 D# k

简单说明： % p" m) E; o+ K( v4 J3 D7 H溢出对我们这些小鸟们属于比较高级的玩意了。所以在这里也不准备多提，否则就违反了这篇文章写给初学者的初衷了。+ s4 v2 u# ^+ Y6 b1 ?) a 缓冲区溢出1 w) M' y' r7 z5 `( K 缓冲区是内存中存放数据的地方。在程序试图将数据放到计算机内存中的某一位置，但没有足够空间时会发生缓冲区溢出。* H& W) R( `0 M! V- W 缓冲区是程序运行时计算机内存中的一个连续的块，它保存了给定类型的数据。问题随着动态分配变量而出现。为了不用太多的内存，一个有动态分配变量的程序在程序运行时才决定给他们分配多少内存。如果程序在动态分配缓冲区放入太多的数据会有什么现象？它溢出了，漏到了别的地方。一个缓冲区溢出应用程序使用这个溢出的数据将汇编语言代码放到计算机的内存中，通常是产生root权限的地方。单单的缓冲区溢出，并不会产生安全问题。只有将溢出送到能够以root权限运行命令的区域才行。这样，一个缓冲区利用程序将能运行的指令放在了有root权限的内存中，从而一旦运行这些指令，就是以root权限控制了计算机。总结一下上面的描述。缓冲区溢出指的是一种系统攻击的手段，通过往程序的缓冲区写超出其长度的内容，造成缓冲区的溢出，从而破坏程序的堆栈，使程序转而执行其它指令，以达到攻击的目的。据统计，通过缓冲区溢出进行的攻击占所有系统攻击总数的80%以上。造成缓冲区溢出的原因是程序中没有仔细检查用户输入的参数。例如下面程序:?/P> % Z6 }) ]2 p$ T {4 Q

　　example0.c , G6 M7 C3 P1 [8 l8 i　　----------------------------------------------------------- W6 H' v# M3 ?& t( v" b5 z 　　void function(char *str) { $ l5 n* w, z7 L+ x6 x　　char buffer[16]; 9 e. |$ q, w5 h! j+ A( K, H　　- s' i- r1 N& g6 `" ^ 　　strcpy(buffer,str);& ~- N, t; H0 f2 L; L1 W 　　} 3 n0 Q$ C+ A1 L! G' r1 c　　-----------------------------------------------------------　

; `6 \( X* {: }8 B7 J1 i. R

上面的strcpy()将直接把str中的内容copy到buffer中。这样只要str的长度大于16，就会造成buffer的溢出，使程序运行出错。存在象strcpy这样的问题的标准函数还有strcat(),sprintf(),vsprintf(),gets(),scanf(),以及在循环内的getc(),fgetc(),getchar()等。在Ｃ语言中，静态变量是分配在数据段中的，动态变量是分配在堆栈段的。缓冲区溢出是利用堆栈段的溢出的。一个程序在内存中通常分为程序段，数据端和堆栈三部分。程序段里放着程序的机器码和只读数据，这个段通常是只读，对它的写操作是非法的。数据段放的是程序中的静态数据。动态数据则通过堆栈来存放。在内存中，它们的位置如下：　

f J! O0 i5 {" t& b/ n5 b

　　 ) I7 ]3 B. U( k z　　／――――――――\　　内存低端 M: J0 P5 p6 e D( Q o! ~　　|程序段| 3 c) ?) D2 l ~, e1 _. p% i( I　　|―――――――――|7 R" X; d, G# q5 J, C, \ 　　|数据段|# Y& d0 S1 X1 d* n: E 　　|―――――――――|6 r4 ~7 ?/ v3 |- @! O2 _% | 　　|堆栈|( G( |% E& j/ ~5 _! l' d0 ` 　　\―――――――――／内存高端　

; |- E: ~: L: n" X6 t% C, i

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

$ f) L( Y% y! H S1 A/ ~/ S( a0 \. v

　　下面举个例子：1 @$ x" n1 b) z 　　example1.c: - d6 q8 B% ~+ T9 V/ t　　------------------------------------------------------------( C+ _2 _4 q5 I/ S/ h/ P1 a7 e 　　void function(int a, int b, int c) {2 e: H2 v, ]3 E5 t; N0 [5 a% }5 P 　　char buffer1[5];- o. C4 {4 L0 [ 　　char buffer2[10];: h4 K$ ^; @# k7 | 　　}( B% T! B, n' j3 U 　　* E: A9 g1 L& S* T# g) L" @' e 　　void main() {0 @2 C% {/ m' n1 \0 S8 e3 M 　　function(1,2,3); E- ^% @* H9 N4 k& j' o! k5 g/ ]　　} 7 h3 ~, ]) [) P" n O5 L1 G　　-----------------------------------------------------------　

' |! d; B0 u: Z& b

为了理解程序是怎样调用函数function()的，使用-S选项，在Linux下，用gcc进行编译，产生汇编代码输出：　

' ~" p" K i/ `- g4 A8 J

　　$ gcc -S -o example1.s example1.c　

8 G! s" q1 k3 l

　　看看输出文件中调用函数的那部分：　

" u5 d. t* i5 a s; s4 _& x

　　pushl $3. W8 d5 U0 }0 l1 l 　　pushl $2 1 F0 m0 p8 D0 h$ u; q　　pushl $1: A% ?- G7 }8 p0 C+ g 　　call function　

' U% l4 f4 D) @# @+ i

　　这就将3个参数压到堆栈里了，并调用function()。指令call会将指令指针IP压入堆栈。在返回时，RET要用到这个保存的IP。在函数中，第一要做的事是进行一些必要的处理。每个函数都必须有这些过程：　

6 R/ F$ ^( d$ a ]5 g& ~

　　 . s( J" ]+ u# [- z9 _　　pushl %ebp$ I% R8 d, Z4 K' I+ s 　　movl %esp,%ebp/ F6 B7 f" P' u( ^ 　　subl $20,%esp　

+ x. ~. o, H4 N" X: w

这几条指令将EBP，基址指针放入堆栈。然后将当前SP拷贝到EBP。然后，为本地变量分配空间，并将它们的大小从SP里减掉。由于内存分配是以字为单位的，因此，这里的buffer1用了8字节（2个字，一个字4字节）。Buffer2用了12字节（3个字）。所以这里将ESP减了20。这样，现在，堆栈看起来应该是这样的。　

5 k/ s5 ^3 K$ p2 ~5 _: j& ]

+ Y5 |/ |5 M8 h @9 p2 N' { ^ 　　低端内存高端内存 4 J; G% L# h! f- s1 b9 R+ v　　buffer2 buffer1 sfp ret a b c ; c1 ]2 |1 y% }7 H& o$ h　　< ------ [ ][ ][ ][ ][ ][ ][ ] : Z# l. ~0 ]- u* j　　栈顶栈底. T2 F3 A1 Y L0 V: I! i, ] 　　- m0 b+ M$ v8 A: K7 x* ^9 m 　　缓冲区溢出就是在一个缓冲区里写入过多的数据。那怎样利用呢，看 * M# N) }8 U+ [一下下面程序：/ c* _6 [$ B6 l2 Z+ f 　　 ( R6 |: ^) Z$ j1 s, n　　 . w. ^2 `% R0 g( ^! J) l' l　　example2.c7 j; p [2 |1 v2 x$ a7 d; W 　　----------------------------------------------------------- + Y, [; p& r R+ @　　void function(char *str) { 5 I, z" M' D! ~; k- z8 _7 F4 j/ n　　char buffer[16];0 V3 j) ~& R" R" R% u8 u& d 　　 5 C+ c/ b6 W1 H- z& _7 L　　strcpy(buffer,str); / Q) e; H: B% k h7 B. h　　} . ?3 m; g- z( v, S, M! Y% e　　9 E8 m$ j& U$ R6 t/ ] 　　void main() {' C$ D4 {( O8 O& p" o( F( ~2 Q- l8 B 　　char large_string[256]; ) X* G& o* n2 l) r' |4 q　　int i;. u/ j, O! Y+ R, H 　　) E2 r2 [$ C3 _# o; G# G 　　for( i = 0; i < 255; i++) ( B7 |1 N- k: s3 z" v+ e2 P　　large_string = A; 1 y; e$ w/ |. S3 \. W7 A　　$ G1 F/ [+ P% g3 J* z3 f: B 　　function(large_string);/ @+ n9 m# i! _ S- x" [ 　　}4 D% l8 I1 n( k5 ?6 P# { ]0 c 　　------------------------------------------------------------　

4 f1 |. m; L) J u1 r- A6 C5 F. H

这个程序是一个经典的缓冲区溢出编码错误。函数将一个字符串不经过边界检查，拷贝到另一内存区域。当调用函数function()时，堆栈如下： 4 I' I8 v/ m" a9 Q　　* y {0 c# p \# T6 I% S1 W6 z 　　低内存端buffer sfp ret *str高内存端+ S4 U* s3 R1 O2 n1 Z% X0 K% ? 　　< ------ [ ][ ][ ][ ]# H) Y- Z' }0 O 　　栈顶栈底　

. L& S1 l; \& L

很明显，程序执行的结果是"Segmentation fault (core dumped)"或类似的出错信息。因为从buffer开始的256个字节都将被*str的内容A覆盖，包括sfp, ret,甚至*str。A的十六进值为0x41，所以函数的返回地址变成了0x41414141, 这超出了程序的地址空间，所以出现段错误。可见，缓冲区溢出允许我们改变一个函数的返回地址。通过这种方式，可以改变程序的执行顺序。　

9 h9 U1 i; Z0 t; Z4 F- Y8 I

由于是简单介绍给大家熟悉一下，所以在这里不给出软件了，如果大家有需要的话，可以在附录中找到。　

9 x9 p, k* p, x

相关资料：* Z) [' r' c. j2 u y p9 M: \- z3 { 缓冲区溢出及其攻击 http://www.sixthroom.com/ailan/f ;... 3&RootID=312&ID=3125 O1 o" @, |, f3 M% ]# J 缓冲区溢出原理分析 http://www.sixthroom.com/ailan/f ;... 3&RootID=313&ID=313 6 T% E0 ]2 l+ n4 l: J) B( ?6 ]更多资料请到 www.sixthroom.com　





欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5