How to solve?

Codegate CTF 2026 Writeup (PhantomCore)

Fri, 10 Apr 2026 00:00:00 GMT

Challenge: PhantomCore - Codegate CTF 2026 Quals

TL;DR

  ┌──────────────┐      ioctl       ┌──────────────┐      MMIO       ┌──────────────┐
  │  gpuctl-cli  │ ───────────────▶ │  gpuctl.ko   │ ──────────────▶ │  phantom-gpu │
  │  (userspace) │    /dev/gpuctl   │   (kernel)   │      BAR0       │    (QEMU)    │
  └──────────────┘                  └──────────────┘                 └──────┬───────┘
                                                                            │
                      ┌─────────────────────────────────────────────────────┴─────┐
                      │                                                           │
                      ▼                                                           ▼
            ┌─────────────────┐                                      ┌────────────────────┐
            │   INIT PATH     │                                      │   RUNTIME PATH     │
            │                 │                                      │                    │
            │  blob @ 0xb0a2d8│                                      │  UPLOAD_SHADER     │
            │       ↓         │                                      │       ↓            │
            │  xorshift32     │                                      │  DISPATCH          │
            │(seed=0xfe170e07)│                                      │       ↓            │
            │       ↓         │                                      │  Validate + Exec   │
            │  CRC + LZ4      │                                      │       ↓            │
            │       ↓         │                                      │  opcode → hash     │
            │  0x308 bytes ───┼──────────────────────────────────────▶  → handler table   │
            │  (state blob)   │                                      │       ↓            │
            └─────────────────┘                                      │  regs/stack/DMA    │
                                                                     └───────────────────

PhantomCore는 커스텀 QEMU PCI 장치(phantom-gpu) 안에 구현된 VM을 분석해서, 도합 6개의 gate 조건을 모두 통과하는 shader bytecode를 작성하고, firmware blob에 숨겨진 hidden witness(레지스터 값 + buf1 32바이트)를 복원하여 최종 flag를 얻는 리버싱 문제이다.

풀이는 크게 두 단계로 나뉜다.

Gate 통과: checker가 요구하는 6-bit 조건을 모두 만족하는 shader + buffer 조합을 찾는다
Flag 복원: gate를 통과해도 success path가 읽는 추가 입력(reg0/reg3/reg4/reg5, buf1 raw 32바이트)이 정확해야만 올바른 flag가 출력된다

아래는 리버싱 자체보다는 전체적인 구조와 흐름에 중점을 두고 작성한 라업이다.

1. 전체 아키텍처

1-1. 배경: GPU와 CPU의 관계

GPU는 CPU와 PCIe 버스로 연결된 별도 물리 장치다. CPU는 자신의 DRAM을, GPU는 별도 VRAM을 갖고 있고, 둘 사이의 데이터 이동은 PCIe를 통한 DMA로 이루어진다.

Driver가 GPU와 통신하는 방법은 2가지다:

MMIO (control plane): CPU가 BAR0에 매핑된 GPU 레지스터에 r/w해서 명령과 설정을 전달한다. 데이터 이동 없이 신호만 전달.
DMA (data plane): GPU가 PCIe Bus Master가 되어 CPU 개입 없이 Host Memory ↔ Device Memory 사이에서 직접 데이터를 전송한다.

방향이 반대라서 분리된다. MMIO는 CPU → device, DMA는 device → RAM.

1-2. QEMU에서의 구현

참고: PCI vs PCIe - QEMU Wiki

기존 PCI는 CPU, Bridge/Memory Controller, Bus, 그리고 그 위에 연결된 장치들로 구성된 shared bus 구조였다. Host Bridge(노스브릿지)가 CPU/DMA와 버스를 연결하며, bus arbitration을 통해 버스 사용 권한이 결정된다.

참고: QEMU PCI 장치 구현 - owalle

이 문제에서는 -machine q35를 사용하여 PCIe 기반 플랫폼을 에뮬레이션한다. PCIe에서는 Root Complex가 기존의 Host Bridge 및 메모리 컨트롤러 역할을 통합하며, 별도의 노스브릿지 칩이 존재하지 않는다. 또한 shared bus 대신 각 장치가 Root Complex와 point-to-point 링크로 연결되는 구조를 사용한다.

/sys/bus/pci/devices로 확인한 장치 목록:

[0000:00] pcie.0 (Root Complex = q35 MCH)
    ├── 00:00.0  Intel 82G33 Host Bridge    vendor=8086:29c0  class=0x060000
    ├── 00:01.0  phantom-gpu (Accelerator)  vendor=1de5:7001  class=0x0b4000  <- DRIVER=gpuctl
    ├── 00:1f.0  ICH9 LPC Controller        vendor=8086:2918  class=0x060100
    ├── 00:1f.2  ICH9 SATA Controller       vendor=8086:2922  class=0x010601
    └── 00:1f.3  ICH9 SMBus Controller      vendor=8086:2930  class=0x0c0500

bus 구조에서 별도의 bridge나 switch가 존재하지 않으므로, 문제 환경은 [PCI Express Topology] 그림과 같이 Root Complex에서 Endpoint로 직접 연결되는 단일 PCIe 토폴로지임을 알 수 있고, 또 [PCI System Block Diagram]의 Graphics 위치에 대응되는 장치가 phantom-gpu라고 볼 수 있다.

한편 phantom-gpu는 BAR0을 통해 MMIO 영역이 매핑되어 있고,

BAR0: 0xfebfe000 ~ 0xfebfefff (4KB MMIO 영역)

이는 해당 디바이스의 레지스터 접근을 위한 메모리 공간을 의미한다.

참고: QEMU 시작하기 - velog

QEMU 프로세스 메모리:

실제 GPU는 PCIe로 연결된 외부 물리 장치지만, phantom-gpu는 QEMU 프로세스 내부에서 C 코드로 구현된 가상 디바이스다. 물리적으로 분리된 VRAM이 여기서는 같은 Guest RAM의 일부 영역으로 표현되고, dma_memory_read/write()를 통해 접근한다.

QEMU 추상화 레이어:

QEMU 내부 모듈:

TCG: Guest x86_64 명령어를 JIT으로 번역해서 Host CPU에서 실행하는 에뮬레이션 엔진
MMU: Guest 가상주소 → 물리주소 변환. BAR0 MMIO 접근 시 MemoryRegion 디스패치로 콜백
QDEV: PCI 장치 에뮬레이션 프레임워크. phantom-gpu가 여기 등록됨

문제 환경은 enable-kvm 없이 순수 TCG 모드로 실행된다. 실행 중 MMIO 주소(BAR0 영역)를 건드리면 해당 주소에 매핑된 MemoryRegion 콜백이 트리거돼서 phantom-gpu handler로 진입하는 구조다.

참고로 QEMU 공식 PCI 디바이스 구현 예제는 hw/misc/edu.c에서 확인할 수 있다.

phantom-gpu는 공식과 유사하게 BAR0 MemoryRegion 등록, DMA 접근, 인터럽트 처리 구조를 따르며, 그 위에 shader VM이 추가된 형태로 보인다.

1-3. phantom-gpu vs. 실제 GPU

실제 GPU Compute Core는 병렬 하드웨어지만, phantom-gpu VM executor는 단순히 instruction을 하나씩 읽고 실행하는 순차적인 소프트웨어 interpreter다. 별도의 MMU도 없고, memory isolation도 없다. firmware blob을 디코드해서 device 내부 struct에 S-box, constants, key material 등을 세팅하고, 이게 곧 VM 실행에 필요한 모든 global state가 된다.

2. 문제 파일 분석

├── bios/
│   ├── bios-256k.bin          <- 필요
│   ├── efi-e1000e.rom         <- 필요X (-nic none)
│   ├── efi-virtio.rom         <- 필요X
│   ├── kvmvapic.bin           <- 필요X (KVM 사용 안함, only TCG)
│   ├── linuxboot_dma.bin      <- 필요X
│   └── vgabios-stdvga.bin     <- 필요X (-vga none)
├── bzImage                    # Guest 리눅스 커널
├── initramfs.cpio.gz          # Guest 루트파일시스템
├── qemu-system-x86_64         # 커스텀 QEMU 바이너리 <- 분석 대상
└── run.sh

bios/ 디렉토리에 6개 파일이 있지만 실제로 필요한 것은 bios-256k.bin 하나뿐이다.

-machine q35가 BIOS를 요구하고, 이것이 Guest Linux 커널 부팅 전 POST 과정을 담당한다. 나머지 5개 파일은 원본 run.sh에 -nic none, -vga none 옵션만 추가하면 전혀 필요가 없다.

initramfs 풀기:

mkdir initramfs_root && cd initramfs_root
gzip -dc ../initramfs.cpio.gz | cpio -idmv

.
├── bin
│   ├── busybox
│   ├── cat -> busybox
│   ├── chmod -> busybox     ├── hexdump -> busybox
│   ├── cp -> busybox        ├── insmod -> busybox
│   ├── dd -> busybox        ├── ls -> busybox
│   ├── dmesg -> busybox     ├── mount -> busybox
│   ├── echo -> busybox      ├── od -> busybox
│   ├── grep -> busybox      └── xxd -> busybox
├── init
├── lib
│   └── modules
│       └── gpuctl.ko        <- 커널 모듈
└── usr
    └── local
        └── bin
            └── gpuctl-cli   <- 유저랜드 CLI

init 스크립트가 gpuctl.ko를 insmod하고, /dev/gpuctl 캐릭터 디바이스를 생성한다.

#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
mount -t devtmpfs none /dev
mkdir -p /dev/pts
mount -t devpts none /dev/pts
mount -t tmpfs none /tmp

export PATH=/bin:/sbin:/usr/local/bin

# Load phantom-gpu driver
insmod /lib/modules/gpuctl.ko
sleep 0.5

echo "================================================"
echo "  PhantomCore"
echo "  /dev/gpuctl is ready"
echo "  Use gpuctl-cli to interact with the device"
echo "================================================"

# Drop to shell
export PATH=/bin:/sbin:/usr/local/bin
export HOME=/tmp
cd /tmp
setsid cttyhack sh

poweroff -f

run.sh 실행:

================================================
  PhantomCore
  /dev/gpuctl is ready
  Use gpuctl-cli to interact with the device
================================================
BusyBox v1.36.1 (Ubuntu 1:1.36.1-6ubuntu3.1) built-in shell (ash)
Enter 'help' for a list of built-in commands.

~ # gpuctl-cli
Usage: gpuctl-cli <command> [args...]
  upload   <shader.bin>              Upload shader bytecode
  setbuf   <slot> <file.bin>         Set buffer slot (0-3)
  dispatch [max_steps]               Dispatch shader execution
  run      <shader.bin> [buf0] [buf1]  One-stop upload+set+dispatch
  log                                Read last execution log

3. gpuctl-cli 리버싱 (Userland)

먼저 gpuctl-cli를 보자. IDA에서 "Usage: %s <command>" 문자열 xref로 main 함수(sub_401BA0)를 찾았다.

함수를 보면 upload / setbuf / dispatch / log는 각각 ioctl 한 번 호출하는 단순 wrapper고, run 명령은 저 전부를 한번에 해준다는 것을 알 수 있다.

int cli_main(int argc, char **argv) {
    if (argc <= 1) {
        print_usage();
        return 1;
    }
    int fd = open("/dev/gpuctl", O_RDWR);
    if (fd < 0) {
        perror("open(/dev/gpuctl)");
        return 1;
    }
    const char *cmd = argv[1];

    if (!strcmp(cmd, "upload")) {
        if (argc != 3) error("upload: need <shader.bin>");
        else rc = upload_shader(fd, argv[2]);
    }
    else if (!strcmp(cmd, "setbuf")) {
        if (argc <= 3) error("setbuf: need <slot> <file>");
        else {
            slot = parse_uint(argv[2]);
            if (slot > 3) error("slot must be 0-3");
            else rc = set_buffer_from_file(fd, slot, argv[3]);
        }
    }
    else if (!strcmp(cmd, "dispatch")) {
        max_steps = (argc == 2) ? 0x100000 : parse_uint(argv[2]);
        out = calloc(1, 0x4000);
        rc = dispatch(fd, max_steps, out);
        free(out);
    }
    else if (!strcmp(cmd, "run")) {
        if (argc == 2) error("run: need at least <shader.bin>");
        else {
            upload_shader(fd, argv[2]);
            if (argc >= 4) set_or_clear(fd, 0, argv[3]);  // buf0
            else           clear_buf(fd, 0);
            if (argc >= 5) set_or_clear(fd, 1, argv[4]);  // buf1
            else           clear_buf(fd, 1);
            clear_buf(fd, 2);   // buf2: 16KB zeroed  ← flag output 영역
            clear_buf(fd, 3);   // buf3: 16KB zeroed  ← stack 영역
            out = calloc(1, 0x4000);
            rc = dispatch(fd, 0x100000, out);
            if (!rc && read_log(fd, &logrec, 8) > 0) {
                print_log(logrec);
                if (logrec.status == 8)   // GATE_TRIGGERED
                    dump_buf2_as_flag(out);
            }
            free(out);
        }
    }
    else if (!strcmp(cmd, "log")) {
        if (read_log(fd, &logrec, 8) < 0) perror("read(log)");
        else print_log(logrec);
    }
    else {
        print_unknown_command(cmd);
        print_usage();
        rc = 1;
    }
    close(fd);
    return rc;
}

유저인 우리는 run명령어를 써서 shader, buf0, buf1을 올리면 된다. buf2(flag output)와 buf3(stack)은 run이 알아서 16KB zeroed 버퍼로 할당해준다.

코드 중에서 특히 logrec.status == 8 체크가 눈에 띄는데, 나중에 알게 되겠지만 이게 GATE_TRIGGERED 상태이다. 이 조건을 만족해야만 buf2가 flag로 dump된다.

또 ioctl 코드는 upload=0x40105001, setbuf=0x40105002, dispatch=0xC0185003이다.

4. gpuctl.ko 리버싱 (Kernel Module)

참고 자료

PCIe Part 2: DMA, MMIO, TLP - ctf.re

PCIe BAR0 and DMA Explained with QEMU - Yair Gadelov

다음으로 gpuctl.ko의 구조를 이해하려면 PCIe DMA의 표준 흐름을 먼저 알아야 한다.

위 그림과 다르게 phantom-gpu에서는 물리적 PCIe TLP가 없다. iowrite32(bar0+0x30)이 guest MMIO trap을 유발하면, QEMU MemoryRegion 콜백이 dma_memory_read(cmd_ring_dma)로 guest RAM을 직접 읽는다. driver 관점에서의 인터페이스는 동일하지만 PCIe fabric 없이 동작한다.

gpuctl.ko는 이 흐름을 그대로 구현한 순수 전달 레이어다. PCIe driver의 전형적인 패턴 — DMA buffer 할당 → device에 주소 전달 → doorbell로 시작 → interrupt로 완료 수신 — 을 크게 초기화(probe), 커맨드 전달(ioctl), 완료 수신(IRQ) 세 파트로 구현한다.

4-1. init_modul에서 probe까지

unk_11A0이 pci_driver 구조체다. IDA에서 해당 주소를 보면:

__int64 init_module() {
    return pci_register_driver(&pci_driver_struct, &_this_module, "gpuctl");
}

.data:11B0  dq offset "gpuctl"          → .name
.data:11B8  dq offset id_table          → .id_table  (vendor=1DE5, device=7001)
.data:11C0  dq offset sub_650           → .probe
.data:11C8  dq offset sub_30            → .remove

pci_register_driver가 이 구조체를 커널에 등록하면, 커널이 PCI 버스를 스캔하다가 vendor=1DE5, device=7001인 장치(phantom-gpu)를 발견하면 .probe = sub_650함수를 자동 호출한다.

4-2. probe(sub_650) — PCI 초기화 및 DMA 할당

PCI 활성화 및 BAR0 매핑
```
pci_enable_device(pdev);
pci_request_regions(pdev, "gpuctl");
gd->bar0 = pci_iomap(pdev, 0, 4096);

// Signature 검증
sig = ioread32(gd->bar0 + 0x00);
// sig == 0x5048544D ("PHTM") 이어야 함
```
pci_iomap이 BAR0 물리주소를 커널 가상주소로 매핑한다. 이후 ioread32/iowrite32로 이 주소를 읽고 쓰면 MMIO 접근이 발생하고, QEMU의 MemoryRegion 콜백이 트리거된다.
DMA buffer 할당 및 주소 전달

PCIe에서 device가 host RAM에 직접 접근하려면, 먼저 OS가 contiguous physical memory를 잡아주고 그 물리주소를 device에 알려줘야 한다. 이때, 주소를 BAR0에 기록한다고 데이터 전송이 시작되는 게 아니고 device에게 나중에 여기를 읽으라고 위치를 알려주는 것뿐이다.
```
// OS에 DMA buffer 할당 요청
gd->cmd_ring = dma_alloc_attrs(&pdev->dev, 0x1000, &gd->cmd_ring_dma, ...);
gd->log_ring = dma_alloc_attrs(&pdev->dev, 0x1000, &gd->log_ring_dma, ...);
gd->shader   = dma_alloc_attrs(&pdev->dev, 0x2000, &gd->shader_dma,   ...);
for (i = 0; i < 4; i++)
    gd->slot[i] = dma_alloc_attrs(&pdev->dev, 0x4000, &gd->slot_dma[i], ...);
```
dma_alloc_attrs의 세 번째 인자(&gd->cmd_ring_dma)가 물리주소를 받아오는 포인터다. device는 이 물리주소로 guest RAM에 직접 접근한다.

그 다음 이 주소들을 BAR0 레지스터에 기록해서 phantom-gpu에 알려준다:
```
// DMA 물리주소 → BAR0에 기록
iowrite32(lower_32_bits(gd->cmd_ring_dma), gd->bar0 + 0x20);  // cmd_ring lo
iowrite32(upper_32_bits(gd->cmd_ring_dma), gd->bar0 + 0x24);  // cmd_ring hi
iowrite32(lower_32_bits(gd->log_ring_dma), gd->bar0 + 0x40);
iowrite32(upper_32_bits(gd->log_ring_dma), gd->bar0 + 0x44);
// slot 0~3도 동일하게 0x50~0x6C에 기록
iowrite32(0, gd->bar0 + 0x30);  // doorbell 초기화
```
이것이 PCIe DMA의 Source Address 프로그래밍 단계다. phantom-gpu는 이 주소들을 내부적으로 저장해두고, 이후 커맨드가 올 때 해당 guest 메모리 영역을 직접 읽는다.

IRQ 등록 및 Firmware init

// MSI interrupt handler 등록
request_threaded_irq(irq, sub_5E0, NULL, 0x80, "gpuctl", gd);

// Firmware init trigger
iowrite32(1, gd->bar0 + 0x100);
_mm_mfence();

// QEMU가 firmware blob 디코드 완료할 때까지 polling
for (i = 0; i < 100; i++) {
    if (ioread32(gd->bar0 + 0x104) == 1) break;
    udelay(4295);
}

pci_set_master(pdev);          // device가 DMA 주체가 될 수 있음
cdev_add(&gd->cdev, ...);      // /dev/gpuctl 생성

bar0+0x100에 1을 쓰는 것이 firmware init doorbell이다. QEMU가 이 write를 받아 내부 firmware blob을 디코드하고 gate 상수들을 세팅한 뒤, bar0+0x104를 1로 바꿔 완료를 알린다.

4-3. ioctl handler (sub_370) - 커맨드 전달

gpuctl-cli가 /dev/gpuctl에 ioctl을 보내면 이 함수가 받는다. sub_370이 ioctl handler인 건 probe에서 cdev_init(gd->cdev, &gpuctl_fops)로 등록한 파일 ops의 .unlocked_ioctl 필드에 이 함수가 들어있기 때문이다.

이 함수는 세 가지 커맨드를 처리한다:

mutex_lock(&gd->lock);
switch (cmd) {

case 0x40105001:  // UPLOAD_SHADER
    copy_from_user(gd->shader, user_ptr, size);   // user → DMA buffer
    push_cmd(gd, CMD_UPLOAD, size, shader_dma);   // cmd ring에 기록 + doorbell
    wait_event(gd->wq, gd->irq_done);             // IRQ 올 때까지 대기
    break;

case 0x40105002:  // SET_BUF
    copy_from_user(gd->slot[slot], user_ptr, size);
    push_cmd(gd, CMD_SETBUF, slot|(size<<32), slot_dma[slot]);
    wait_event(gd->wq, gd->irq_done);
    break;

case 0xC0185003:  // DISPATCH
    push_cmd(gd, CMD_DISPATCH, max_steps, 0);
    wait_event(gd->wq, gd->irq_done);
    copy_to_user(user_out, gd->slot[2], min(out_size, 0x4000));  // 결과 반환
    break;
}
mutex_unlock(&gd->lock);

이 때 push_cmd(sub_160)의 역할이 중요하다:

// 1. cmd ring의 다음 슬롯에 64바이트 커맨드 기록 (DMA buffer에 씀)
memcpy(&cmd_ring[tail], &cmd, 64);

// 2. doorbell write → QEMU MMIO write handler 트리거
iowrite32(next_idx, gd->bar0 + 0x30);

cmd_ring은 streaming DMA ring buffer 패턴으로 동작한다. driver가 tail(Producer index)을 올리며 커맨드를 채우고, phantom-gpu가 head(Consumer index)를 소비한다.

이때 DMA buffer를 먼저 채운 뒤 doorbell로 device를 깨우는 것이 PCIe DMA의 표준적인 순서이고, iowrite32(next_idx, bar0+0x30)이 그 신호라고 할 수 있다. doorbell write 이후로는 phantom-gpu는 DMA로 cmd_ring을 읽어 커맨드를 처리한다.

4-5. IRQ handler (sub_5E0) - 완료 통보

irqreturn_t irq_handler(int irq, void *gd) {
    u32 status = ioread32(gd->bar0 + 0x14);   // completion status 확인
    if (status) {
        gd->log_record = *(u64 *)gd->log_ring; // log 읽기
        gd->has_log = 1;
        iowrite32(status, gd->bar0 + 0x18);    // IRQ ACK
        wake_up(&gd->wq);                       // ioctl handler 깨움
    }
    return IRQ_HANDLED;
}

DISPATCH 완료 후 phantom-gpu가 MSI를 발생시키면 이 ISR이 깨어난다. wait_event로 block 중이던 ioctl handler를 깨우고, 이후 copy_to_user로 결과(slot2 = flag output 영역)가 user 쪽으로 전달된다.

4-6. 전체 흐름

gpuctl-cli
    │ ioctl(fd, DISPATCH, ...)
    ▼
sub_370 (ioctl handler)
    ├─ copy_from_user → DMA buffer (slot[0], slot[1])
    ├─ push_cmd
    │     ├─ cmd_ring[tail]에 커맨드 기록  ← streaming ring buffer
    │     └─ iowrite32(next_idx, bar0+0x30)  ← doorbell
    │                   │
    │        실제 HW:    └─ PCIe TLP → device DMA engine → host RAM 읽기
    │        QEMU:      └─ MMIO trap → MemoryRegion 콜백
    │                        └─ dma_memory_read(cmd_ring_dma)  ← guest RAM 직접
    │                                    │
    │                      shader validation + VM execution
    │                      MSI interrupt 발생
    │                   │
    └─ wait_event ◀─────┘
                        │
                    sub_5E0 (IRQ handler)
                        ioread32(bar0+0x14)   completion status
                        iowrite32(bar0+0x18)  ACK
                        wake_up(&gd->wq)
                        │
    ioctl handler 재개 ◀┘
    copy_to_user(slot[2]) → flag output 반환

앞서 설명했지만 gpuctl.ko는 모든 요청을 DMA 버퍼에 복사하고 doorbell을 울릴 뿐인 순수한 전달 레이어다. 진짜 분석해야할 대상은 qemu-system-x86_64 바이너리이다.

5. QEMU phantom-gpu 리버싱

qemu의 경우는 우선 IDA에서 "phantom-gpu" 문자열 xref를 추적해서 가장 주요한 함수들을 찾았다:

함수	설명
`sub_4277B0`	PCI class init; `"Phantom GPU (CTF Challenge Device)"`
`sub_427D10`	device realize; MMIO region 등록, BAR 활성화
`sub_427C10`	MMIO read handler; signature/version 반환
`sub_428AB0`	MMIO write handler

sub_428AB0는 약 6천 줄짜리 함수로, firmware init / DMA command 처리 / shader validation / VM execution / post-gate success path 까지 핵심 로직들이 전부 들어있다.

<center>GPU 아키텍처 관점에서의 동작</center>

5-1. Firmware Blob 추출 및 디코드

앞서 언급한 함수인 sub_428AB0에서 offset == 0x100 분기가 firmware init 경로다. 0xB0A2D8의 embedded blob을 참조한다.

firmware 디코딩 체인은 단순하다:

; ① xorshift32 — 0x428FE8
mov  edx, 0FE170E07h          ; seed
loc_428FE8:
    mov  eax, edx
    shl  eax, 0Dh             ; state ^= state << 13
    xor  eax, edx
    mov  edx, eax
    shr  edx, 11h             ; state ^= state >> 17
    xor  eax, edx
    mov  edx, eax
    shl  edx, 5               ; state ^= state << 5
    xor  edx, eax
    xor  [rcx], dl             ; blob[i] ^= low_byte(state)
    add  rcx, 1
    cmp  rcx, rbp              ; 0x2E1 bytes
    jnz  loc_428FE8

; ② CRC32 — 0x42901C
mov  eax, 0FFFFFFFFh           ; CRC init
loc_429028:
    movzx edx, byte ptr [rsi]
    xor   edx, eax
    shr   eax, 8
    movzx edx, dl
    xor   eax, [rcx+rdx*4]    ; table @ 0x19EEF00
    cmp   rsi, rbp
    jnz   loc_429028
cmp  eax, 0AEF1393Ah          ; expected CRC

; ③ LZ4 raw block — 0x429080
movzx ebx, byte ptr [rdx]     ; token byte
    shr  al, 4                 ; literal_length = token >> 4
    cmp  al, 0Fh               ; if 0xF → extended length loop
    jz   loc_429522

아래 스크립트로 firmware blob을 추출할 수 있다.

<details> <summary>extract.py</summary>

#!/usr/bin/env python3
import struct, zlib, sys, lz4.block
from pathlib import Path

qemu = Path("qemu-system-x86_64").read_bytes()
enc = bytearray(qemu[0xB0A2D8 : 0xB0A2D8 + 0x2E1])

# xorshift32 decrypt (seed=0xFE170E07)
state = 0xFE170E07
for i in range(len(enc)):
    state ^= (state << 13) & 0xFFFFFFFF
    state ^= state >> 17
    state ^= (state << 5) & 0xFFFFFFFF
    state &= 0xFFFFFFFF
    enc[i] ^= (state & 0xFF)

# CRC32 verify — pre-final XOR value == 0xAEF1393A
crc_raw = zlib.crc32(bytes(enc)) ^ 0xFFFFFFFF & 0xFFFFFFFF
assert crc_raw == 0xAEF1393A, f"CRC mismatch: {crc_raw:#x} vs 0xAEF1393A"

# LZ4 raw block decompress -> firmware blobs
firmware = lz4.block.decompress(bytes(enc), uncompressed_size=0x308)
Path("firmware_decompressed.bin").write_bytes(firmware)
print(f"OK: {len(firmware)} bytes → firmware_decompressed.bin")

</details>

5-2. Firmware → Device State 복사

LZ4 압축해제 이후의 0x308바이트 blob은 device state 구조체의 여러 오프셋으로 복사된다. IDA에서 추적한 mov/rep movsq 어셈으로 구조를 복원하면 이와 같다:

  typedef struct PhantomGPUState {
  uint8_t  _pci_header[0xC00];

  uint8_t  key_seed[8];
  uint8_t  blob_copy[0x308];

  uint64_t blob_tail_qword;

  uint8_t  trace_pattern[8];
  uint32_t gate_reg7;
  uint32_t gate_buf2_dw0;
  uint32_t gate_crc_buf1;
  uint32_t gate_xor_r0r3;

  uint32_t post_f28;
  uint32_t post_f2c;

  uint64_t dispatch_table[256];

  uint8_t  _dma_addrs[];

  uint32_t reg[16];
  uint32_t pc;
  uint32_t sp;
  uint32_t cmp_flag;
  
  uint8_t  active_shader[0x2000];

  uint8_t  trace_ring[16];
  uint32_t trace_count;

  uint32_t gate_armed;
  uint32_t vm_status;
  uint32_t fault_code;

} PhantomGPUState;

5-3. Phase 1 Transform — Grammar A / Grammar B

firmware blob → gate 상수 파생 과정을 Phase 1 Transform이라고 명명하겠다. 이때 IDA 0x429240~0x429472 구간에 두 가지 유의미한 패턴이 반복된다.

Grammar A (stream XOR) — trace pattern 생성

0x429240~0x429261 루프:

loc_429240:
    lea  edx, [ecx+eax]         ; edx = (seed + i) — seed는 blob[0x08]의 하위 바이트
    movzx edx, dl               ; dl = (seed + i) & 0xFF
    movzx edx, byte ptr [rdi+rdx+0D0Ch]  ; dev[0xD0C + dl] = sbox[dl]
    xor   dl, [rax+0C07h]       ; ^ blob[i-1] (dev[0xC08+i-1])
    mov   [rax+0F0Fh], dl       ; → dev[0xF10+i-1] (trace pattern)
    add   rax, 1
    cmp   rax, rsi              ; 8회 반복
    jnz   loc_429240

Pseudo-code:

// Grammar A: sbox byte XOR
for (i = 0; i < 8; i++)

dev[0xF10 + i] = sbox[(seed + i) & 0xFF] ^ blob[i];

seed는 blob[0x08:0x0C]의 하위 바이트(= dev[0xC10]), sbox는 dev[0xD0C] = blob[0xFC:0x1FC]이다. 그리고 결과가 50 11 21 40 20 11 51 41 — gate bit 0의 trace 기대값이다.

Grammar B (pack_perm XOR) — 32-bit 상수 생성

0x42926B~0x4292C1이 첫 번째 Grammar B 블록이다:

mov  edx, [rbx+0C18h]       ; edx = selector (blob 내 4바이트 값)
lea  eax, [rdx+1]           ; idx+1
lea  ecx, [rdx+2]           ; idx+2
movzx eax, byte ptr [rbx+rax+0D0Ch]  ; sbox[(selector+1) & 0xFF]
movzx ecx, byte ptr [rbx+rcx+0D0Ch]  ; sbox[(selector+2) & 0xFF]
shl  eax, 8                 ; byte1 << 8
shl  ecx, 10h               ; byte2 << 16
or   eax, ecx
movzx ecx, dl               ; sbox[(selector+0) & 0xFF]
movzx ecx, byte ptr [rbx+rcx+0D0Ch]
add  edx, 3
movzx edx, byte ptr [rbx+rdx+0D0Ch]  ; sbox[(selector+3) & 0xFF]
or   eax, ecx               ; | byte0
shl  edx, 18h               ; byte3 << 24
or   eax, edx               ; = pack_perm 결과
xor  eax, [rbx+0C14h]       ; blob에서 가져온 상수랑 XOR
mov  [rbx+0F18h], eax       ; → dev[0xF18] (gate_reg7)

Pseudo-code:

// Grammar B: 4-byte S-box lookup → u32 → XOR
uint32_t pack_perm(uint8_t *sbox, uint32_t idx) {
    return sbox[(idx+0) & 0xFF]        |
          (sbox[(idx+1) & 0xFF] << 8)  |
          (sbox[(idx+2) & 0xFF] << 16) |
          (sbox[(idx+3) & 0xFF] << 24);
}

dev[0xF18] = pack_perm(sbox, blob_dword(selector_offset)) ^ blob_dword(xor_offset);

이 패턴이 6번 반복되면서 gate 상수 6개를 생성한다:

// selector 오프셋 → XOR 상수 → 저장 주소
dev[0xF18] = pack_perm(sbox, blob[0x10]) ^ blob[0x0C]   // gate_reg7    = 0xA5A5A5A5
dev[0xF1C] = pack_perm(sbox, blob[0x18]) ^ blob[0x14]   // gate_buf2    = 0xC0DEF00D
dev[0xF20] = pack_perm(sbox, blob[0x20]) ^ blob[0x1C]   // gate_crc     = 0x2A8DED84
dev[0xF24] = pack_perm(sbox, blob[0x58]) ^ blob[0x54]   // gate_xor     = 0xCC99E897
dev[0xF28] = pack_perm(sbox, blob[0x28]) ^ blob[0x24]   // post_f28     = 0x13579BDF
dev[0xF2C] = pack_perm(sbox, blob[0x30]) ^ blob[0x2C]   // post_f2c     = 0x2468ACE0

대부분 blob[0x0C]부터 8바이트 간격으로 순차 배치되지만, f24(gate_xor)만 blob[0x54]/blob[0x58]로 떨어져 있다.

5-4. Dispatch Table 초기화

Phase 1 Transform 직후 dispatch table이 초기화된다. unk_1719400에 15개 (opcode, handler) 쌍이 정적으로 정의되어 있고, firmware blob의 scramble 값으로 최종 slot 위치를 결정한다:

// 0x4294C2 — dispatch table 초기화 루프
for (int i = 0; i < 15; i++) {
    uint8_t  opcode  = static_table[i].opcode;      // unk_1719400
    void    *handler = static_table[i].handler;
    uint8_t  slot    = (13 * opcode + scramble_data[opcode] + blob[0x304]) & 0xFF;
    dev->dispatch_table[slot] = handler;
}
// scramble_data = blob[0x1FC:0x2FC], blob[0x304] = global constant

이 scramble이 없으면 opcode → handler 매핑을 알 수 없으므로, firmware 디코딩이 VM 분석의 선행 조건이다.

디코딩 후 복원한 ISA — 15개 opcode, 4바이트 고정 길이 (byte0=opcode, byte1=Rd, byte2=Rs/Rb/buf, byte3=imm/offset):

Opcode	Mnemonic	Operation
`0x01`	`MOV Rd, Rs`	`reg[Rd] = reg[Rs]`
`0x02`	`LI Rd, imm8`	`reg[Rd] = sign_extend(imm8)`
`0x10`	`ADD Rd, Rs`	`reg[Rd] += reg[Rs]`
`0x11`	`XOR Rd, Rs`	`reg[Rd] ^= reg[Rs]`
`0x12`	`AND Rd, Rs`	`reg[Rd] &= reg[Rs]`
`0x13`	`OR Rd, Rs`	`reg[Rd] \|= reg[Rs]`
`0x20`	`LOAD Rd, [buf, Rb+off]`	`reg[Rd] = dma_buf[buf][(reg[Rb]+off)*4]`
`0x21`	`STORE Rs, [buf, Rb+off]`	`dma_buf[buf][(reg[Rb]+off)*4] = reg[Rs]`
`0x30`	`CMP Rd, Rs`	`flag = (reg[Rd] == reg[Rs])`
`0x31`	`BEQ off8`	`if flag: PC += off*4`
`0x32`	`BNE off8`	`if !flag: PC += off*4`
`0x40`	`CALL off8`	`SP--; stack[SP]=PC+4; gate_check(); PC+=off*4`
`0x41`	`RET`	`if checker()==0x3F → GATE_TRIGGERED; else PC=pop()`
`0x50`	`PUSH Rs`	`SP--; stack[SP] = reg[Rs]`
`0x51`	`POP Rd`	`reg[Rd] = stack[SP]; SP++`

5-5. Shader Validator (`sub_428450`)

dispatch 전에 업로드된 shader를 검사한다:

int validate_shader(PhantomGPUState *dev) {
    uint8_t *shader = dev->active_shader;
    int size = dev->shader_size;

    // 1. 크기/정렬
    if (size == 0 || (size & 3) || size > 0x1803)
        return FAIL;

    // 2. opcode 유효성 — 모든 instruction을 순회
    for (int pc = 0; pc < size; pc += 4) {
        uint8_t op = shader[pc];
        if (op > 0x51)                  // switch 82 cases, default → FAIL
            return 7;
        // jump table: 0x01,0x02,0x10~0x13,0x20,0x21,0x30~0x32,0x40,0x41,0x50,0x51만 허용
        // 나머지 → return 7
    }

    // 3. BFS reachability 마킹 (sub_4275B0)
    //    PC=0부터 시작, CALL/BEQ/BNE target을 따라가며 reachable 블록 마킹
    mark_reachable(shader, size);  // sub_4275B0

    // 4~5. reachable 블록에 대해서만 prologue/epilogue 검사
    for (each reachable instruction) {
        if (op == 0x41) {              // RET
            // RET 직전 2개 명령이 POP(0x51)이어야 함
            // 추가로 POP의 대상 레지스터가 r15, r14 순이어야 함
            word_m2 = read_insn(pc - 8);  // byte[pc-12..pc-9]
            word_m1 = read_insn(pc - 4);  // byte[pc-8..pc-5]
            if ((word_m2 & 0xFF) != 0x51) return 4;
            if ((word_m1 & 0xFF) != 0x51) return 4;
            // word_m1의 byte1 == 0x0E (r14) 확인
            // word_m2의 byte1 == 0x0F (r15) 확인
        }
        if (op == 0x40) {              // CALL
            // CALL target의 첫 2개 명령이 PUSH r15(0x50 0x0F) + MOV r15,r14(0x01 0x0F 0x0E)
            target = pc + offset*4;
            word0 = read_insn(target);
            word1 = read_insn(target + 4);
            if ((word0 & 0xFF) != 0x50) return 4;   // PUSH
            if ((word0 >> 8 & 0xF) != 0xF) return 4; // r15
            if ((word1 & 0xFF) != 0x01) return 4;   // MOV
            if ((word1 >> 8 & 0xF) != 0xF) return 4; // Rd=r15
            if ((word1 >> 16 & 0xF) != 0xE) return 4; // Rs=r14
        }
    }
    return 0;  // pass
}

여기서 검증 4, 5는 sub_4275B0(BFS)이 reachable로 마킹한 블록에만 적용된다. BFS가 도달하지 못한 블록은 prologue/epilogue 검사를 완전히 건너뛴다.

이걸로 추후 gate 검증 우회를 할 수 있다.

5-6. VM Executor Loop & Fault Codes

dispatch 시작 시 memset(dev + 0x1730, 0, 0x20a8)로 레지스터/PC/SP/trace ring을 전부 초기화한 뒤, 아래 루프를 실행한다:

while (steps < max_steps) {
    if (pc >= shader_size) { fault = FAULT_BAD_PC; break; }

    uint8_t opcode = shader[pc];
    uint8_t slot = (13 * opcode + scramble_data[opcode] + blob[0x304]) & 0xFF;
    handler_fn *handler = dev->dispatch_table[slot];

    if (!handler) { fault = FAULT_BAD_OPCODE; break; }

    trace_ring[trace_count++ % 16] = opcode;
    handler(dev, &shader[pc]);

    if (dev->fault_code) break;
    steps++;
}

dispatch_table[256]은 함수 포인터 배열로, 5-4에서 초기화된 15개 slot만 실제 handler가 채워져 있고 나머지는 NULL이다. 유효하지 않은 opcode가 들어오면 NULL handler → FAULT_BAD_OPCODE로 즉시 종료된다.

각 handler 내부 함수에서는 에러 조건을 만나면 dev->fault_code(offset 0x379C)에 상수를 쓰는데, 이 패턴을 추적해서 fault code를 식별할 수 있다:

코드	이름	트리거 조건
0	OK	정상 종료
1	FAULT_OOB	DMA 버퍼 범위 초과 (LOAD/STORE)
2	FAULT_STACK_OVER	SP ≤ 0 (PUSH)
3	FAULT_STACK_UNDER	스택 비어있음 (POP)
4	FAULT_BAD_OPCODE	NULL handler
5	FAULT_BAD_PC	PC 범위 초과
6	STEPS_EXHAUST	최대 스텝 소진
7	HALTED	shader 끝 도달
8	GATE_TRIGGERED	checker == 0x3F → success path

요약:

6. Gate 검증

6-1. Gate 조건 분석

RET handler(sub_428370)가 매 RET 실행 시 sub_4280D0(checker)을 호출한다. 반환값이 정확히 0x3F(6비트 모두 set)이면 vm_status = 8 (GATE_TRIGGERED).

Bit 0 (0x01) — Trace History

최근 8개 opcode == 50 11 21 40 20 11 51 41
(PUSH XOR STORE CALL LOAD XOR POP RET)

Bit 1 (0x02) — Register Check

reg[7] == 0xA5A5A5A5
reg[0] ^ reg[3] == 0xCC99E897

Bit 2 (0x04) — buf2 First Dword

*(u32*)buf2 == 0xC0DEF00D

Bit 3 (0x08) — buf1 CRC32

CRC32(buf1[0:16]) == 0x2A8DED84

gate는 buf1 앞 16바이트의 CRC만 검사한다. 바이트 자체는 고정하지 않는다.

Bit 4 (0x10) — Gate Armed

CALL 실행 시: reg[1] == 0x47415445 ("ETAG") + 직전 4개 trace == [LOAD, AND, STORE, CALL]

Bit 5 (0x20) — Shader CRC32

reg[2] == CRC32(전체 shader bytecode)

dead code 바이트도 CRC 계산에 포함된다.

6-2. Gate 검증 우회

문제:

Bit 0 history 50 11 21 40 20 11 51 41에서 RET 직전은 0x51(POP) 하나이고 그 앞은 0x11(XOR)이다. 그런데 validator는 reachable RET 직전 두 명령이 POP 두 개여야 한다고 강제한다. reachable code만으로는 두 조건을 동시에 만족할 수 없다.

해결:

Validator가 dead code 블록에 대해서 CALL prologue/RET epilogue 규칙을 검사하지 않는다는 점을 이용할 수 있다.

Reachable 함수 내에서 STORE로 slot3(stack)의 return address를 dead block PC로 덮어쓴다
Validator 규칙을 만족하는 POP + POP + RET로 함수를 종료한다
RET가 덮어쓴 주소를 팝하여 dead block으로 점프한다
Dead block에서 정확히 50 11 21 40 20 11 51 41 history를 만들 수 있다
Dead block의 마지막 RET에서 checker 호출 → 0x3F → GATE_TRIGGERED

Dead Block Return Address Overwrite

gpuctl-cli run이 slot3을 16KB(SP=4096)로 할당한다. CALL이 return address를 stack[4095]에 push하는데, STORE의 offset(byte3)은 signed 8-bit이라 base가 0이면 stack[15]까지만 도달 가능하다.

이 때 CALL 전에 r14 = 4080을 미리 로드하면 된다. 함수 prologue의 MOV r15, r14가 r15 = 4080을 만들고, STORE r9, [buf3, r15+15]가 stack[4095]를 정확히 덮는다. validator는 함수 바이트코드 자체를 검사하므로, 동일한 바이트코드가 입력값(r14)에 따라 다른 위치를 overwrite하는 것까지는 막지 못한다.

6-3. Shader 레이아웃

최종 shader는 reachable region과 dead block 두 영역으로 구성된다. Reachable 영역에서 gate bit 1~5를 세팅한 뒤, return address overwrite로 dead block에 진입하여 bit 0(trace history)까지 만족시킨다.

7. Flag 복원

GATE_TRIGGERED까지 성공해도 buf2에 올바른 flag가 바로 나오지는 않는다. Gate 조건은 레지스터·버퍼의 관계(XOR, CRC 등)만 검사하므로 통과 가능한 입력 조합은 무수히 많지만, success path는 각 값을 직접 사용해 AES key를 파생한다. 정확한 입력이 아니면 의미 있는 출력이 나올 수 없다.

7-1. Gate 검사 범위

Gate가 고정하는 값:

trace8 — 8바이트 일치
reg7 — 값 일치
reg0 ^ reg3 — XOR 결과만 (개별값은 자유)
buf2[0:4] — 값 일치
CRC32(buf1[:16]) — CRC만 (raw bytes는 자유)
reg2 — CRC32(shader) 일치

Gate가 검사하지 않는 값:

reg0, reg3 개별값
reg4, reg5
buf1 전체 32바이트 (앞 16바이트는 CRC만, 뒤 16바이트는 자유)

7-2. Success Path가 실제로 읽는 것

// sub_428AB0 success path, 0x4299d6..
v132 = f28 ^ reg0                                // reg0 개별값 직접 씀
v134 = f2c ^ ((reg4 + reg5) & 0xFFFFFFFF)        // reg4, reg5 직접 씀
v135 = ROL32(reg3, 7) ^ v132                     // reg3 개별값 직접 씀
msg  = trace8 || pack_le32(v135) || pack_le32(v134) || buf1[16:32]
rounds = expand_round_material(buf1[0:16])        // buf1 전반 raw bytes 직접 씀

Gate를 통과하더라도, 위 코드에서 직접 참조하는 reg0, reg3, reg4, reg5의 개별값과 buf1 32바이트의 정확한 내용을 별도로 복원해야 올바른 flag를 얻을 수 있다.

7-4. Success Path 분석

buf1[0:32]  ──┐
trace8      ──┤
reg0~reg5   ──┼──▶ compress_states() ──▶ S0 (AES key), S1 (CTR counter)
f28, f2c    ──┘
                         ↓
              AES-128-CTR(S0, S1) ──▶ keystream (78B)
                                           │
              fixed_blob (78B) ──XOR───────┘──▶ flag (buf2 output)

compress_states 메인 로직은 아래와 같다:

buf1[0:16]에서 round material 24개 생성 (MurmurHash3 fmix 변형)
GF(2^8) MixColumns (standard + custom matrix) + Feistel 12라운드
fold16 (sub_4279B0): 16B → 64bit keyed digest (seed 0xDEADBEEFCAFEBABE)
역방향 Feistel 8라운드 + 최종 GF MixColumns → S0(AES key), S1(CTR counter)

compress_states 함수는 역연산이 불가능한 일방향 함수이다. 다만 올바른 입력값만 넣으면 VM 내부에서 알아서 연산되므로, 자세히 보지 않겠다.

7-6. Hidden Witness

자, Gate를 통과해도 flag가 나오지 않으니 이제 success path가 기대하는 정확한 입력값을 찾아야 한다. 그리고 다행히도 firmware blob 0x308바이트 중 아직 해석이 덜 된 영역이 남아있다.

여기부터는 약간의 게싱이 필요한데,

Hidden Register

Firmware blob 0x034..0x054 영역을 Grammar B (pack_perm XOR) 방식으로 디코드하면:

값	용도
`0x12345678`	reg0
`0xDEADBEEF`	reg3
`0x11111111`	reg4
`0x22222222`	reg5

검증: 0x12345678 ^ 0xDEADBEEF = 0xCC99E897 = gate bit 1의 reg0 ^ reg3 기대값과 정확히 일치한다.

Hidden buf1

Firmware blob blob[0x5C:0x80] 영역:

[0x5C:0x7C] = raw 32바이트 (Grammar A로 인코딩된 데이터)
[0x7C:0x80] = selector dword (0x0000009D)

이 구조가 trace8 디코드에 사용된 Grammar A 블록과 완전히 동일한 [raw data] + [selector dword] 포맷이다. Grammar A를 적용하면:

decoded[i] = blob[0x5C + i] ^ sbox[(0x9D + i) & 0xFF]

PHTM_CTF_KEY_128SECONDHALF_DATA! 라는 의미있는 문자열이 나온다!

이처럼 trace block과 동일한 [raw data] + [selector dword] , 의미있는 ASCII 문자열이 나온 데다가 앞 16바이트 CRC32 = 0x2A8DED84 = gate 상수 f20과 정확히 일치하는 점으로 미루어보았을 때 이게 의도된 buf1 값이라는 걸 알 수 있다.

이때 hidden reg 및 buf1은 QEMU success path에 의해 참조되진 않는다. Hidden marker는 runtime 중에 소비되는 정답이 아니라 숨겨진 값이다.

8. Solve

LA CTF 2026 Writeup (Reflection)

Fri, 13 Feb 2026 00:00:00 GMT

1. Challenge Overview

reflection이라는 Rust 바이너리가 주어진다. 실행하면 인자와 무관하게 항상 panic 메시지가 출력된다:

$ ./reflection
thread 'main' panicked at src/main.rs:2:5:
Come close to me and I'll make you regret it.
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

$ ./reflection a
thread 'main' panicked at src/main.rs:2:5:
Come close to me and I'll make you regret it.

어떤 값을 넘기든 출력은 동일하다. 디컴파일러에서 reflection::main을 확인하면 무조건 panic!()만 호출한다. .text 어디에도 플래그 검증 로직이 없고, 바이너리가 입력을 어떻게 받는지도 알 수 없다.

여기서 드는 두 가지 의문:

검증 로직은 어디에 있는가?
바이너리는 플래그를 어떻게 읽는가?

.text에 검증 코드가 없다면, 검증은 메타데이터에 숨겨져 있어야 한다. Rust에서 panic!()은 스택 Unwinding을 트리거하며, 이 과정에서 .eh_frame(임의의 DWARF 바이트코드를 포함할 수 있는 섹션)을 읽는다. 여기가 다음으로 살펴볼 곳이다.

참고: 후에 기술하겠지만, 플래그는 실제로 커맨드라인 인자로 전달된다. ./reflection "lactf{...}" 정확한 로직은 DWARF 표현식을 분석해야 알 수 있으며, 해당 표현식은 Rust 내부 전역 변수에서 argc와 argv를 직접 읽는다.

2. Background — Stack Unwinding, .eh_frame

2.1 Rust Panic: Unwind vs. Abort

참고: https://os.phil-opp.com/freestanding-rust-binary/

Rust 프로그램이 panic!()을 만나면, 컴파일 시점에 Cargo.toml로 설정된 두 가지 전략 중 하나가 실행된다:

Abort 모드 (panic = "abort"): 프로세스가 즉시 종료된다. 스택 정리도, 소멸자 호출도 없다. 더 단순하고 바이너리 크기가 작아 임베디드, 베어메탈 환경에서 흔히 사용된다.

[profile.release]
panic = "abort"   # 그냥 프로세스를 죽임

Unwind 모드 (기본값): 런타임이 콜 스택을 역방향으로 순회하며, 살아있는 각 지역 변수의 소멸자를 호출하고, catch_unwind를 통한 복구를 허용한다:

use std::panic;

let result = panic::catch_unwind(|| {
    panic!("something went wrong");
});
// result는 Err — 프로그램은 계속 실행됨

Unwinding에는 각 스택 프레임에 대한 메타데이터가 필요하다 — 구체적으로 DWARF Call Frame Information이 포함된 .eh_frame 섹션이다. 이 메타데이터는 Unwinder한테 레지스터 복원 방법과 이전 프레임을 찾는 방법을 알려준다.

이 챌린지 바이너리는 기본 Unwind 모드를 사용한다. 다음을 통해 확인할 수 있다:

panic 출력에 백트레이스 힌트(RUST_BACKTRACE=1)가 포함되어 있으며, 이는 Unwinding에서만 동작함
바이너리에 큰 .eh_frame 섹션이 존재함
panic 도중 libgcc_s.so.1의 _Unwind_RaiseException이 호출됨

즉, panic!()이 Unwinding을 트리거하고, Unwinding이 .eh_frame DWARF 표현식을 평가하므로, 출제자는 해당 표현식 안에 완전한 검증 프로그램을 숨겨놓은 것이다!

2.2 Unwinding 동작 원리: 2-Phase 메커니즘

참고: gcc/libgcc/unwind.inc(https://github.com/gcc-mirror/gcc/tree/master/libgcc)

Rust panic! 이 발생하면, Unwinder는 콜 스택을 역방향으로 순회하며 각 프레임의 저장된 레지스터를 복원하고 정리 코드를 실행한다. Linux x86-64에서 Unwinder는 libgcc_s.so.1에 위치한다. 진입점은 _Unwind_RaiseException()이며, 2단계로 동작한다:

// libgcc/unwind.inc 요약 
_Unwind_RaiseException(exc) {
    // Phase 1 — 검색:
    //   프레임을 위로 순회하며 핸들러(catch_unwind)를 찾음.
    //   아직 아무것도 변경하지 않음. 표현식은 실행되지만 결과는 폐기됨.
    while (1) {
        uw_frame_state_for(&context, &fs);   // FDE 찾기, CFI 파싱
        if (fs.personality)
            personality(..._UA_SEARCH_PHASE...);  // 질의: 정리? 캐치?
        uw_update_context(&context, &fs);     // CFI 규칙 적용
    }

    cur_context = this_context;  // ★ 초기 상태로 리셋

    // Phase 2 — 정리:
    //   처음부터 프레임을 다시 순회.
    //   각 프레임에서: 레지스터 복원, 정리 코드 실행.
    //   핸들러 프레임에 도달하면 점프.
    while (1) {
        uw_frame_state_for(&context, &fs);
        if (fs.personality)
            personality(..._UA_CLEANUP_PHASE...);
        uw_update_context(&context, &fs);     // ★ 표현식 실행, RIP 결정
    }
}

핵심 함수는 uw_update_context()이다. .eh_frame의 CFI 규칙을 읽고 이전 프레임의 레지스터 값을 계산한다. 규칙에 DWARF 표현식이 포함되어 있으면, libgcc 내부의 스택 기반 바이트코드 VM인 execute_stack_op()이 해당 표현식을 평가한다. 두 Phase 모두 동일한 프레임을 순회하므로, 모든 DWARF 표현식은 두 번 실행된다(각 Phase에서 한 번씩.) 그러나 Phase 1은 이후 컨텍스트를 리셋하므로 Phase 2의 결과만 주의깊게 보면 된다.

2.3 .eh_frame section: CIE, FDE

참고: https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html

.eh_frame 섹션은 하나 이상의 Call Frame Information(CFI) 레코드를 포함해야 한다.

레코드 개수는 섹션 헤더에 명시된 섹션 크기에 따라 결정된다.

각 CFI 레코드는 다음으로 구성된다:

하나의 Common Information Entry (CIE)
그 뒤에 하나 이상의 Frame Description Entry (FDE)

CIE와 FDE는 모두 주소 단위 크기의 경계에 정렬(aligned)되어야 한다.

CIE (Common Information Entry) — 여러 함수가 공유하는 템플릿:

Field	Usage
`Augmentation String`	기능 플래그: `"zR"` (기본), `"zPLR"` (personality 함수 포함)
`Code Align`ment factor	명령어 정렬 인수 (x86-64에서 1)
`Data Align`ment factor	스택 슬롯 인수 (x86-64에서 -8)
`Return Address Register`	복귀 주소 레지스터 (16 = RIP)
`Initial Instructions`	모든 FDE가 상속하는 기본 CFI 규칙

FDE (Frame Description Entry) — 함수당 하나:

Field	Usage
`PC Begin`	함수 시작 주소
`PC Range`	함수 크기(바이트)
`Call Frame Instructions`	스택 프레임 변화를 기술하는 CFI 바이트코드

2.4 두 가지 바이트코드 시스템: DW_CFA vs. DW_OP

참고: https://dwarfstd.org/doc/DWARF5.pdf

DWARF is a debugging information file format used by many compilers and debuggers to support source level debugging. It addresses the requirements of a number of procedural languages, such as C, C++, and Fortran, and is designed to be extensible to other languages. DWARF is architecture independent and applicable to any processor or operating system. It is widely used on Unix, Linux and other operating systems, as well as in stand-alone environments.

DWARF는 두 종류의 바이트코드 시스템을 포함한다:

DWARF Expressions (DW_OP_*) — 스택 기반 표현식 평가 언어
Call Frame Instructions (DW_CFA_*) — 레지스터 복원 규칙을 생성하는 상태 머신

구분	DWARF Expression	DW_CFA Instruction
정의	스택 기반 표현식 평가기	콜 프레임 기술 언어
모델	스택 기반 가상 평가기	복원 규칙을 생성하는 상태 머신
목적	값/주소 계산	CFA 및 레지스터 복원 규칙

대부분의 CFI 명령어는 콜 프레임 상태 복원 방법을 기술하는 규칙 테이블을 단순히 업데이트한다. 그러나 특정 DW_CFA 명령어는 DWARF 표현식을 피연산자로 내장할 수 있다:

CFI Instruction	Meaning
`DW_CFA_def_cfa_expression`	표현식 E를 평가하여 CFA를 계산
`DW_CFA_expression(reg)`	표현식 E가 레지스터 `reg`이 저장된 주소를 계산
`DW_CFA_val_expression(reg)`	표현식 E가 레지스터 `reg`의 값을 계산

uw_update_context() (Unwinder 함수)가 이러한 명령어를 만나면, libgcc/unwind-dw2.c의 execute_stack_op() — 산술, 메모리 접근, 제어 흐름, 레지스터 읽기를 지원하는 스택 기반 DWARF VM — 을 호출한다.

이 챌린지에서 출제자는 12,888바이트짜리 검증 프로그램을 DW_CFA_val_expression 안에 심었다.

3. 숨겨진 코드 찾기

3.1 Expressions 스캔

참고: https://man7.org/linux/man-pages/man1/readelf.1.html

readelf의 --debug-dump=frames 옵션을 이용해 보면,

$ readelf --debug-dump=frames ./reflection | grep expression
  DW_CFA_def_cfa_expression (DW_OP_breg7 (rsp): 8; ...)
  DW_CFA_val_expression: r16 (rip) (DW_OP_GNU_encoded_addr: ... (Unknown location op 0x5))
  DW_CFA_val_expression: r2 (rcx) (DW_OP_const8u: 342697)
  DW_CFA_val_expression: r12 (r12) (DW_OP_const8u: 4469372305074626438)
  DW_CFA_val_expression: r16 (rip) (DW_OP_GNU_encoded_addr: ... (Unknown location op 0x1))
  DW_CFA_val_expression: r13 (r13) (DW_OP_const8u: 5860663257725425333)
  DW_CFA_expression: r8 (r8) (DW_OP_GNU_encoded_addr: fmt:42 addr:0000000000000024)

6개 FDE에 걸쳐 7개의 DWARF 표현식이 있는 것을 알 수 있다. 바이너리의 대부분의 FDE는 단순한 CFI 규칙만 갖고 있다. 이 7개가 의심스럽다.

이때 readelf가 두 개의 r16 (rip) 표현식을 파싱하지 못하고 (Unknown location op)으로 보고하고 있는데, 이는 readelf가 지원하지 않는 funcrel|uleb128 인코딩의 DW_OP_GNU_encoded_addr (0xF1)을 사용하기 때문이다. 0xF1 이후 바이트를 잘못 파싱하고 포기한다.

실제 표현식은 115바이트와 12,888바이트로, 일반 CFI에 비해 훨씬 크다. raw 바이트는 다른 방법으로 추출해야 한다.

3.2 GDB 디버깅 — Expressions 추출

참고: gcc/libgcc/unwind-dw2.의 execute_stack_op() 함수(https://github.com/gcc-mirror/gcc/tree/705d87ba8e987cb8e0ca8b6d400c0aff8739eb23/libgcc)

readelf가 이 표현식들을 완전히 파싱할 수 없으므로, 런타임에서 추출해야 한다.

핵심 인사이트: libgcc의 execute_stack_op()은 raw 표현식 바이트를 인자로 받는다.

// libgcc/unwind-dw2.c
static _Unwind_Word
execute_stack_op(const unsigned char *op_ptr,   // 표현식 시작
                 const unsigned char *op_end,   // 표현식 끝
                 struct _Unwind_Context *context,
                 _Unwind_Word initial)

이 함수에 브레이크포인트를 걸면 실행되는 모든 DWARF 표현식을 검사할 수 있다:

$ gdb ./reflection
(gdb) set args "AAAA"
(gdb) start                          # libgcc_s.so.1 로드
(gdb) break execute_stack_op         # DWARF 표현식 VM 진입점
(gdb) continue

브레이크포인트에 도달할 때마다, op_end - op_ptr로 정확한 표현식 크기를 알 수 있고, x/<size>xb $rdi로 원시 바이트를 덤프할 수 있다. Python GDB 스크립트(reflection_dump.py)로 이를 자동화한다: 각 호출마다 inferior.read_memory()로 원시 바이트를 읽고, .bin 파일로 저장하며, 컨텍스트 레지스터 상태를 기록한다.

2-phase Unwinding으로 인해, 각 표현식은 두 번 실행된다 (Phase 1 + Phase 2). op_ptr 주소로 중복을 제거하고, Phase 2 실행만 유지하도록 스크립트를 작성했다:

reflection_dump.py

"""
reflection_dump.py
LACTF reflection - DWARF expression dump + analysis

Usage: gdb -x reflection_dump.py ./reflection
Output: expr_p{1,2}_N_{size}b.bin  (Phase_CallNumber_Size)

Examples:
  expr_p1_1_9b.bin      Phase 1, call #1, 9 bytes (RCX constant)
  expr_p1_3_115b.bin    Phase 1, call #3, 115 bytes (trigger)
  expr_p2_7_12888b.bin  Phase 2, call #7, 12888 bytes (main VM)
"""

import gdb
import struct
import os

FLAG_INPUT = "lactf{si" + "A" * 38 + "}"  # 8 + 38 + 1 = 47
OUTDIR = "./reflection_exprs"
PRINT_LIMIT = 256  # Max bytes for terminal output (truncates to head/tail if exceeded)
PRINT_HEAD = 128
PRINT_TAIL = 64

call_num = 0
phase = 1
phase1_ctx = None
seen = {}  # op_ptr -> (call_num, size, data, ctx_addr) deduplication map

def read_bytes(addr, size):
    """Read raw bytes from memory"""
    inferior = gdb.selected_inferior()
    return bytes(inferior.read_memory(addr, size))

def get_reg(ctx_addr, idx):
    """Return context register (by_value, value)"""
    try:
        bv = int(gdb.parse_and_eval(
            f"((struct _Unwind_Context*){ctx_addr:#x})->by_value[{idx}]"))
        val = int(gdb.parse_and_eval(
            f"(unsigned long)((struct _Unwind_Context*){ctx_addr:#x})->reg[{idx}]"))
        return bv, val
    except:
        return -1, 0

def get_cfa(ctx_addr):
    try:
        return int(gdb.parse_and_eval(
            f"(unsigned long)((struct _Unwind_Context*){ctx_addr:#x})->cfa"))
    except:
        return 0

def hexdump(data, addr, limit=None):
    """Pretty hex dump. Shows only head/tail if limit is exceeded."""
    if limit and len(data) > limit:
        # Head section
        for i in range(0, PRINT_HEAD, 16):
            chunk = data[i:i+16]
            hex_str = " ".join(f"{b:02x}" for b in chunk)
            ascii_str = "".join(chr(b) if 32 <= b < 127 else "." for b in chunk)
            print(f"  {addr+i:012x}  {hex_str:<48s}  {ascii_str}")
        print(f"  ... ({len(data) - PRINT_HEAD - PRINT_TAIL} bytes omitted) ...")
        # Tail section
        start = len(data) - PRINT_TAIL
        start = (start // 16) * 16
        for i in range(start, len(data), 16):
            chunk = data[i:i+16]
            hex_str = " ".join(f"{b:02x}" for b in chunk)
            ascii_str = "".join(chr(b) if 32 <= b < 127 else "." for b in chunk)
            print(f"  {addr+i:012x}  {hex_str:<48s}  {ascii_str}")
    else:
        for i in range(0, len(data), 16):
            chunk = data[i:i+16]
            hex_str = " ".join(f"{b:02x}" for b in chunk)
            ascii_str = "".join(chr(b) if 32 <= b < 127 else "." for b in chunk)
            print(f"  {addr+i:012x}  {hex_str:<48s}  {ascii_str}")

def save_bin(data, filename):
    """Save as binary file"""
    path = os.path.join(OUTDIR, filename)
    with open(path, "wb") as f:
        f.write(data)
    return path

def save_context(ctx_addr, filename):
    """Save context registers as JSON-like text"""
    regs = {}
    for idx, name in [(2, "rcx"), (8, "r8"), (12, "r12"), (13, "r13"), (16, "rip")]:
        bv, val = get_reg(ctx_addr, idx)
        regs[name] = {"by_value": bv, "value": val}
        # Dereference if by_value=0 and value is non-zero
        if bv == 0 and val != 0:
            try:
                deref = int(gdb.parse_and_eval(f"*(unsigned long*){val:#x}"))
                regs[name]["deref"] = deref
            except:
                pass
    regs["cfa"] = get_cfa(ctx_addr)

    path = os.path.join(OUTDIR, filename)
    with open(path, "w") as f:
        for name, info in regs.items():
            if isinstance(info, dict):
                bv = info["by_value"]
                val = info["value"]
                deref = info.get("deref")
                line = f"{name}: by_value={bv} val={val:#018x}"
                if deref is not None:
                    line += f" *val={deref:#018x}"
                f.write(line + "\n")
            else:
                f.write(f"{name}: {info:#018x}\n")
    return path

class ExprBreakpoint(gdb.Breakpoint):
    def stop(self):
        global call_num, phase, phase1_ctx, seen

        try:
            op_ptr = int(gdb.parse_and_eval("(unsigned long)$rdi"))
            op_end = int(gdb.parse_and_eval("(unsigned long)$rsi"))
            ctx = int(gdb.parse_and_eval("(unsigned long)$rdx"))
            initial = int(gdb.parse_and_eval("(unsigned long)$rcx"))
        except:
            return True

        call_num += 1
        size = op_end - op_ptr

        # Phase detection
        if call_num == 1:
            phase1_ctx = ctx
            phase = 1
        elif ctx != phase1_ctx and phase == 1:
            phase = 2

        # Read raw bytes
        data = read_bytes(op_ptr, size)

        # Dedup check: overwrite if same op_ptr (Phase 2 takes precedence)
        is_new = op_ptr not in seen
        seen[op_ptr] = {
            "call_num": call_num,
            "phase": phase,
            "size": size,
            "data": data,
            "ctx": ctx,
            "initial": initial,
            "op_ptr": op_ptr,
        }

        # Output
        dup_tag = "" if is_new else " [overwrite]"
        print()
        print(f"{'='*60}")
        print(f"  #{call_num}  |  Phase {phase}  |  {size} bytes{dup_tag}")
        print(f"{'='*60}")

        # Register summary
        for idx, name in [(2, "RCX"), (8, "R8"), (12, "R12"), (13, "R13")]:
            bv, val = get_reg(ctx, idx)
            tag = "val" if bv == 1 else "ptr" if bv == 0 else "?"
            extra = ""
            if bv == 0 and val != 0:
                try:
                    deref = int(gdb.parse_and_eval(f"*(unsigned long*){val:#x}"))
                    extra = f" → {deref:#x}"
                except:
                    pass
            print(f"  {name:>3}: [{tag}] {val:#x}{extra}")
        print(f"  CFA: {get_cfa(ctx):#x}")
        print()

        # Hex dump
        hexdump(data, op_ptr, limit=PRINT_LIMIT)

        # Extra info for 115-byte expressions
        if size == 115:
            bv_rcx, val_rcx = get_reg(ctx, 2)
            if bv_rcx == 1 and val_rcx != 0:
                print()
                try:
                    argc = int(gdb.parse_and_eval(f"*(unsigned long*){val_rcx - 89:#x}"))
                    argv_ptr = int(gdb.parse_and_eval(f"*(unsigned long*){val_rcx - 81:#x}"))
                    argv1 = int(gdb.parse_and_eval(f"*(unsigned long*){argv_ptr + 8:#x}"))
                    argv1_s = gdb.execute(f"x/s {argv1:#x}", to_string=True).split(":", 1)[1].strip()
                    print(f"  argc={argc}, argv[1]={argv1_s}")
                except:
                    pass

        print(f"{'='*60}")

        return False  # Auto-continue

def main():
    os.makedirs(OUTDIR, exist_ok=True)
    # Clean up existing files
    for f in os.listdir(OUTDIR):
        os.remove(os.path.join(OUTDIR, f))

    print(f"\n[*] LACTF reflection expression dumper")
    print(f"[*] Input: {FLAG_INPUT}")
    print(f"[*] Output: {OUTDIR}/")
    print()

    gdb.execute(f'set args "{FLAG_INPUT}"')
    gdb.execute("set pagination off")
    gdb.execute("set confirm off")
    gdb.execute("start")

    bp = ExprBreakpoint("execute_stack_op")
    bp.silent = True

    print(f"\n[*] Continuing to panic...\n")
    gdb.execute("continue")

    # Save only deduplicated expressions
    print(f"\n{'='*60}")
    print(f"  {call_num} total calls, {len(seen)} unique expressions")
    print(f"  Output directory: {OUTDIR}/")
    print()

    # Sort by execution order (call_num)
    sorted_exprs = sorted(seen.values(), key=lambda x: x["call_num"])

    for i, info in enumerate(sorted_exprs, 1):
        size = info["size"]
        bin_name = f"expr_{i}_{size}b.bin"
        ctx_name = f"expr_{i}_{size}b_ctx.txt"

        # Save .bin
        save_bin(info["data"], bin_name)

        # Save context (Phase 2 values)
        save_context(info["ctx"], ctx_name)

        # Description labels
        labels = {9: "constant assign", 4: "address encoding", 115: "1st validation", 12888: "2nd validation VM"}
        label = labels.get(size, f"{size}b")

        fpath = os.path.join(OUTDIR, bin_name)
        print(f"  {bin_name:>30s}  ({os.path.getsize(fpath):>6d} bytes)"
              f"  #{info['call_num']:>2d}  @{info['op_ptr']:#x}  {label}")

    print(f"{'='*60}")

main()

이때 1차 검증 로직에 따라 올바른 47바이트 입력(lactf{si + 38*A + })을 주고 덤프하면, Phase 2 실행 순서로 6개의 expressions가 나타난다:

#  크기       op_ptr 주소       설명
1    9 bytes  0x55555559e567   val_expression(RCX) = 상수 대입
2    4 bytes  0x5555555a4ea9   expression(R8) = 주소 인코딩
3  115 bytes  0x55555559cbf1   val_expression(RIP) — 1차 검증
4    9 bytes  0x5555555a1ba8   val_expression(R12) = 상수 대입
5    9 bytes  0x5555555a4e10   val_expression(R13) = 상수 대입
6  12888 bytes 0x5555555a1bb5  val_expression(RIP) — 2차 검증 VM

표현식 #4~#6은 115바이트 사전 검사(#3)를 통과할 때만 나타난다.

입력이 잘못되면, Unwinding은 정상 복귀 경로를 타고 이 표현식들은 실행되지 않는다. 이 경우 프로세스는 총 6번의 호출(Phase당 3개 × 2 Phase, 표현식 #1~#3만)로 종료된다.

3.3 Expression 체인

정리하면, 전체 로직은 6개 표현식이 순서대로 실행되면서, 앞의 표현식이 설정한 레지스터 값을 뒤의 표현식이 읽는 구조다:

❶ val_expression(RCX) = 0x53AA9         → ARGV 전역 변수 접근 기준점
❷ expression(R8) = 0x555555590d94       → .text 영역 주소. 역참조하면 0x0f10478b4808578b
                                           (코드 바이트를 해시 상수 겸 XOR 키로 재활용)
❸ val_expression(RIP) [115B]            → 1차 검증: argc, strlen, 해시, '}' 확인
                                           통과 시 RIP를 리다이렉트 → ❹❺❻ 실행
                                           실패 시 정상 복귀 → ❹❺❻ 미실행
❹ val_expression(R12) = 0x3E06666E84F11F86  → 2차 VM용 상수 키
❺ val_expression(R13) = 0x5155422E88E856B5  → 2차 VM용 상수 키
❻ val_expression(RIP) [12,888B]         → 2차 검증: 38개 블록으로 나머지 플래그 검증

❹❺❻은 같은 FDE에 속해 있어 Unwinder가 해당 FDE를 처리할 때 세 표현식이 함께 실행된다. ❸의 1차 검증이 실패하면 이 FDE에 도달하지 않으므로 ❹❺❻은 실행되지 않는다.

나의 경우는 lactf{test} 같은 문자열을 줬을 때 ❸까지만 멈춘 걸 보고 해당 표현식 바이트를 덤프해서 로직을 분석하고 초기 입력 검증 조건을 알아냈다.

3.4 115바이트 입력값 검증

이게 표현식 ❸의 Phase2 115바이트 덤프이다

============================================================
  #9  |  Phase 2  |  115 bytes [overwrite]
============================================================
  RCX: [val] 0x5555555a7aa9
   R8: [ptr] 0x555555590d94 → 0xf10478b4808578b
  R12: [ptr] 0x7fffffffdf80 → 0x0
  R13: [ptr] 0x7fffffffdf88 → 0x1000
  CFA: 0x7fffffffe050

  55555559cbf1  f1 41 06 06 08 ff 1a 3d 1c 0a 05 0a 16 52 16 1c   .A.....=.....R..
  55555559cc01  16 13 12 06 32 2e 28 56 00 23 08 06 23 08 06 12   ....2.(V.#..#...
  55555559cc11  30 16 12 06 08 ff 1a 30 29 28 09 00 23 01 16 23   0......0)(..#..#
  55555559cc21  01 16 2f ed ff 17 08 4b 27 08 64 2e 16 06 30 31   ../....K'.d...01
  55555559cc31  1c 40 25 22 0e dc 66 8d a7 9d 87 cc 0c 33 24 27   .@%"..f......3$'
  55555559cc41  58 2e 21 16 31 1c 06 08 ff 1a 08 7d 2e 21 28 08   X.!.1......}.!(.
  55555559cc51  00 f1 41 e1 b7 0e 2f 03 00 38 1c 06 2f 04 00 13   ..A.../..8../...
  55555559cc61  38 1c 06                                          8..

여기서 바이너리가 플래그를 읽는 방식이 드러난다. 사전 검사 표현식은 표현식 ❶에서 0x53AA9로 설정된 RCX 기준 상대 주소를 계산하는 것으로 시작한다. GDB에서:

(gdb) x/gx (0x5555555a7aa9 - 89)
0x5555555a7a50 <std::sys::args::unix::imp::ARGC.0>: 0x0000000000000002

(gdb) x/gx (0x5555555a7aa9 - 81)
0x5555555a7a58 <std::sys::args::unix::imp::ARGV.0>: 0x00007fffffffe268

(gdb) set $argv = *(unsigned long*)(0x5555555a7aa9 - 81)
(gdb) x/s *(char**)($argv + 8)
0x7fffffffe516: "lactf{test}"

이 표현식은 Rust 런타임이 내부적으로 저장하는 raw 전역 변수에서 argv를 읽는다. 이로써 플래그가 ./reflection "lactf{...}"로 전달된다는 것이 확실해졌다.

DWARF op코드가 *(RCX-89) == 2 (카운트가 2인지 확인)와 *(*(RCX-81)+8) (포인터 배열을 따라가 두 번째 요소에 접근)이라는 접근 패턴을 보여주었다. 이것이 argc/argv처럼 보였고, GDB가 해당 주소에서 ARGC.0과 ARGV.0이라는 심볼 이름을 보여줌으로써 확인되었다.

사전 검사는 115바이트 DWARF 표현식을 통해 네 가지 조건을 검증한다:

블록 A — argc 검사 (오프셋 0–24):

GNU_encoded_addr(funcrel, 6) → 0x3046   ; NOP 패딩 바이트 주소
deref → *(0x3046) & 0xFF = 0x66
lit13; minus → 0x66 - 13 = 89           ; ARGC까지의 오프셋 계산
reg2 (RCX); minus → RCX - 89 = ARGC_addr
deref → *(ARGC_addr) = argc
lit2; ne → (argc ≠ 2)?
bra(+86) → argc ≠ 2이면 탈출

블록 B — argv[1] 포인터 (오프셋 25–33):

plus_uconst(8); deref → *(ARGC_addr + 8) = ARGV_ptr
plus_uconst(8); deref → *(ARGV_ptr + 8) = argv[1] = flag_ptr

블록 C — strlen 루프 (오프셋 34–52):

LOOP:
  dup; deref → 현재 바이트
  const1u(0xFF); and → 8비트로 마스킹
  lit0; eq → 널 검사
  bra(+9) → 널이면 탈출
  plus_uconst(1) → ptr++
  swap; plus_uconst(1); swap → count++
  skip(-19) → 루프 복귀

블록 D — 3중 검증 (오프셋 53–96):

검증 1: (count ^ 75) != 100 → strlen ≠ 47 → 실패
검증 2: (first8_le + 0x0000FFFFFFFFFFFF) ^ 0x66643CED3C6B36E0 != R8 → 해시 실패
검증 3: last_byte != 0x7D ('}') → 실패

성공/실패 분기 (오프셋 97–114):

모든 검사 통과 → RIP = GNU_encoded_addr(funcrel, 236513) = 0x3CC21 → 가상 프레임
검사 실패 → RIP = *(CFA-8) = 정상 복귀 주소 → 종료

처음 8바이트에 대한 해시 검사를 역산할 수 있다:

first8 + 0x0000FFFFFFFFFFFF = R8_val ^ 0x66643CED3C6B36E0
       = 0x0f10478b4808578b ^ 0x66643CED3C6B36E0
       = 0x69747B667463616B

first8 = 0x69747B667463616B - 0x0000FFFFFFFFFFFF
       = 0x69737B667463616C

LE → ASCII: 6C 61 63 74 66 7B 73 69 = "lactf{si"

이로써 플래그 접두사가 확인되고, 위치 0–7이 lactf{si임을 알 수 있다.

4. 12KB DWARF VM 리버싱

4.1 바이트코드 추출 및 디코딩

참고: https://github.com/gcc-mirror/gcc/tree/705d87ba8e987cb8e0ca8b6d400c0aff8739eb23/libgcc

메인 표현식은 가상 프레임 FDE의 12,888바이트 val_expression(RIP)이다.

마찬가지로 앞서 작성한 GDB 덤프 스크립트로 통째로 덤프했다.

이후 libgcc/unwind-dw2.c의 execute_stack_op()과 libgcc/unwind-pe.h를 기반으로 한 커스텀 디코더(dwarf_decoder.py)가 이를 9,195개의 명령어로 디스어셈블했다.

dwarf_decoder.py

#!/usr/bin/env python3
"""
DWARF Expression VM Decoder
============================
Decodes DW_OP_* opcodes from raw .eh_frame bytecode,
including GNU extension DW_OP_GNU_encoded_addr (0xF1).

Based on libgcc/unwind-dw2.c execute_stack_op() and libgcc/unwind-pe.h

Usage:
  python3 dwarf_decoder.py <dwarf_vm.bin>
"""
import sys, struct
from collections import Counter

# x86-64 register name mapping
REG_NAMES = {
    0:"rax", 1:"rdx", 2:"rcx", 3:"rbx", 4:"rsi", 5:"rdi", 6:"rbp", 7:"rsp",
    8:"r8", 9:"r9", 10:"r10", 11:"r11", 12:"r12", 13:"r13", 14:"r14", 15:"r15", 16:"rip"
}

def regname(n):
    return REG_NAMES.get(n, f"r{n}")

# ═══════════════════════════════════════════════════
#  LEB128 readers
# ═══════════════════════════════════════════════════

def read_uleb128(data, pos):
    result = shift = 0
    while pos < len(data):
        b = data[pos]; pos += 1
        result |= (b & 0x7f) << shift; shift += 7
        if not (b & 0x80): break
    return result, pos

def read_sleb128(data, pos):
    result = shift = 0; b = 0
    while pos < len(data):
        b = data[pos]; pos += 1
        result |= (b & 0x7f) << shift; shift += 7
        if not (b & 0x80): break
    if shift < 64 and (b & 0x40): result |= -(1 << shift)
    if result >= (1 << 63): result -= (1 << 64)
    return result, pos

# ═══════════════════════════════════════════════════
#  GNU encoded address decoder
# ═══════════════════════════════════════════════════

MOD_NAMES = {0x00:"abs", 0x10:"pcrel", 0x20:"textrel", 0x30:"datarel", 0x40:"funcrel", 0x50:"aligned"}
FMT_NAMES = {0x00:"ptr", 0x01:"uleb", 0x02:"u2", 0x03:"u4", 0x04:"u8",
             0x09:"sleb", 0x0a:"s2", 0x0b:"s4", 0x0c:"s8"}

def decode_encoded_addr(data, pos):
    """Decode DW_OP_GNU_encoded_addr per libgcc/unwind-pe.h"""
    enc = data[pos]; pos += 1
    fmt = enc & 0x0f; modifier = enc & 0x70; indirect = enc & 0x80

    if   fmt == 0x00: val = int.from_bytes(data[pos:pos+8], 'little'); pos += 8
    elif fmt == 0x01: val, pos = read_uleb128(data, pos)
    elif fmt == 0x02: val = int.from_bytes(data[pos:pos+2], 'little'); pos += 2
    elif fmt == 0x03: val = int.from_bytes(data[pos:pos+4], 'little'); pos += 4
    elif fmt == 0x04: val = int.from_bytes(data[pos:pos+8], 'little'); pos += 8
    elif fmt == 0x09: val, pos = read_sleb128(data, pos)
    elif fmt == 0x0a: val = int.from_bytes(data[pos:pos+2], 'little', signed=True); pos += 2
    elif fmt == 0x0b: val = int.from_bytes(data[pos:pos+4], 'little', signed=True); pos += 4
    elif fmt == 0x0c: val = int.from_bytes(data[pos:pos+8], 'little', signed=True); pos += 8
    else: val = 0

    enc_str = f"{MOD_NAMES.get(modifier,'?')}|{FMT_NAMES.get(fmt,'?')}"
    if indirect: enc_str += "|indirect"
    return val, enc_str, pos

# ═══════════════════════════════════════════════════
#  Main decoder
# ═══════════════════════════════════════════════════

def decode_dwarf_expr(data, func_base=0x3cc20):
    """Decode DWARF expression bytecode into (offset, name, description, metadata) list."""
    pos = 0; insns = []

    while pos < len(data):
        off = pos; op = data[pos]; pos += 1

        # DW_OP_lit0..lit31 (0x30..0x4f)
        if 0x30 <= op <= 0x4f:
            v = op - 0x30
            insns.append((off, f"lit{v}", f"push {v}", []))
        # DW_OP_reg0..reg31 (0x50..0x6f)
        elif 0x50 <= op <= 0x6f:
            r = op - 0x50
            insns.append((off, f"reg{r}", f"push {regname(r)}", []))
        # DW_OP_breg0..breg31 (0x70..0x8f)
        elif 0x70 <= op <= 0x8f:
            r = op - 0x70; sv, pos = read_sleb128(data, pos)
            insns.append((off, f"breg{r}", f"push {regname(r)}+({sv})", []))

        elif op == 0x03:  # DW_OP_addr
            v = int.from_bytes(data[pos:pos+8], 'little'); pos += 8
            insns.append((off, "addr", f"push 0x{v:x}", []))
        elif op == 0x06:
            insns.append((off, "deref", "pop a; push *(uint64*)a", []))
        elif op == 0x08:
            v = data[pos]; pos += 1
            insns.append((off, "const1u", f"push {v} (0x{v:02x})", []))
        elif op == 0x09:
            v = struct.unpack_from('b', data, pos)[0]; pos += 1
            insns.append((off, "const1s", f"push {v}", []))
        elif op == 0x0a:
            v = int.from_bytes(data[pos:pos+2], 'little'); pos += 2
            insns.append((off, "const2u", f"push {v} (0x{v:04x})", []))
        elif op == 0x0b:
            v = int.from_bytes(data[pos:pos+2], 'little', signed=True); pos += 2
            insns.append((off, "const2s", f"push {v}", []))
        elif op == 0x0c:
            v = int.from_bytes(data[pos:pos+4], 'little'); pos += 4
            insns.append((off, "const4u", f"push 0x{v:08x}", []))
        elif op == 0x0e:
            v = int.from_bytes(data[pos:pos+8], 'little'); pos += 8
            insns.append((off, "const8u", f"push 0x{v:016x}", []))
        elif op == 0x0f:
            v = int.from_bytes(data[pos:pos+8], 'little', signed=True); pos += 8
            insns.append((off, "const8s", f"push {v}", []))
        elif op == 0x10:
            v, pos = read_uleb128(data, pos)
            insns.append((off, "constu", f"push {v} (0x{v:x})", []))
        elif op == 0x11:
            v, pos = read_sleb128(data, pos)
            insns.append((off, "consts", f"push {v}", []))

        elif op == 0x12: insns.append((off, "dup",   "push TOS", []))
        elif op == 0x13: insns.append((off, "drop",  "pop TOS", []))
        elif op == 0x14: insns.append((off, "over",  "push stack[-2]", []))
        elif op == 0x15:
            idx = data[pos]; pos += 1
            insns.append((off, "pick", f"push stack[-{idx+1}]", []))
        elif op == 0x16: insns.append((off, "swap",  "swap TOS and TOS-1", []))
        elif op == 0x17: insns.append((off, "rot",   "rotate top 3: [a,b,c]->[c,a,b]", []))
        elif op == 0x19: insns.append((off, "abs",   "TOS = |TOS|", []))

        elif op == 0x1a: insns.append((off, "and",   "pop b,a; push a & b", []))
        elif op == 0x1b: insns.append((off, "div",   "pop b,a; push a / b", []))
        elif op == 0x1c: insns.append((off, "minus", "pop b,a; push a - b", []))
        elif op == 0x1d: insns.append((off, "mod",   "pop b,a; push a % b", []))
        elif op == 0x1e: insns.append((off, "mul",   "pop b,a; push a * b", []))
        elif op == 0x1f: insns.append((off, "neg",   "TOS = -TOS", []))
        elif op == 0x20: insns.append((off, "not",   "TOS = ~TOS", []))
        elif op == 0x21: insns.append((off, "or",    "pop b,a; push a | b", []))
        elif op == 0x22: insns.append((off, "plus",  "pop b,a; push a + b", []))
        elif op == 0x23:
            v, pos = read_uleb128(data, pos)
            insns.append((off, "plus_uconst", f"TOS += {v}", []))
        elif op == 0x24: insns.append((off, "shl",   "pop b,a; push a << b", []))
        elif op == 0x25: insns.append((off, "shr",   "pop b,a; push a >> b (unsigned)", []))
        elif op == 0x26: insns.append((off, "shra",  "pop b,a; push a >> b (signed)", []))
        elif op == 0x27: insns.append((off, "xor",   "pop b,a; push a ^ b", []))

        elif op == 0x28:  # DW_OP_bra (conditional branch)
            soff = int.from_bytes(data[pos:pos+2], 'little', signed=True); pos += 2
            tgt = pos + soff
            insns.append((off, "bra", f"if TOS!=0 goto {tgt} (offset {soff:+d})", [("target", tgt)]))

        elif op == 0x29: insns.append((off, "eq", "pop b,a; push (a == b)", []))
        elif op == 0x2a: insns.append((off, "ge", "pop b,a; push (a >= b)", []))
        elif op == 0x2b: insns.append((off, "gt", "pop b,a; push (a > b)", []))
        elif op == 0x2c: insns.append((off, "le", "pop b,a; push (a <= b)", []))
        elif op == 0x2d: insns.append((off, "lt", "pop b,a; push (a < b)", []))
        elif op == 0x2e: insns.append((off, "ne", "pop b,a; push (a != b)", []))

        elif op == 0x2f:  # DW_OP_skip (unconditional branch)
            soff = int.from_bytes(data[pos:pos+2], 'little', signed=True); pos += 2
            tgt = pos + soff
            insns.append((off, "skip", f"goto {tgt} (offset {soff:+d})", [("target", tgt)]))

        elif op == 0x90:  # DW_OP_regx
            v, pos = read_uleb128(data, pos)
            insns.append((off, "regx", f"push {regname(v)} (reg {v})", []))
        elif op == 0x91:  # DW_OP_fbreg
            sv, pos = read_sleb128(data, pos)
            insns.append((off, "fbreg", f"push CFA+({sv})", []))
        elif op == 0x93:  # DW_OP_piece
            v, pos = read_uleb128(data, pos)
            insns.append((off, "piece", f"piece({v} bytes)", []))
        elif op == 0x9f:
            insns.append((off, "stack_value", "TOS is the value (not addr)", []))

        elif op == 0xf1:  # DW_OP_GNU_encoded_addr
            val, enc_str, pos = decode_encoded_addr(data, pos)
            if "funcrel" in enc_str:
                resolved = func_base + val
                insns.append((off, "GNU_encoded_addr", f"({enc_str}, {val}) -> 0x{resolved:x}", []))
            elif "datarel" in enc_str:
                insns.append((off, "GNU_encoded_addr", f"({enc_str}, {val}) -> dbase+{val}", []))
            else:
                insns.append((off, "GNU_encoded_addr", f"({enc_str}, {val})", []))

        elif op == 0x00:
            insns.append((off, "nop", "", []))
        else:
            insns.append((off, f"UNKNOWN_0x{op:02x}", "???", []))

    return insns

# ═══════════════════════════════════════════════════
#  Main
# ═══════════════════════════════════════════════════

def main():
    if len(sys.argv) != 2:
        print(f"Usage: python3 {sys.argv[0]} <dwarf_vm.bin>")
        sys.exit(1)

    data = open(sys.argv[1], "rb").read()
    print(f"Loaded {len(data)} bytes of DWARF expression bytecode\n")

    insns = decode_dwarf_expr(data, func_base=0x3cc20)

    # Collect branch targets for annotation
    targets = {v for _, _, _, meta in insns for k, v in meta if k == "target"}

    # Print disassembly
    print(f"{'OFF':>5}  {'OPCODE':<22} {'DESCRIPTION'}")
    print("=" * 80)
    for off, name, desc, _ in insns:
        prefix = ">>>" if off in targets else "   "
        print(f"{prefix}{off:5d}  {name:<22} {desc}")

    print(f"\nTotal: {len(insns)} instructions decoded from {len(data)} bytes")

    # Top opcodes
    counts = Counter(name.split('(')[0] for _, name, _, _ in insns)
    print(f"\nTop opcodes:")
    for name, count in counts.most_common(20):
        print(f"  {name}: {count}")

if __name__ == "__main__":
    main()

디코더는 바이트코드에서 사용된 모든 DW_OP Op코드를 처리하며, 다양한 인코딩 형식(funcrel|uleb128, datarel|udata4 등)의 GNU 확장 DW_OP_GNU_encoded_addr(0xF1)도 포함한다.

$ python3 dwarf_decoder.py dwarf_vm.bin
Loaded 12888 bytes of DWARF expression bytecode

  OFF  OPCODE                 DESCRIPTION
================================================================================
     0  GNU_encoded_addr       (datarel|uleb, 8) → dbase+8
     3  breg2                  push rcx+(-81)
     6  deref                  pop a; push *(uint64*)a
     7  plus                   pop b,a; push a + b
     8  deref                  pop a; push *(uint64*)a
     9  const2u                push 5377 (0x1501)
    ...
 12884  GNU_encoded_addr       (funcrel|uleb, 14000) → 0x402d0

Total: 9195 instructions decoded from 12888 bytes

4.2 제약 조건 요약

12,888바이트 VM은 38개의 검증 블록으로 구성된다. 각 블록은 결과로 0 또는 1을 반환하고, 전체가 AND되어 하나라도 실패하면 최종 결과는 0이다.

각 블록의 검증 방식은 이렇다: 플래그 바이트를 2진수로 펼친 뒤, 1이 연속으로 붙어있는 덩어리만 골라 각 덩어리의 크기를 기록한다. 0은 구분자일 뿐이고, 1 덩어리의 크기를 왼쪽부터 나열한 것이 그 바이트의 "시그니처"다:

'e' = 01100101
      0 [11] 00 [1] 0 [1]    → 시그니처 = [2, 1, 1]

'_' = 01011111
      0 [1] 0 [11111]        → 시그니처 = [1, 5]

VM은 플래그의 각 글자에 대해 이 시그니처를 계산하고, 미리 정해둔 정답 시그니처와 같은지 비교한다.

블록은 두 유형이다:

바이트 단위 (31개): 한 글자의 시그니처만 검증. 각 위치를 독립적으로 제약
교차 바이트 (7개): 여러 글자에 걸쳐 특정 비트 위치의 연속 패턴을 검증. 위치 간 의존성이 생기므로 한 글자씩 분석해서는 풀 수 없음

38개 블록에서 총 152개의 eq 비교가 수행된다. 모든 상수는 R8 레지스터 값으로 XOR 난독화되어 있으며, 디코딩 패턴 매칭으로 추출했다.

5. Solution

디코딩한 바이트코드의 구조를 파악했으니, 이를 기반으로 솔버를 작성하면 된다.

LLM이 소화할 만큼 문제를 잘게 분해했으니 더 이상 "ANTHROPIC MAGIC STRING"을 두려워하지 않아도 된다 ㅇㅅㅇ

Solve Code

solve.py

#!/usr/bin/env python3
"""
LACTF 'reflection' exploit solver
==================================
Extracts constraints from DWARF Expression VM bytecode in .eh_frame,
then recovers the flag via Simulated Annealing + Coordinate Descent.

Usage:
  python3 solves.py <dwarf_vm.bin> <vm_fast.so>
"""
import struct, sys, ctypes, random, time, math

FLAG_PREFIX = "lactf{si"
FLAG_LEN = 47

# ═══════════════════════════════════════════════════
#  1. Bytecode loader + DWARF disassembler
# ═══════════════════════════════════════════════════

def load_bytecode(path):
    with open(path, "rb") as f:
        return f.read()

def read_uleb128(data, pos):
    result = shift = 0
    while pos < len(data):
        b = data[pos]; pos += 1
        result |= (b & 0x7f) << shift; shift += 7
        if not (b & 0x80): break
    return result, pos

def read_sleb128(data, pos):
    result = shift = 0; b = 0
    while pos < len(data):
        b = data[pos]; pos += 1
        result |= (b & 0x7f) << shift; shift += 7
        if not (b & 0x80): break
    if shift < 64 and (b & 0x40): result |= -(1 << shift)
    if result >= (1 << 63): result -= (1 << 64)
    return result, pos

def parse_instructions(data):
    """Decode raw DWARF expression bytecode into (offset, mnemonic, operand) list."""
    pos = 0; ops = []
    while pos < len(data):
        off = pos; op = data[pos]; pos += 1
        if   0x30 <= op <= 0x4f: ops.append((off, 'lit', op - 0x30))
        elif 0x50 <= op <= 0x6f: ops.append((off, 'reg', op - 0x50))
        elif 0x70 <= op <= 0x8f:
            _, pos = read_sleb128(data, pos); ops.append((off, 'breg', op - 0x70))
        elif op == 0x06: ops.append((off, 'deref', None))
        elif op == 0x08: v = data[pos]; pos += 1; ops.append((off, 'const1u', v))
        elif op == 0x09: v = struct.unpack_from('b', data, pos)[0]; pos += 1; ops.append((off, 'const1s', v))
        elif op == 0x0a: v = int.from_bytes(data[pos:pos+2], 'little'); pos += 2; ops.append((off, 'const2u', v))
        elif op == 0x0e: v = int.from_bytes(data[pos:pos+8], 'little'); pos += 8; ops.append((off, 'const8u', v))
        elif op == 0x10: v, pos = read_uleb128(data, pos); ops.append((off, 'constu', v))
        elif op == 0x12: ops.append((off, 'dup', None))
        elif op == 0x13: ops.append((off, 'drop', None))
        elif op == 0x14: ops.append((off, 'over', None))
        elif op == 0x15: v = data[pos]; pos += 1; ops.append((off, 'pick', v))
        elif op == 0x16: ops.append((off, 'swap', None))
        elif op == 0x17: ops.append((off, 'rot', None))
        elif op == 0x1a: ops.append((off, 'and', None))
        elif op == 0x1b: ops.append((off, 'div', None))
        elif op == 0x1c: ops.append((off, 'minus', None))
        elif op == 0x1d: ops.append((off, 'mod', None))
        elif op == 0x1e: ops.append((off, 'mul', None))
        elif op == 0x1f: ops.append((off, 'neg', None))
        elif op == 0x20: ops.append((off, 'not', None))
        elif op == 0x21: ops.append((off, 'or', None))
        elif op == 0x22: ops.append((off, 'plus', None))
        elif op == 0x23: v, pos = read_uleb128(data, pos); ops.append((off, 'plus_uconst', v))
        elif op == 0x24: ops.append((off, 'shl', None))
        elif op == 0x25: ops.append((off, 'shr', None))
        elif op == 0x26: ops.append((off, 'shra', None))
        elif op == 0x27: ops.append((off, 'xor', None))
        elif op == 0x28:
            soff = int.from_bytes(data[pos:pos+2], 'little', signed=True); pos += 2
            ops.append((off, 'bra', pos + soff))
        elif op == 0x29: ops.append((off, 'eq', None))
        elif op == 0x2a: ops.append((off, 'ge', None))
        elif op == 0x2b: ops.append((off, 'gt', None))
        elif op == 0x2c: ops.append((off, 'le', None))
        elif op == 0x2d: ops.append((off, 'lt', None))
        elif op == 0x2e: ops.append((off, 'ne', None))
        elif op == 0x2f:
            soff = int.from_bytes(data[pos:pos+2], 'little', signed=True); pos += 2
            ops.append((off, 'skip', pos + soff))
        elif op == 0x90: v, pos = read_uleb128(data, pos); ops.append((off, 'regx', v))
        elif op == 0xf1:
            enc = data[pos]; pos += 1; fmt = enc & 0x0f
            if   fmt == 0x01: v, pos = read_uleb128(data, pos)
            elif fmt == 0x02: v = int.from_bytes(data[pos:pos+2], 'little'); pos += 2
            elif fmt == 0x03: v = int.from_bytes(data[pos:pos+4], 'little'); pos += 4
            elif fmt == 0x04: v = int.from_bytes(data[pos:pos+8], 'little'); pos += 8
            else: v = 0
            ops.append((off, 'encoded_addr', (enc, enc & 0x70, v)))
        elif op == 0x00: ops.append((off, 'nop', None))
        else: ops.append((off, f'unk_{op:02x}', None))
    return ops

# ═══════════════════════════════════════════════════
#  2. Constraint extraction
# ═══════════════════════════════════════════════════
R8 = 0x8578b  # constant key stored in r8

def xr(X, shift):
    """XOR decode: X ^ ((r8 >> shift) & 0xFF)"""
    return X ^ ((R8 >> shift) & 0xFF)

def bit_groups_of(byte_val):
    """Return list of consecutive 1-bit group lengths (MSB to LSB)."""
    if byte_val == 0: return []
    groups = []; p = 7
    while p >= 0 and not (byte_val & (1 << p)): p -= 1
    while p >= 0:
        cnt = 0
        while p >= 0 and (byte_val & (1 << p)): cnt += 1; p -= 1
        if cnt > 0: groups.append(cnt)
        while p >= 0 and not (byte_val & (1 << p)): p -= 1
    return groups

def find_constraint_eq_offsets(ops):
    """Find bytecode offsets of all 'eq' ops that follow the XOR-decode pattern."""
    eq_offsets = set()
    for i in range(len(ops)):
        off, name, operand = ops[i]
        if name not in ('const1u', 'lit') or i + 7 >= len(ops): continue
        n1 = ops[i+1]
        if not ((n1[1] == 'regx' and n1[2] == 8) or (n1[1] == 'reg' and n1[2] == 8)): continue
        n2 = ops[i+2]
        if n2[1] not in ('lit', 'const1u'): continue
        if ops[i+3][1] != 'shr': continue
        if ops[i+4][1] != 'const1u' or ops[i+4][2] != 255: continue
        if ops[i+5][1] != 'and': continue
        if ops[i+6][1] != 'xor': continue
        if ops[i+7][1] == 'eq':
            eq_offsets.add(ops[i+7][0])
    return eq_offsets

def find_block_ranges(ops):
    """Detect constraint block boundaries via rot/drop/drop/and sequences."""
    markers = []
    for i in range(len(ops) - 3):
        if (ops[i][1] == 'rot' and ops[i+1][1] == 'drop' and
            ops[i+2][1] == 'drop' and ops[i+3][1] == 'and'):
            markers.append(ops[i][0])
    markers.sort()
    ranges = []
    prev = 9
    for m in markers:
        ranges.append((prev, m))
        prev = m + 4
    return ranges

def extract_per_byte_constraints(ops, block_ranges):
    """From single-deref blocks, extract {flag_pos: expected_bit_groups}."""
    per_byte = {}
    for bstart, bend in block_ranges:
        block_ops = [(o, n, p) for o, n, p in ops if bstart <= o < bend]
        if sum(1 for _, n, _ in block_ops if n == 'deref') > 1:
            continue  # skip cross-byte blocks

        brs, gcs = [], []
        for i in range(len(ops)):
            off, name, operand = ops[i]
            if not (bstart <= off < bend): continue
            if name not in ('const1u', 'lit') or i + 7 >= len(ops): continue
            X = operand
            n1 = ops[i+1]
            if not ((n1[1] == 'regx' and n1[2] == 8) or (n1[1] == 'reg' and n1[2] == 8)): continue
            n2 = ops[i+2]
            if n2[1] in ('lit', 'const1u'): shift = n2[2]
            else: continue
            if ops[i+3][1] != 'shr': continue
            if ops[i+4][1] != 'const1u' or ops[i+4][2] != 255: continue
            if ops[i+5][1] != 'and': continue
            if ops[i+6][1] != 'xor': continue
            val = xr(X, shift)
            if   ops[i+7][1] == 'plus': brs.append(val)
            elif ops[i+7][1] == 'eq':   gcs.append(val)

        if brs:
            per_byte[brs[0]] = gcs
    return per_byte

def compute_per_byte_candidates(per_byte):
    """Build candidate char set for each flag position from per-byte constraints."""
    candidates = {}
    for pos in range(FLAG_LEN):
        if pos < len(FLAG_PREFIX):
            candidates[pos] = [ord(FLAG_PREFIX[pos])]
        elif pos == FLAG_LEN - 1:
            candidates[pos] = [ord('}')]
        elif pos in per_byte:
            expected = per_byte[pos]
            cands = [v for v in range(32, 127) if bit_groups_of(v) == expected]
            candidates[pos] = cands if cands else list(range(32, 127))
        else:
            candidates[pos] = list(range(32, 127))
    return candidates

# ═══════════════════════════════════════════════════
#  3. C VM interface (ctypes wrapper)
# ═══════════════════════════════════════════════════
class CVM:
    def __init__(self, so_path, bytecode, constraint_offsets, r8=R8):
        self.lib = ctypes.CDLL(so_path)
        self.bc = (ctypes.c_uint8 * len(bytecode))(*bytecode)
        self.bc_len = len(bytecode)
        self.r8 = ctypes.c_uint64(r8)
        self.n_con = len(constraint_offsets)
        c_offsets = (ctypes.c_int * self.n_con)(*sorted(constraint_offsets))
        self.lib.setup_constraints(c_offsets, self.n_con)

    def run_quick(self, flag_bytes):
        """Execute VM with given flag -> (result, total_passes)"""
        c_flag = (ctypes.c_uint8 * len(flag_bytes))(*flag_bytes)
        c_out = ctypes.c_int(0)
        passes = self.lib.vm_run_quick(
            self.bc, self.bc_len,
            c_flag, len(flag_bytes),
            self.r8, ctypes.byref(c_out)
        )
        return c_out.value, passes

# ═══════════════════════════════════════════════════
#  4. Coordinate Descent solver
# ═══════════════════════════════════════════════════
def solve_coordinate_descent(vm, candidates, n_constraints, max_rounds=20):
    """Greedy per-position optimization: pick the value that maximizes pass count."""
    flag = [candidates[p][0] for p in range(FLAG_LEN)]
    _, best_score = vm.run_quick(flag)

    for rnd in range(max_rounds):
        improved = False
        positions = list(range(len(FLAG_PREFIX), FLAG_LEN - 1))
        random.shuffle(positions)

        for pos in positions:
            orig = flag[pos]; best_val = orig
            for v in candidates[pos]:
                if v == orig: continue
                flag[pos] = v
                _, score = vm.run_quick(flag)
                if score > best_score:
                    best_score = score; best_val = v; improved = True
            flag[pos] = best_val

        result, _ = vm.run_quick(flag)
        flag_str = ''.join(chr(b) for b in flag)
        print(f"  [CD round {rnd+1}] score={best_score}/{n_constraints} flag={flag_str}")
        if result != 0:
            return flag, True
        if not improved:
            break

    return flag, False

# ═══════════════════════════════════════════════════
#  5. Simulated Annealing solver
# ═══════════════════════════════════════════════════
def solve_simulated_annealing(vm, candidates, n_constraints,
                               max_iter=2000000, T_start=8.0, T_end=0.001):
    """SA: probabilistically accepts worse moves at high T to escape local optima."""
    mutable = [p for p in range(len(FLAG_PREFIX), FLAG_LEN - 1) if len(candidates[p]) > 1]

    # random init
    flag = [random.choice(candidates[p]) if len(candidates[p]) > 1 else candidates[p][0]
            for p in range(FLAG_LEN)]
    _, cur_score = vm.run_quick(flag)
    best_score = cur_score; best_flag = list(flag)
    log_interval = max_iter // 20

    for i in range(max_iter):
        T = T_start * (T_end / T_start) ** (i / max_iter)

        pos = random.choice(mutable)
        old_val = flag[pos]
        new_val = random.choice(candidates[pos])
        if new_val == old_val: continue

        flag[pos] = new_val
        result, new_score = vm.run_quick(flag)

        if result != 0:
            print(f"  [SA iter {i}] FOUND! score={new_score}/{n_constraints}")
            return flag, True

        delta = new_score - cur_score
        if delta > 0 or random.random() < math.exp(delta / max(T, 1e-10)):
            cur_score = new_score
            if new_score > best_score:
                best_score = new_score; best_flag = list(flag)
        else:
            flag[pos] = old_val

        if i % log_interval == 0 and i > 0:
            flag_str = ''.join(chr(b) for b in best_flag)
            print(f"  [SA {i//1000}K/{max_iter//1000}K] T={T:.3f} best={best_score}/{n_constraints} "
                  f"flag={flag_str}")

    return best_flag, False

def solve_sa_with_restarts(vm, candidates, n_constraints,
                            n_restarts=10, iter_per_restart=2000000):
    """Run SA multiple times with random restarts."""
    best_overall = 0; best_flag = None

    for r in range(n_restarts):
        print(f"\n  --- SA restart {r+1}/{n_restarts} ---")
        flag, found = solve_simulated_annealing(
            vm, candidates, n_constraints,
            max_iter=iter_per_restart, T_start=6.0, T_end=0.001
        )
        if found: return flag, True

        _, score = vm.run_quick(flag)
        if score > best_overall:
            best_overall = score; best_flag = list(flag)
        flag_str = ''.join(chr(b) for b in flag)
        print(f"  [SA restart {r+1}] score={score}/{n_constraints} "
              f"(best={best_overall}) flag={flag_str}")

        # if very close, brute-force one position at a time
        if score >= n_constraints - 2:
            print(f"  [*] Near-solution ({score}/{n_constraints}), trying single-pos bruteforce...")
            for pos in range(len(FLAG_PREFIX), FLAG_LEN - 1):
                for v in range(32, 127):
                    trial = list(flag); trial[pos] = v
                    result, _ = vm.run_quick(trial)
                    if result != 0:
                        print(f"  FOUND via pos {pos} = '{chr(v)}'")
                        return trial, True

    return best_flag, False

# ═══════════════════════════════════════════════════
#  6. Main
# ═══════════════════════════════════════════════════
def main():
    if len(sys.argv) != 3:
        print(f"Usage: python3 {sys.argv[0]} <dwarf_vm.bin> <vm_fast.so>")
        sys.exit(1)

    bin_path = sys.argv[1]
    so_path  = sys.argv[2]

    # --- Parse bytecode ---
    data = load_bytecode(bin_path)
    ops  = parse_instructions(data)
    print(f"[*] Loaded {len(data)} bytes -> {len(ops)} instructions")

    # --- Extract constraints ---
    block_ranges  = find_block_ranges(ops)
    eq_offsets    = find_constraint_eq_offsets(ops)
    n_constraints = len(eq_offsets)
    per_byte      = extract_per_byte_constraints(ops, block_ranges)
    candidates    = compute_per_byte_candidates(per_byte)
    print(f"[*] Blocks: {len(block_ranges)}, Constraints: {n_constraints}, Per-byte: {len(per_byte)}")

    # --- Per-position candidate summary ---
    print(f"\n[*] Per-position candidates:")
    fixed = 0
    for pos in range(len(FLAG_PREFIX), FLAG_LEN - 1):
        cands = candidates[pos]
        if len(cands) == 1:
            print(f"    pos {pos:>2}: FIXED -> '{chr(cands[0])}'")
            fixed += 1
        elif len(cands) <= 10:
            cand_str = ' '.join(f"'{chr(c)}'" for c in cands)
            print(f"    pos {pos:>2}: [{len(cands):>2}] {cand_str}")
        else:
            print(f"    pos {pos:>2}: [{len(cands):>2}] (unconstrained)")
    n_search = (FLAG_LEN - 1) - len(FLAG_PREFIX)
    print(f"    Fixed: {fixed}, Need search: {n_search - fixed}")

    # --- Init C VM ---
    vm = CVM(so_path, data, eq_offsets)

    # --- Phase 1: Simulated Annealing ---
    print(f"\n[*] Phase 1: Simulated Annealing")
    random.seed(42)
    flag, found = solve_sa_with_restarts(vm, candidates, n_constraints,
                                          n_restarts=10, iter_per_restart=2000000)
    if found:
        print(f"\n{'='*60}\n  FLAG: {''.join(chr(b) for b in flag)}\n{'='*60}")
        return

    # --- Phase 2: Coordinate Descent polish ---
    print(f"\n[*] Phase 2: Coordinate Descent")
    flag, found = solve_coordinate_descent(vm, candidates, n_constraints)
    if found:
        print(f"\n{'='*60}\n  FLAG: {''.join(chr(b) for b in flag)}\n{'='*60}")
        return

    _, best_score = vm.run_quick(flag)
    print(f"\n[-] Not solved. Best: {best_score}/{n_constraints}")
    print(f"    {''.join(chr(b) for b in flag)}")

if __name__ == "__main__":
    t0 = time.time()
    main()
    print(f"\n[*] Elapsed: {time.time()-t0:.1f}s")

vm_emulator.c

/*
 * DWARF Expression VM  –  C accelerator for the solver
 *
 * Exports:
 *   setup_constraints(offsets, n)  – register 'eq' bytecode offsets
 *   vm_run_quick(data, bc_len, flag, flag_len, r8, out_result)
 *       -> returns total constraint passes; *out_result = final TOS
 *
 * Build:
 *   gcc -O3 -shared -fPIC -o vm_fast2.so vm_fast2.c
 */

#include <stdint.h>
#include <string.h>

/* ── Tunables ─────────────────────────────────────── */
#define MAX_STACK       4096
#define MAX_STEPS       2000000
#define MAX_CONSTRAINTS 256
#define MEM_SIZE        128

/* ── Helpers ──────────────────────────────────────── */

static inline int64_t to_signed(uint64_t v) { return (int64_t)v; }

static int read_uleb128(const uint8_t *d, int len, int p, uint64_t *out) {
    uint64_t r = 0; int s = 0;
    while (p < len) {
        uint8_t b = d[p++];
        r |= (uint64_t)(b & 0x7f) << s; s += 7;
        if (!(b & 0x80)) break;
    }
    *out = r; return p;
}

static int read_sleb128(const uint8_t *d, int len, int p, int64_t *out) {
    int64_t r = 0; int s = 0; uint8_t b = 0;
    while (p < len) {
        b = d[p++];
        r |= (int64_t)(b & 0x7f) << s; s += 7;
        if (!(b & 0x80)) break;
    }
    if (s < 64 && (b & 0x40)) r |= -(1LL << s);
    *out = r; return p;
}

/* ── Constraint offset -> index map ───────────────── */

static int con_map[16384];   /* offset -> constraint index (-1 = none) */
static int n_con = 0;

void setup_constraints(const int *offsets, int n) {
    n_con = n;
    memset(con_map, 0xFF, sizeof(con_map));
    for (int i = 0; i < n && i < MAX_CONSTRAINTS; i++)
        if (offsets[i] >= 0 && offsets[i] < 16384)
            con_map[offsets[i]] = i;
}

/* ── Flat memory (flag bytes mapped at flag_ptr) ──── */

static uint8_t mem[MEM_SIZE];

static uint64_t mem_read_u64(uint64_t addr, uint64_t base) {
    uint64_t v = 0;
    for (int i = 0; i < 8; i++) {
        int idx = (int)(addr + i - base);
        uint8_t b = (idx >= 0 && idx < MEM_SIZE) ? mem[idx] : 0;
        v |= (uint64_t)b << (i * 8);
    }
    return v;
}

/* ── VM execution ─────────────────────────────────── */

int vm_run_quick(const uint8_t *data, int bc_len,
                 const uint8_t *flag, int flag_len,
                 uint64_t r8, int *out_result)
{
    const uint64_t flag_ptr = 0x400000ULL;

    /* Load flag into flat memory */
    memset(mem, 0, MEM_SIZE);
    for (int i = 0; i < flag_len && i < MEM_SIZE; i++)
        mem[i] = flag[i];

    uint64_t stk[MAX_STACK];
    int sp = 0;
    stk[sp++] = flag_ptr;            /* initial TOS = pointer to flag */
    int pos = 9;                      /* skip 9-byte prologue */
    int steps = 0, passes = 0;

    while (pos < bc_len) {
        if (++steps > MAX_STEPS) { *out_result = -1; return passes; }

        int pc = pos;
        uint8_t op = data[pos++];

        /* ── Compact opcode ranges ── */
        if (op >= 0x30 && op <= 0x4f) { stk[sp++] = (uint64_t)(op - 0x30);  continue; }  /* lit0..lit31  */
        if (op >= 0x50 && op <= 0x6f) { stk[sp++] = ((op-0x50)==8) ? r8 : 0; continue; }  /* reg0..reg31  */
        if (op >= 0x70 && op <= 0x8f) {                                                     /* breg0..breg31 */
            int64_t dummy; pos = read_sleb128(data, bc_len, pos, &dummy);
            stk[sp++] = 0; continue;
        }

        switch (op) {

        /* ── Memory / constants ── */
        case 0x06: { uint64_t a = stk[--sp]; stk[sp++] = mem_read_u64(a, flag_ptr); break; }        /* deref    */
        case 0x08: { stk[sp++] = data[pos++]; break; }                                               /* const1u  */
        case 0x09: { int8_t v = (int8_t)data[pos++]; stk[sp++] = (uint64_t)(int64_t)v; break; }     /* const1s  */
        case 0x0a: { uint16_t v = data[pos]|((uint16_t)data[pos+1]<<8); pos+=2; stk[sp++]=v; break; }/* const2u */
        case 0x0e: { uint64_t v=0; for(int i=0;i<8;i++) v|=(uint64_t)data[pos+i]<<(i*8); pos+=8; stk[sp++]=v; break; } /* const8u */
        case 0x10: { uint64_t v; pos=read_uleb128(data,bc_len,pos,&v); stk[sp++]=v; break; }        /* constu   */

        /* ── Stack manipulation ── */
        case 0x12: stk[sp]=stk[sp-1]; sp++; break;                                                   /* dup   */
        case 0x13: sp--; break;                                                                       /* drop  */
        case 0x14: stk[sp]=stk[sp-2]; sp++; break;                                                   /* over  */
        case 0x15: { uint8_t i=data[pos++]; stk[sp]=stk[sp-1-i]; sp++; break; }                     /* pick  */
        case 0x16: { uint64_t t=stk[sp-1]; stk[sp-1]=stk[sp-2]; stk[sp-2]=t; break; }              /* swap  */
        case 0x17: { uint64_t a=stk[sp-1],b=stk[sp-2],c=stk[sp-3];                                 /* rot   */
                     stk[sp-1]=b; stk[sp-2]=c; stk[sp-3]=a; break; }

        /* ── Arithmetic ── */
        case 0x1a: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=a&b; break; }                     /* and   */
        case 0x1b: { uint64_t b=stk[--sp],a=stk[--sp]; int64_t sb=to_signed(b);                    /* div   */
                     stk[sp++]=sb?(uint64_t)(to_signed(a)/sb):0; break; }
        case 0x1c: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=a-b; break; }                     /* minus */
        case 0x1d: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=b?a%b:0; break; }                 /* mod   */
        case 0x1e: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=a*b; break; }                     /* mul   */
        case 0x1f: { uint64_t a=stk[--sp]; stk[sp++]=(uint64_t)(-to_signed(a)); break; }           /* neg   */
        case 0x20: { uint64_t a=stk[--sp]; stk[sp++]=~a; break; }                                   /* not   */
        case 0x21: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=a|b; break; }                     /* or    */
        case 0x22: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=a+b; break; }                     /* plus  */
        case 0x23: { uint64_t v; pos=read_uleb128(data,bc_len,pos,&v);                              /* plus_uconst */
                     stk[sp-1]+=v; break; }
        case 0x24: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=a<<(b&63); break; }               /* shl   */
        case 0x25: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=a>>(b&63); break; }               /* shr   */
        case 0x26: { uint64_t b=stk[--sp],a=stk[--sp];                                              /* shra  */
                     stk[sp++]=(uint64_t)(to_signed(a)>>(b&63)); break; }
        case 0x27: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=a^b; break; }                     /* xor   */

        /* ── Branching ── */
        case 0x28: { int16_t off=(int16_t)(data[pos]|((uint16_t)data[pos+1]<<8)); pos+=2;           /* bra   */
                     if(stk[--sp]) pos+=off; break; }
        case 0x2f: { int16_t off=(int16_t)(data[pos]|((uint16_t)data[pos+1]<<8)); pos+=2;           /* skip  */
                     pos+=off; break; }

        /* ── Comparisons ── */
        case 0x29: { uint64_t b=stk[--sp],a=stk[--sp];                                              /* eq — constraint check */
                     int ok=(a==b); stk[sp++]=ok;
                     if(pc<16384 && con_map[pc]>=0 && ok) passes++;
                     break; }
        case 0x2a: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=(to_signed(a)>=to_signed(b)); break; } /* ge */
        case 0x2b: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=(to_signed(a)> to_signed(b)); break; } /* gt */
        case 0x2c: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=(to_signed(a)<=to_signed(b)); break; } /* le */
        case 0x2d: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=(to_signed(a)< to_signed(b)); break; } /* lt */
        case 0x2e: { uint64_t b=stk[--sp],a=stk[--sp]; stk[sp++]=(a!=b); break; }                       /* ne */

        /* ── Register extended ── */
        case 0x90: { uint64_t v; pos=read_uleb128(data,bc_len,pos,&v);                              /* regx  */
                     if      (v==8)  stk[sp++]=r8;
                     else if (v==12) stk[sp++]=0x3E06666E84F11F86ULL;   /* r12 constant */
                     else if (v==13) stk[sp++]=0x5155422E88E856B5ULL;   /* r13 constant */
                     else stk[sp++]=0; break; }

        /* ── GNU encoded address ── */
        case 0xf1: { uint8_t enc=data[pos++]; uint8_t fmt=enc&0x0f; uint8_t mod=enc&0x70;
                     uint64_t v=0;
                     if      (fmt==0x01) { pos=read_uleb128(data,bc_len,pos,&v); }
                     else if (fmt==0x02) { v=data[pos]|((uint64_t)data[pos+1]<<8); pos+=2; }
                     else if (fmt==0x03) { for(int i=0;i<4;i++) v|=(uint64_t)data[pos+i]<<(i*8); pos+=4; }
                     else if (fmt==0x04) { for(int i=0;i<8;i++) v|=(uint64_t)data[pos+i]<<(i*8); pos+=8; }
                     stk[sp++] = (mod==0x40) ? 0x3cc20ULL+v : v;       /* funcrel -> base+v */
                     break; }

        case 0x00: break;                                                                             /* nop  */
        default:   *out_result = -2; return passes;
        }

        if (sp < 0 || sp >= MAX_STACK) { *out_result = -3; return passes; }
    }

    *out_result = (sp > 0) ? (int)stk[sp-1] : -4;
    return passes;
}

최종적으로 정리하면, 풀이에 쓰인 코드는 크게 네가지 아래와 같다.

File	Description
`dwarf_decoder.py`	DWARF 표현식 디스어셈블러 (GNU 확장 지원 DW_OP_* 디코더)
`solve.py`	메인 솔버: 바이트코드 파싱 + 제약 조건 추출 + C VM 인터페이스 + SA
`vm_emulator.c`	C VM 가속기 (libgcc `execute_stack_op` 재구현)
`reflection_dump.py`	자동 표현식 추출을 위한 GDB Python 스크립트

Flag

./solve.py dwarf_vm.bin vm.so    
[*] Loaded 12888 bytes -> 9195 instructions
[*] Blocks: 38, Constraints: 152, Per-byte: 31

[*] Per-position candidates:
    pos  8: FIXED -> 'k'
    pos  9: [ 4] '5' 'e' 'i' 'j'
    pos 10: FIXED -> '_'
    pos 11: [95] (unconstrained)
    pos 12: [95] (unconstrained)
    pos 13: [ 4] '5' 'e' 'i' 'j'
    pos 14: [ 3] ';' 's' 'v'
    pos 15: [95] (unconstrained)
    pos 16: [95] (unconstrained)
    pos 17: [ 3] ';' 's' 'v'
    pos 18: FIXED -> '_'
    pos 19: [ 7] '1' '2' '4' 'a' 'b' 'd' 'h'
    pos 20: [ 5] '3' '6' 'c' 'f' 'l'
    pos 21: [ 5] '9' ':' 'q' 'r' 't'
    pos 22: FIXED -> 'u'
    pos 23: [ 7] '1' '2' '4' 'a' 'b' 'd' 'h'
    pos 24: [ 5] '3' '6' 'c' 'f' 'l'
    pos 25: [ 5] '3' '6' 'c' 'f' 'l'
    pos 26: [ 3] '=' 'y' 'z'
    pos 27: FIXED -> '_'
    pos 28: [ 7] '1' '2' '4' 'a' 'b' 'd' 'h'
    pos 29: FIXED -> '_'
    pos 30: [ 2] '8' 'p'
    pos 31: FIXED -> 'u'
    pos 32: FIXED -> 'm'
    pos 33: [ 7] '1' '2' '4' 'a' 'b' 'd' 'h'
    pos 34: [ 4] '5' 'e' 'i' 'j'
    pos 35: [ 5] '9' ':' 'q' 'r' 't'
    pos 36: [95] (unconstrained)
    pos 37: [95] (unconstrained)
    pos 38: [ 4] '5' 'e' 'i' 'j'
    pos 39: [ 5] '3' '6' 'c' 'f' 'l'
    pos 40: [ 4] '5' 'e' 'i' 'j'
    pos 41: [ 5] '9' ':' 'q' 'r' 't'
    pos 42: [ 4] '5' 'e' 'i' 'j'
    pos 43: [95] (unconstrained)
    pos 44: [ 5] '3' '6' 'c' 'f' 'l'
    pos 45: [ 4] '5' 'e' 'i' 'j'
    Fixed: 8, Need search: 30

[*] Phase 1: Simulated Annealing

  --- SA restart 1/10 ---
  [SA 300K/2000K] T=1.627 best=130/152 flag=lactf{siki_<lj;Qms_hltublfz_a_8um2e:G*e6ere43e}
  [SA 500K/2000K] T=0.682 best=143/152 flag=lactf{sike_this_es_actu1lly_a_pumb5rWBef5:5.c5}
  [SA 600K/2000K] T=0.441 best=146/152 flag=lactf{sike_tiesSa;_af9udlly_a_pumber_re6e:5n3e}
  [SA 900K/2000K] T=0.120 best=147/152 flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}
  [SA 1100K/2000K] T=0.050 best=147/152 flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}
  [SA 1200K/2000K] T=0.032 best=147/152 flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}
  [SA 1300K/2000K] T=0.021 best=147/152 flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}
  [SA 1400K/2000K] T=0.014 best=147/152 flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}
  [SA 1600K/2000K] T=0.006 best=147/152 flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}
  [SA 1700K/2000K] T=0.004 best=147/152 flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}
  [SA 1800K/2000K] T=0.002 best=147/152 flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}
  [SA 1900K/2000K] T=0.002 best=147/152 flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}
  [SA restart 1] score=147/152 (best=147) flag=lactf{sike_tae;[a;_af9udlly_a_pumber_re6e:enc5}

  --- SA restart 2/10 ---
  [SA 100K/2000K] T=3.884 best=125/152 flag=lactf{siki_Qhe;;B;_b39u16fy_h_8umb5q[ej6et56le}
  [SA 200K/2000K] T=2.514 best=125/152 flag=lactf{siki_Qhe;;B;_b39u16fy_h_8umb5q[ej6et56le}
  [SA 300K/2000K] T=1.627 best=130/152 flag=lactf{sike_de5s_hs_h39u1fly_h_pumb5:[>j6itja6j}
  [SA 400K/2000K] T=1.053 best=136/152 flag=lactf{sik5_tai;[%s_aftual6y_a_puma5:Wb56e:e.ce}
  [SA iter 535145] FOUND! score=152/152

============================================================
  FLAG: lactf{sike_this_is_actually_a_pumber_reference}
============================================================

최종 검증을 위해 바이너리에 플래그를 넣으면…

catch_unwind 핸들러가 panic을 받고, expression이 0이 아닌 값을 반환하여 프로그램이 정상 종료된다!

6. 실행 흐름

./reflection "lactf{...}"
│
├─ main() → catch_unwind 설정
│    └─ __rust_begin_short_backtrace()
│         └─ reflection::main()
│              └─ panic!("Come close to me and I'll make you regret it.")
│                   └─ panic_fmt() → panic_with_hook() → rust_panic()
│                        └─ _Unwind_RaiseException() — 여기서 검증 시작
│
├─ [Phase 1] 검색: 프레임 순회, main()의 catch_unwind 핸들러 발견
│    └─ 표현식이 실행되지만 컨텍스트는 이후 리셋됨
│
├─ [Phase 2] 정리: 프레임을 다시 순회, DWARF 표현식 실행
│    ├─ ❶ panic_with_hook FDE → RCX = 0x53AA9 (ARGV 전역 변수 근처)
│    ├─ ❷ panic_handler FDE → R8 = 코드 영역 주소 (해시 값)
│    ├─ ❸ __rust_begin_short_backtrace FDE → 115B 표현식:
│    │      argc==2? strlen==47? hash(first8)? last=='}'?
│    │      ├─ 통과 → RIP = 0x3CC21 (가상 프레임 진입)
│    │      └─ 실패 → RIP = 정상 복귀 (검증 건너뜀)
│    ├─ ❹ 가상 프레임 FDE → R12 = 0x3E06666E84F11F86 (상수 키)
│    ├─ ❺ 가상 프레임 FDE → R13 = 0x5155422E88E856B5 (상수 키)
│    └─ ❻ 가상 프레임 FDE → 12,888B 표현식:
│           38개 블록이 비트 그룹 시그니처로 나머지 문자 검증
│           ├─ 모두 통과 → VM이 0이 아닌 값 반환 → RIP = 성공 경로
│           └─ 하나라도 실패 → VM이 0 반환 → RIP = 실패 경로
│
└─ catch_unwind가 결과를 받음 → 프로그램 종료

Unwinder는 CFI를 신뢰해 레지스터를 복원하는데, 바로 이 점이 이러한 조작을 가능하게 한다. 와!

7. Conclusion

요즘 많은 문제들이 LLM으로 쉽게 풀리다 보니 허무할 때도 있는데, Anti-LLM 문자열(?)이 들어있는 리버싱 문제는 처음이라 신박했다. (~~내가 먼저 써먹으려고 했는데!~~)

아무튼 재미있었다.

0 CTF 2025 Writeup (1Zwasm)

Mon, 05 Jan 2026 00:00:00 GMT

Challenges: https://github.com/sajjadium/ctf-archives/tree/main/ctfs/0CTF/2025/rev/1Zwasm

1. Challenge Overview

우선 문제 바이너리를 열어보니 UPX로 패킹돼있었고, 툴로 언패킹이 불가능했다.

GDB로 붙어봤는데 이번엔 디버깅이 안 됐다. set follow-fork-mode child 명령어를 써서 트레이싱 해봤더니, memfd_create() 시스콜이 호출됨을 알 수 있었다.

(gdb) set follow-fork-mode child
(gdb) r
Starting program: /home/noonchi/ctf/1Zwαsm

Catchpoint 1 (call to syscall memfd_create), 0x00007ffff7ffe3c7 in ?? ()
(gdb) c
Continuing.

...

[Attaching after process 108066 fork to child process 108619]
[New inferior 2 (process 108619)]
process 108619 is executing new program: /proc/108619/exe
Enter the flag:hey

:(
[Inferior 2 (process 108619) exited normally]

2. 바이너리 언패킹 및 덤프

UPX 패커가 실행할 때 memfd_create() 시스콜로 파일 두 개를 생성하고 있어서 런타임에 덤프를 떴다.

pgrep -f 1Zw | xargs -I{} sh -c 'echo "=== PID {} ===" && ls -la /proc/{}/fd/ 2>/dev/null'
=== PID 65619 ===
합계 0
dr-x------ 2 noonchi noonchi 5 12월 20 15:39 .
dr-xr-xr-x 9 noonchi noonchi 0 12월 20 15:30 ..
lrwx------ 1 noonchi noonchi 64 12월 20 15:39 0 -> /dev/pts/16
lrwx------ 1 noonchi noonchi 64 12월 20 15:39 1 -> /dev/pts/16
lrwx------ 1 noonchi noonchi 64 12월 20 15:39 2 -> /dev/pts/16
lrwx------ 1 noonchi noonchi 64 12월 20 15:39 3 -> '/memfd:chall (deleted)'
lrwx------ 1 noonchi noonchi 64 12월 20 15:39 4 -> '/memfd:chall_wasm (deleted)'

두 개의 파일이 메모리에 올라와 있다:

파일 1. chall: toywasm 런타임 (WASM 인터프리터)
- cat /proc/65619/fd/3 > chall.bin
파일 2. chall_wasm: Rust로 작성된 WASM 모듈
- cat /proc/65619/fd/4 > chall_wasm.bin

chall은 디컴파일러로 열면 UPX로 패킹돼있다고 뜨고, chall_wasm은 WASM 바이너리로 인식은 되지만 코드가 깨져 보인다.

3. WASM 바이너리 분석

chall_wasm 바이너리를 wasm-objdump로 보면, END를 비롯한 여러 opcode가 손상된 것을 알 수 있다:

wasm-objdump -h chall_wasm.bin

chall_wasm.bin:       file format wasm 0x1
0000253: error: init expression must end with END opcode
000028b: error: unfinished section (expected end: 0x2e1)
000e8f2: error: ref.null type must be a reference type
module name: <chall-7a8478e4c9508fe0.wasm>

Sections:

     Type start=0x0000000b end=0x0000008c (size=0x00000081) count: 18
   Import start=0x0000008f end=0x00000146 (size=0x000000b7) count: 5
 Function start=0x00000149 end=0x00000237 (size=0x000000ee) count: 236
    Table start=0x00000239 end=0x0000023e (size=0x00000005) count: 1
   Memory start=0x00000240 end=0x00000243 (size=0x00000003) count: 1
   Global start=0x00000245 end=0x00000253 (size=0x0000000e) count: 2
   Export start=0x00000255 end=0x00000276 (size=0x00000021) count: 3
     Elem start=0x00000278 end=0x000002e1 (size=0x00000069) count: 1
     Code start=0x000002e5 end=0x0000e253 (size=0x0000df6e) count: 236
     Data start=0x0000e256 end=0x00011490 (size=0x0000323a) count: 2
   Custom start=0x00011493 end=0x00011537 (size=0x000000a4) "target_features"
   Custom start=0x0001153a end=0x000153f7 (size=0x00003ebd) "name"
   Custom start=0x000153fa end=0x000154ba (size=0x000000c0) "producers"

마찬가지로 wasm-objdump로 확인한 함수 심볼 등으로 추측컨대, 전체 흐름이 대충 **"입력 문자[i] → apply_sbox_layer(???) → SHA1 → 타겟 해시[i]와 비교"**이고, 구체적인 로직을 알아내서 역연산을 해야 한다는 걸 알 수 있다.

함수	이름	설명
func[6]	`_start`	EntryPoint
func[11]	`chall::main`	메인 함수
func[12]	`chall::crypto::apply_sbox_layer`	S-box 치환
func[23]	`sha1::compress::compress`	SHA1 압축
..	등등...	...

추가로 데이터 세그먼트에서 정적 데이터를 추출했다:

플래그 포맷: 0ops{...}
타겟 해시 테이블: 해시 40개
S-box 테이블: 16바이트
- 0e 04 0d 01 02 0f 0b 08 03 0a 06 0c 05 09 00 07

4. toywasm 런타임 식별

덤프 뜬 chall을 실행해보니 toywasm이 원형임을 알 수 있었다.

./chall
Usage:
        toywasm [OPTIONS] [--] <MODULE> [WASI-ARGS...]
Options:
        --allow-unresolved-functions
        --disable-jump-table
        --disable-localtype-cellidx
        --disable-resulttype-cellidx
        --invoke FUNCTION[ FUNCTION_ARGS...]
        --load MODULE_PATH
        --max-frames NUMBER_OF_FRAMES
        --max-memory MEMORY_LIMIT_IN_BYTES
        --max-stack-cells NUMBER_OF_CELLS
        --repl
        --repl-prompt STRING
        --print-build-options
        --print-stats
        --timeout TIMEOUT_MS
        --version
        --wasi
        --wasi-dir HOST_DIR[::GUEST_DIR]
        --wasi-env NAME=VAR
Examples:
        Run a wasi module
                toywasm --wasi module
        Load a module and invoke its function
                toywasm --load module --invoke "func arg1 arg2"

원본 toywasm의 오픈소스 코드를 뜯어보니, opcode를 테이블로 해석하고 각 instruction handler로 넘기는 파싱 로직이 보였다.

toywasm expr.c — opcode 디스패치 테이블

이쯤에서 이 문제는 커스텀 opcode를 정의한 VM-like 문제가 아닐까 하는 생각을 했다.

5. 커스텀 Opcode 가설

근거 1. 모든 236개 함수가 `0x55`로 끝남

Code 섹션을 WASM 포맷대로 파싱해서 각 함수 body의 마지막 1바이트 값을 확인해본 결과 모두 0x55로 끝남
표준 WASM에서는 0x0b (END)로 끝나야 하기 때문에, 0x55 → 0x0b 이렇게 치환된 게 아닐까 추측

근거 2. 바이트 빈도 분포가 비정상적임

0x38: 7193회 (원래 f32.store인데 이렇게 많을 수 없음)
0x45: 4441회 (원래 i32.eqz)
0x55: 1459회 (원래 i64.gt_u)
0x0b: 227회 (원래 end인데 너무 적음!)

여기서 명백한 사실은, 커스텀 인터프리터는 커스텀 WASM 바이너리의 바이트코드를 올바르게 해석하고 실행하고 있다는 것이다.

즉, 멋대로 뒤섞인 opcode를 표준 opcode 테이블로 디스어셈블하면 니모닉이 틀리는 게 당연하고, 디스패처 역할을 하는 함수를 찾고 매핑 테이블을 알아내서 패치만 해주면 일반 디컴파일러로도 해석이 가능해질 것이다.

이 가설을 세우고 언패킹된 toywasm을 덤프 떠서 실제 사용되는 opcode 핸들러를 추적하고자 했다.

6. 코어 덤프를 통한 Opcode 매핑 추출

./chall --wasi ./chall_wasm 으로 실행한 뒤 프로세스 메모리 맵을 확인:

cat /proc/16222/maps
555576ff5000-555577016000 rw-p 00000000 00:00 0                          [heap]
7cf924fec000-7cf9250fc000 rw-p 00000000 00:00 0
7cf925200000-7cf925228000 r--p 00000000 fc:00 2118957                    /usr/lib/x86_64-linux-gnu/libc.so.6
7cf925228000-7cf9253b0000 r-xp 00028000 fc:00 2118957                    /usr/lib/x86_64-linux-gnu/libc.so.6
...
7cf925572000-7cf9255b3000 r-xs 00000000 00:01 6031                       /memfd:upx (deleted)
...

앞서 말했듯 chall은 UPX로 패킹돼있기 때문에 런타임에 덤프를 떠야 한다. gcore -o core <PID>로 전체 덤프를 뜨면 대강 이런 구조:

┌─────────────────────────────────────────────────────────────┐
│  core.??? (2.2MB) - 프로세스 메모리 스냅샷
│
│  내용:
│  ├── libc.so.6          (~1.5MB) - 시스템 라이브러리
│  ├── ld-linux.so        (~200KB) - 동적 링커
│  ├── libm.so            (~500KB) - 수학 라이브러리
│  ├── memfd:upx          (266KB) <- 언패킹된 toywasm
│  ├── 힙, 스택
│  └── WASM 메모리
└─────────────────────────────────────────────────────────────┘

바이너리를 분석해 opcode 디스패처 함수를 찾는다.

코어 덤프 뜰 때마다 베이스 주소는 달라질 수 있기 때문에 i64.eqz 같은 문자열 검색해서 xref를 찾아서 타고 올라가다 보면 찾을 수 있다. (사실 expr.c 핸들러를 찾는 게 목표니 기존 expr.c 소스코드에 있던 "Unimplemented instructions" 같은 문자열 기준으로 찾으면 더 쉽다)

추출한 opcode 매핑은 아래와 같다:

# 전체 Opcode 매핑 테이블
# base=0x7cf099725fe0 stride=32
0x00 i64.eqz          0x01 i64.sub          0x02 i64.load16_s
0x03 i64.gt_u         0x04 nop              0x05 i64.const
0x06 select           0x07 else             0x08 i64.load16_u
0x09 i64.ge_u         0x0a i64.load8_u      0x0b f64.lt
0x0c i32.gt_s         0x0d i32.lt_s         0x0e i32.load8_u
0x0f i32.rem_u        0x10 i64.store        0x11 br
0x12 f32.ne           0x13 i64.load8_s      0x14 i32.or
0x15 f32.lt           0x16 i32.add          0x17 i32.clz
0x18 i32.shr_u        0x1a f32.eq           0x1b i64.load32_u
0x1c global.get       0x1d i32.eqz          0x20 select_t
0x21 i32.div_s        0x22 i32.shr_s        0x23 i32.store8
0x24 i32.gt_u         0x25 i32.store        0x26 i64.clz
0x28 local.set        0x29 i64.le_s         0x2a f32.const
0x2b i64.le_u         0x2d f64.ge           0x2e if
0x2f i32.rotl         0x30 i32.eq           0x31 i64.load
0x33 i64.store8       0x34 f32.ge           0x35 i64.eq
0x36 global.set       0x37 i32.xor          0x38 local.get
0x39 drop             0x3a i64.gt_s         0x3d table_set
0x3e call             0x3f memory.size       0x40 f32.gt
0x41 i64.ne           0x42 local.tee        0x43 f64.ne
0x44 f64.store        0x45 i32.const        0x46 i32.ctz
0x47 i32.mul          0x48 i32.shl          0x49 return
0x4a f32.le           0x4c i32.load8_s      0x4d br_if
0x4e i32.popcnt       0x4f i32.load16_u     0x50 i32.sub
0x51 i32.lt_u         0x53 table_get        0x54 br_table
0x55 end              0x56 i64.lt_s         0x57 call_indirect
0x58 i64.lt_u         0x59 i32.load         0x5a i32.load16_s
0x5b block            0x5c unreachable       0x5d i64.mul
0x5e f64.le           0x5f i32.le_u         0x62 f64.const
0x63 f32.store        0x64 f32.load         0x65 f64.eq
0x66 i64.ctz          0x67 i32.ne           0x68 i64.add
0x69 i64.popcnt       0x6a i64.div_s        0x6b i32.ge_u
0x6d i32.rotr         0x6f i32.rem_s        0x70 memory.grow
0x71 i64.store16      0x72 i32.ge_s         0x73 i32.div_u
0x74 i64.store32      0x75 f64.load         0x76 i64.ge_s
0x77 i32.and          0x78 i64.load32_s     0x7a loop
0x7c i32.store16      0x7e f64.gt           0x7f i32.le_s
0x80 ref.null         0x81 fd               0x82 f32.convert_i32_s
0x84 i64.rem_s        0x85 i64.extend8_s    0x86 f64.ceil
0x87 i64.xor          0x88 f32.convert_i32_u 0x8a i64.trunc_f64_u
0x8e i64.extend_i32_u 0x90 f64.convert_i32_s 0x91 f32.neg
0x93 i64.trunc_f64_s  0x99 i64.shr_s        0x9b f32.convert_i64_u
0x9c f64.div          0x9e f32.copysign      0x9f f32.sub
0xa0 f64.floor        0xa3 f64.convert_i64_u 0xa5 f32.demote_f64
0xa7 i64.rotr         0xa8 f64.sub           0xaa i64.extend16_s
0xac f64.trunc        0xae i64.or            0xb1 i32.trunc_f32_u
0xb2 i64.shr_u        0xb3 i32.reinterpret_f32 0xb5 ref.is_null
0xb6 f64.min          0xb8 f64.add           0xb9 f64.neg
0xbb f32.div          0xbc i64.rotl          0xbd f64.copysign
0xbe f32.nearest      0xbf f64.reinterpret_i64 0xc1 ref.func
0xc2 f64.mul          0xc4 f64.convert_i64_s 0xc5 i32.extend16_s
0xc9 f32.trunc        0xcb f32.max           0xcc i64.extend_i32_s
0xcd f32.ceil         0xcf i64.trunc_f32_u   0xd2 f32.add
0xd3 f64.max          0xd4 f32.floor         0xd5 f32.abs
0xd7 f32.sqrt         0xd9 i32.trunc_f32_s   0xda i64.trunc_f32_s
0xdb i64.rem_u        0xdc i64.div_u         0xe0 f64.nearest
0xe1 f32.min          0xe2 i64.extend32_s    0xe3 f64.convert_i32_u
0xe4 i32.trunc_f64_s  0xe8 fc                0xec i64.shl
0xee f64.abs          0xf0 i32.extend8_s     0xf1 i64.reinterpret_f64
0xf4 f32.reinterpret_i32 0xf5 i32.trunc_f64_u 0xf8 f32.convert_i64_s
0xf9 f64.sqrt         0xfa i64.and           0xfb i32.wrap_i64
0xfc f64.promote_f32  0xfd f32.mul

실제 WASM 표준 테이블과 비교해보면, 표준 WASM에선 end가 항상 0x0B인데 여기선 end가 0x55로 매핑돼 있고, 반대로 표준 테이블에서 i64.sub는 0x7D인데 추출 테이블에선 0x01이 i64.sub로 되어있는 식이다.

정리

chall을 실행하면 커스텀된 toywasm이 메모리 상에 풀린 상태로 동작함
그 상태에서 프로세스 코어덤프를 뜨면, toywasm의 opcode → mnemonic 문자열 포인터 테이블도 같이 메모리에 남음
core 바이너리 리버싱해서 opcode 핸들러 함수와 매핑 테이블을 찾을 수 있음
(덤) 테이블 베이스를 잡고 IDA Python으로 0..255를 순회해서 0x?? mnemonic을 출력하는 식으로 자동화도 가능

7. Opcode 패치 및 디컴파일

알아낸 매핑대로 WASM 바이너리를 패치했다. 아래는 WASM을 포맷대로 파싱해서 opcode 위치만 치환하는 코드이다:

# Opcode 패치 스크립트
import argparse
import os
import re


def uleb(d: bytes, o: int) -> tuple[int, int]:
    r = 0
    s = 0
    i = 0
    while True:
        b = d[o + i]
        r |= (b & 0x7F) << s
        i += 1
        if b < 0x80:
            return r, i
        s += 7
        if i > 16:
            raise ValueError("uleb too long")


def read_uleb_bytes(d: bytes, o: int) -> tuple[bytes, int]:
    i = 0
    while True:
        b = d[o + i]
        i += 1
        if b < 0x80:
            return d[o : o + i], i
        if i > 16:
            raise ValueError("uleb bytes too long")


def read_sleb_bytes(d: bytes, o: int) -> tuple[bytes, int]:
    i = 0
    while True:
        b = d[o + i]
        i += 1
        if b < 0x80:
            return d[o : o + i], i
        if i > 16:
            raise ValueError("sleb bytes too long")


def encode_uleb(n: int) -> bytes:
    out = bytearray()
    while True:
        b = n & 0x7F
        n >>= 7
        if n:
            out.append(b | 0x80)
        else:
            out.append(b)
            return bytes(out)


def parse_sections(wasm: bytes) -> list[tuple[int, int, int]]:
    if wasm[:4] != b"\0asm":
        raise ValueError("not wasm")
    o = 8
    secs: list[tuple[int, int, int]] = []
    while o < len(wasm):
        sid = wasm[o]
        o += 1
        sz, n = uleb(wasm, o)
        o += n
        secs.append((sid, o, o + sz))
        o += sz
    return secs


def sec_range(secs: list[tuple[int, int, int]], sid: int) -> tuple[int, int] | None:
    for s, a, b in secs:
        if s == sid:
            return a, b
    return None


def load_opdump(path: str) -> dict[int, str]:
    enc2name: dict[int, str] = {}
    with open(path, "r", encoding="utf-8", errors="ignore") as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            k, name = line.split(None, 1)
            enc2name[int(k, 16)] = name.strip()
    return enc2name


_RE_INSN = re.compile(r'INSTRUCTION\(\s*(0x[0-9a-fA-F]+)\s*,\s*"([^"]+)"')


def load_std_maps(repo_root: str) -> tuple[dict[str, int], dict[str, int]]:
    def parse_hdr(p: str) -> dict[str, int]:
        m: dict[str, int] = {}
        with open(p, "r", encoding="utf-8", errors="ignore") as f:
            for ln in f:
                mo = _RE_INSN.search(ln)
                if mo:
                    m[mo.group(2)] = int(mo.group(1), 0)
        return m

    base_p = os.path.join(repo_root, "toywasm", "lib", "insn_list_base.h")
    fc_p = os.path.join(repo_root, "toywasm", "lib", "insn_list_fc.h")
    if not (os.path.exists(base_p) and os.path.exists(fc_p)):
        raise SystemExit("need toywasm headers: toywasm/lib/insn_list_base.h + insn_list_fc.h")

    std = parse_hdr(base_p)
    std_fc = parse_hdr(fc_p)
    if "table.grew" in std_fc:
        std_fc["table.grow"] = std_fc.pop("table.grew")
    return std, std_fc


# encoded 0xfc subopcode -> mnemonic
FC_ENC2NAME: dict[int, str] = {
    7: "i64.trunc_sat_f32_u",
    39: "memory.copy",
    85: "memory.fill",
}


def rewrite_init_expr(buf: bytes, enc2name: dict[int, str], std: dict[str, int]) -> tuple[bytes, int]:
    out = bytearray()
    i = 0
    while i < len(buf):
        op = buf[i]
        i += 1
        name = enc2name.get(op)
        if not name:
            raise ValueError(f"unknown encoded opcode 0x{op:02x} in init-expr")
        if name in ("fc", "fd"):
            raise ValueError("prefix in init-expr not supported")

        out.append(std[name])
        if name in ("i32.const", "i64.const"):
            raw, n = read_sleb_bytes(buf, i)
            i += n
            out += raw
        elif name == "f32.const":
            out += buf[i : i + 4]
            i += 4
        elif name == "f64.const":
            out += buf[i : i + 8]
            i += 8
        elif name == "global.get":
            raw, n = read_uleb_bytes(buf, i)
            i += n
            out += raw
        elif name == "ref.null":
            out.append(buf[i])
            i += 1
        elif name == "ref.func":
            raw, n = read_uleb_bytes(buf, i)
            i += n
            out += raw

        if name == "end":
            return bytes(out), i
    raise ValueError("init-expr didn't end with end")


def rewrite_code(code: bytes, enc2name: dict[int, str], std: dict[str, int], std_fc: dict[str, int]) -> bytes:
    out = bytearray()
    i = 0
    while i < len(code):
        op = code[i]
        i += 1
        name = enc2name.get(op)
        if not name:
            raise ValueError(f"unknown encoded opcode 0x{op:02x} at +0x{i-1:x}")

        if name == "fd":
            raise ValueError("0xfd(SIMD) not supported")

        if name == "fc":
            enc_sub, _ = uleb(code, i)
            _raw, n = read_uleb_bytes(code, i)
            i += n
            sub_name = FC_ENC2NAME.get(enc_sub)
            if not sub_name:
                raise ValueError(f"unknown encoded 0xfc subopcode {enc_sub}")
            std_sub = std_fc.get(sub_name)
            if std_sub is None:
                raise ValueError(f"unknown std 0xfc mnemonic {sub_name!r}")

            out.append(0xFC)
            out += encode_uleb(std_sub)

            # fc immediates
            if 0x00 <= std_sub <= 0x07:
                pass
            elif sub_name == "memory.init":
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
            elif sub_name == "data.drop":
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
            elif sub_name == "memory.copy":
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
            elif sub_name == "memory.fill":
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
            elif sub_name == "table.init":
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
            elif sub_name == "elem.drop":
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
            elif sub_name == "table.copy":
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
            elif sub_name in ("table.grow", "table.size", "table.fill"):
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
            else:
                raise ValueError(f"unsupported 0xfc mnemonic {sub_name!r}")
            continue

        out.append(std[name])

        # immediates: length-only
        if name in ("block", "loop", "if"):
            b = code[i]
            if b in {0x40, 0x7F, 0x7E, 0x7D, 0x7C, 0x7B, 0x70, 0x6F}:
                out.append(b); i += 1
            else:
                raw, n = read_sleb_bytes(code, i); i += n; out += raw
        elif name in ("br", "br_if", "call", "local.get", "local.set", "local.tee",
                       "global.get", "global.set", "table_get", "table_set"):
            raw, n = read_uleb_bytes(code, i); i += n; out += raw
        elif name == "call_indirect":
            raw, n = read_uleb_bytes(code, i); i += n; out += raw
            out.append(code[i]); i += 1
        elif name == "br_table":
            raw_cnt, n = read_uleb_bytes(code, i)
            cnt, _ = uleb(code, i)
            i += n
            out += raw_cnt
            for _ in range(cnt + 1):
                raw, n = read_uleb_bytes(code, i); i += n; out += raw
        elif name == "select_t":
            raw_cnt, n = read_uleb_bytes(code, i)
            cnt, _ = uleb(code, i)
            i += n
            out += raw_cnt
            out += code[i : i + cnt]
            i += cnt
        elif ".load" in name or ".store" in name:
            raw, n = read_uleb_bytes(code, i); i += n; out += raw
            raw, n = read_uleb_bytes(code, i); i += n; out += raw
        elif name in ("memory.size", "memory.grow"):
            out.append(code[i]); i += 1
        elif name in ("i32.const", "i64.const"):
            raw, n = read_sleb_bytes(code, i); i += n; out += raw
        elif name == "f32.const":
            out += code[i : i + 4]; i += 4
        elif name == "f64.const":
            out += code[i : i + 8]; i += 8
        elif name == "ref.null":
            out.append(code[i]); i += 1
        elif name == "ref.func":
            raw, n = read_uleb_bytes(code, i); i += n; out += raw

    return bytes(out)


def rewrite_module(wasm: bytes, enc2name: dict[int, str],
                   std: dict[str, int], std_fc: dict[str, int]) -> bytes:
    secs = parse_sections(wasm)
    out = bytearray(wasm)

    # globals (6)
    gr = sec_range(secs, 6)
    if gr:
        gs, ge = gr
        p = gs
        gcount, n = uleb(out, p); p += n
        for _ in range(gcount):
            p += 2
            rw, used = rewrite_init_expr(bytes(out[p:ge]), enc2name, std)
            out[p : p + used] = rw
            p += used

    # elem (9) - active segments(flags 0/2)만
    er = sec_range(secs, 9)
    if er:
        es, ee = er
        p = es
        segcnt, n = uleb(out, p); p += n
        for _ in range(segcnt):
            flags, n = uleb(out, p); p += n
            if flags not in (0, 2):
                raise ValueError(f"unsupported elem flags {flags}")
            if flags == 2:
                _, n = uleb(out, p); p += n
            rw, used = rewrite_init_expr(bytes(out[p:ee]), enc2name, std)
            out[p : p + used] = rw
            p += used
            cnt, n = uleb(out, p); p += n
            for _j in range(cnt):
                _, n = uleb(out, p); p += n

    # data (11)
    dr = sec_range(secs, 11)
    if dr:
        ds, de = dr
        p = ds
        segcnt, n = uleb(out, p); p += n
        for _ in range(segcnt):
            flags, n = uleb(out, p); p += n
            if flags & 0x02:
                _, n = uleb(out, p); p += n
            if (flags & 0x01) == 0:
                rw, used = rewrite_init_expr(bytes(out[p:de]), enc2name, std)
                out[p : p + used] = rw
                p += used
            sz, n = uleb(out, p); p += n
            p += sz

    # code (10)
    cr = sec_range(secs, 10)
    if not cr:
        raise ValueError("no code section")
    cs, _ce = cr
    p = cs
    fcnt, n = uleb(out, p); p += n
    for fi in range(fcnt):
        body_size, nsz = uleb(out, p); p += nsz
        bs = p
        be = p + body_size
        body = bytes(out[bs:be])
        q = 0
        lgc, nn = uleb(body, q); q += nn
        for _ in range(lgc):
            _, nn = uleb(body, q); q += nn
            q += 1
        rw = rewrite_code(body[q:], enc2name, std, std_fc)
        if len(rw) != len(body) - q:
            raise ValueError(f"code size changed at func {fi}; need section rebuild")
        out[bs + q : be] = rw
        p = be

    return bytes(out)


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--wasm", required=True)
    ap.add_argument("--opdump", required=True)
    ap.add_argument("--out", required=True)
    args = ap.parse_args()

    repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    std, std_fc = load_std_maps(repo_root)
    enc2name = load_opdump(args.opdump)
    wasm = open(args.wasm, "rb").read()
    out = rewrite_module(wasm, enc2name, std, std_fc)
    open(args.out, "wb").write(out)
    print("[ok]", args.out, "size", len(out))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Ghidra Wasm plugin을 설치하고 패치된 바이너리를 열어보면:

코드가 보인다!

제일 궁금했던 apply_sbox_layer 함수 로직은 64비트 값을 4비트 조각으로 쪼개 S-box 테이블(DAT_ram_00100abc)로 바꾼 뒤 다시 64비트로 합치는 로직이었다.

8. 솔브 코드

import hashlib

HASHES = [
    "4462fc5ac9dda45e1f956bfa9159c148906ea2eb",
    "50afeeeba0e2674462f21f8286bb8fa20f91e882",
    "271d1c2edfb9d5c6506be73c695958b035a2fbb4",
    "82ef770e9de4f8ad66071b95e69cc80998cc6154",
    "5a6778089ec6ecf9abc84348af33e761e30f0368",
    "c839f2e7c4701924709bc0b9fa339cb7d361102e",
    "e93f555173093854f0588ae859de9caf686213d4",
    "3e0bd1fb0cc18b23941f3a015a0826071f9526a6",
    "1df3f80cd3b0c34360f9e7c56378fba862d05e0b",
    "6c144bf262c8e54719cd1e056ca6ede306161182",
    "983b5bc62c686e987e252de3548cd17ce2f0c998",
    "64e63929dc2c52e93a26ea72c6c5d00db839d2c4",
    "afb7023a362d94e0bfdb33e2a8dced45ae87aa0b",
    "c5b02ef1d8f7a31950ab219e6258355fd81a218e",
    "58511d70859435ea1e4a4a64ebab7aff01e8ccad",
    "2f58d45d2c6cdf5421d41af2b08778abf0e3d525",
    "deeb5ed18ce5d39b0f0be9a7f9ccd9bdf8221753",
    "8bae2558d08c0bc17e80192fbc398436e6934d55",
    "b6a03cd5819d84f9babf9e80291b08c6901cfa5d",
    "2d91a20a20fcaeb0ae60b5189b810bdf8481b1d7",
    "5a930b172e356b7e4d9e3e0560863ca7794a87d8",
    "72f676227f09ea59b4c176786b43d5638709e594",
    "4acf5137e8896d3de00cb2fe97cbbbd5c00ae443",
    "b6f116748b1a85fd0514666b220f3acd73c05863",
    "a5522b2b6e176d64dc1d064264d43704e31b7325",
    "1ea1c9dea1b08dc9cb3834d66e4ac48c28e3cf30",
    "f5b378b0e1eed620d0522de40427a59ecb1d1b06",
    "b6d3b5ebc1b4ed96d33702e18796846d4a07996c",
    "c4e45262d2f681f87ca7624dab7589df0daec44e",
    "fd1a1247655fccb5ccf1689f99789a30e69440fa",
    "4a7008477bfd6c0bb38b44cbfe1f578230f09c34",
    "2eebddd42c73f4df038bcedf24d2a9fda3e24b96",
    "416a237b97883bf34bcbf14f9b84bc8111d369dd",
    "814daf9e0d4106a254fe39a4019338377db99300",
    "c70544086b038f41391a84815e6a3cb5c8e7405a",
    "f36ef8a4827781edca736f121fab55d61ad2a902",
    "e737b3e6a9d2f5d36c930e0f825813ae1f86e2ee",
    "2789186ff38370bb23b45775f9bcf8b3bfb72ddc",
    "001c5fcd727e9e8a1af79b5ef966771b5b5008ef",
    "d685f409ea233df5eba3658a4547ddd78485d2fa",
]

SBOX = [0x0e, 0x04, 0x0d, 0x01, 0x02, 0x0f, 0x0b, 0x08, 0x03, 0x0a, 0x06, 0x0c, 0x05, 0x09, 0x00, 0x07]
INV_SBOX = [0] * 16
for i, v in enumerate(SBOX):
    INV_SBOX[v] = i

MASK32 = 0xFFFFFFFF
MASK64 = (1 << 64) - 1

C1 = (-0x4508329480000000) & MASK64
C2 = (-0x77fccd388a106529) & MASK64
C0 = 0x225d686a
M32 = 0x1e35a7bd
ROUND_CONSTS = [
    0x6bdfe07b,
    0xaf92329f,
    0x32553697,
    0x45b21761,
    0xa45b1a4b,
    0xff580251,
    0xd3f278fc,
    0x0945406a,
    0x9826331a,
    0x3d0b5dce,
    0x52b238a8,
    0x3c67752c,
    0xeb51d479,
    0xf3c6b787,
    0x7f7d729b,
]

SHIFT = (C1 & -C1).bit_length() - 1
K1 = C1 >> SHIFT
MOD_K1 = 1 << (64 - SHIFT)
INV_K1 = pow(K1, -1, MOD_K1)
MOD31 = 1 << 31
INV_C2_31 = pow(C2 % MOD31, -1, MOD31)

def g(u8):
    return (SBOX[u8 >> 4] << 17) | (SBOX[u8 & 0xF] << 13)

def f32(u):
    return ((u * M32) ^ g(u & 0xFF)) & MASK32

def inv_sbox_layer(x):
    out = 0
    for i in range(16):
        out |= INV_SBOX[(x >> (4 * i)) & 0xF] << (4 * i)
    return out

def bswap64(x):
    return int.from_bytes(x.to_bytes(8, "little"), "big")

def inv_mix(p1, u):
    t0 = ((p1 >> SHIFT) * INV_K1) % MOD_K1
    a = (t0 * C2) & MASK64
    k = (u - (a >> 33)) & (MOD31 - 1)
    k = (k * INV_C2_31) % MOD31
    return (t0 + (k << (64 - SHIFT))) & MASK64

def recover_words():
    table = {hashlib.sha1(v.to_bytes(2, "little")).hexdigest(): v for v in range(65536)}
    return [table[h] for h in HASHES]

def recover_block(out64):
    b = out64.to_bytes(8, "little")
    u = b[7] | (b[6] << 8) | (b[5] << 16) | ((b[4] & 0x7F) << 24)
    p1 = ((b[4] & 0x80) << 24) | (b[3] << 32) | (b[2] << 40) | (b[1] << 48) | (b[0] << 56)

    t = inv_mix(p1, u)
    v = inv_sbox_layer(t)
    A = v & MASK32
    B = (v >> 32) & MASK32

    A ^= f32(B ^ ROUND_CONSTS[-1])
    for i in range(len(ROUND_CONSTS) - 2, -1, -1):
        if i % 2 == 0:
            A ^= f32(B ^ ROUND_CONSTS[i])
        else:
            B ^= f32(A ^ ROUND_CONSTS[i])

    H = B ^ f32(A ^ C0)
    p1 = (A & 0x80000000) | (H << 32)
    u = A & 0x7FFFFFFF
    y = inv_mix(p1, u)

    x = bswap64(inv_sbox_layer(y))
    return x.to_bytes(8, "little")

def main():
    w = recover_words()
    data = b"".join(
        recover_block(w[i] | (w[i + 1] << 16) | (w[i + 2] << 32) | (w[i + 3] << 48)) for i in range(0, len(w), 4)
    )
    print(data.rstrip(b"\x00").decode())

if __name__ == "__main__":
    main()

Flag

0ops{𝞃ĥ|ß_ǐ$_Ʀ³αIıу_Ą_Ślmp1ȩ_Ŵǟ5ɱ_cHªIIεnɠ𝛆（）}

9. 결론

한번 코드가 노출되면 아무리 어려운 로직이어도 LLM이 쓱싹 풀어줄 수도 있는데, 여기에 포렌식 요소를 더해서 스크램블된 opcode를 패치해 바이너리를 복원하게끔 하는 출제 의도가 좋았다.

물론 CTF 서버에서 어떤 분이 LLM이 잘 풀어주더라며 코멘트 하기도 했지만, 적어도 원샷에 풀 수 있는 문제는 아니었다고 생각한다.

더 디깅하고 싶은데 시간이 없는 관계로 이 정도만 적을게요 그럼 20000

How to solve?

Codegate CTF 2026 Writeup (PhantomCore)

TL;DR

1. 전체 아키텍처

1-1. 배경: GPU와 CPU의 관계

1-2. QEMU에서의 구현

1-3. phantom-gpu vs. 실제 GPU

2. 문제 파일 분석

3. gpuctl-cli 리버싱 (Userland)

4. gpuctl.ko 리버싱 (Kernel Module)

4-1. init_modul에서 probe까지

4-2. probe(sub_650) — PCI 초기화 및 DMA 할당

4-3. ioctl handler (sub_370) - 커맨드 전달

4-5. IRQ handler (sub_5E0) - 완료 통보

4-6. 전체 흐름

5. QEMU phantom-gpu 리버싱

5-1. Firmware Blob 추출 및 디코드

5-2. Firmware → Device State 복사

5-3. Phase 1 Transform — Grammar A / Grammar B

5-4. Dispatch Table 초기화

5-5. Shader Validator (sub_428450)

5-6. VM Executor Loop & Fault Codes

6. Gate 검증

6-1. Gate 조건 분석

6-2. Gate 검증 우회

6-3. Shader 레이아웃

7. Flag 복원

7-1. Gate 검사 범위

7-2. Success Path가 실제로 읽는 것

7-4. Success Path 분석

7-6. Hidden Witness

8. Solve

LA CTF 2026 Writeup (Reflection)

1. Challenge Overview

2. Background — Stack Unwinding, .eh_frame

2.1 Rust Panic: Unwind vs. Abort

2.2 Unwinding 동작 원리: 2-Phase 메커니즘

2.3 .eh_frame section: CIE, FDE

2.4 두 가지 바이트코드 시스템: DW_CFA vs. DW_OP

3. 숨겨진 코드 찾기

3.1 Expressions 스캔

3.2 GDB 디버깅 — Expressions 추출

3.3 Expression 체인

3.4 115바이트 입력값 검증

4. 12KB DWARF VM 리버싱

4.1 바이트코드 추출 및 디코딩

4.2 제약 조건 요약

5. Solution

Solve Code

Flag

6. 실행 흐름

7. Conclusion

0 CTF 2025 Writeup (1Zwasm)

1. Challenge Overview

2. 바이너리 언패킹 및 덤프

3. WASM 바이너리 분석

4. toywasm 런타임 식별

5. 커스텀 Opcode 가설

근거 1. 모든 236개 함수가 0x55로 끝남

근거 2. 바이트 빈도 분포가 비정상적임

6. 코어 덤프를 통한 Opcode 매핑 추출

정리

7. Opcode 패치 및 디컴파일

8. 솔브 코드

Flag

9. 결론

5-5. Shader Validator (`sub_428450`)

근거 1. 모든 236개 함수가 `0x55`로 끝남