SKILL: Heap Exploitation — Expert Attack Playbook

AI LOAD INSTRUCTION: glibc ヒープ エクスプロイテーション専門技術。ptmalloc2 の内部構造、bin 構造、tcache メカニズム、libc/ヒープ リーク方法、および glibc バージョンごとの攻撃選択をカバーします。ctf-wiki ヒープセクション、how2heap、および実際のエクスプロイテーション から厳選されています。ベース モデルでは glibc バージョン制約を混同しやすく、2.32 で導入された safe-linking (PROTECT_PTR) を見落とします。

0. RELATED ROUTING

• stack-overflow-and-rop — オーバーフロー がヒープではなくスタックにある場合
• format-string-exploitation — フォーマット文字列経由でヒープ/libc アドレスをリークする場合
• arbitrary-write-to-rce — ヒープ任意書き込みをコード実行に変換する場合
• binary-protection-bypass — ASLR/RELRO をバイパスしてヒープ書き込みを有効にする場合

Advanced References

• HOUSE_OF_TECHNIQUES.md — House of Force/Spirit/Orange/Einherjar/Roman/Pig/Banana/Cat/Apple および tcache 攻撃
• IO_FILE_EXPLOITATION.md — _IO_FILE vtable ハイジャック、FSOP、stdout/stdin 悪用、exit フロー エクスプロイテーション

---

1. PTMALLOC2 STRUCTURE QUICK REFERENCE

malloc_chunk Layout (64-bit)

         chunk pointer (returned by malloc - 0x10)
         ┌──────────────────────────┐
    0x00 │  prev_size (if prev free)│
    0x08 │  size        | A | M | P │  ← P=PREV_INUSE, M=IS_MMAPPED, A=NON_MAIN_ARENA
         ├──────────────────────────┤  ← user data starts here (returned pointer)
    0x10 │  fd (if free)            │  ← forward pointer to next free chunk
    0x18 │  bk (if free)            │  ← backward pointer to prev free chunk
    0x20 │  fd_nextsize (large only)│
    0x28 │  bk_nextsize (large only)│
         └──────────────────────────┘

Bin Types

Bin	Size Range (64-bit)	Structure	LIFO/FIFO
tcache (per-thread)	≤ 0x410 (7 entries per size)	Singly linked (next pointer)	LIFO
fastbin	≤ 0x80 (default)	Singly linked (fd)	LIFO
unsortedbin	Any freed size	Doubly linked circular	FIFO
smallbin	< 0x400	Doubly linked circular	FIFO
largebin	≥ 0x400	Doubly linked + size-sorted	Sorted

Key Global Structures

Structure	Location	Purpose
main_arena	libc .data segment	bin ヘッド、top chunk、system_mem を格納
mp_	libc .data	malloc パラメータ (tcache 設定、mmap しきい値)
tcache_perthread_struct	Heap (first allocation)	スレッドごと tcache bin とカウント

---

2. LEAK METHODS

Libc Base Leak

Method	Precondition	Technique
Unsortedbin fd/bk	tcache 範囲より大きいチャンクを解放（または tcache を満杯にする）	fd/bk → main_arena + 0x60 (またはバージョンによって +0x70) → libc base
Smallbin fd/bk	unsortedbin から smallbin に移動されたチャンク	unsortedbin リークと同じ
stdout FILE leak	_IO_2_1_stdout_ に書き込み	_IO_write_base を破損して libc データをリーク (IO_FILE 参照)

Heap Base Leak

Method	Precondition	Technique
Tcache fd pointer	2 つの tcache チャンクを解放し、最初のものの fd を読む	fd → ヒープ アドレス (≥ 2.32 で XOR されている)
Fastbin fd	2 つの fastbin チャンクを解放	fd → ヒープ アドレス
UAF read	解放されたチャンクで use-after-free	fd/bk を直接読む

Safe-Linking Decode (glibc ≥ 2.32)

# PROTECT_PTR: fd_stored = (chunk_addr >> 12) ^ real_fd
# デコード: real_fd = fd_stored ^ (chunk_addr >> 12)
# エンコード: fd_stored = (chunk_addr >> 12) ^ target_addr

def deobfuscate(stored_fd, chunk_addr):
    return stored_fd ^ (chunk_addr >> 12)

def obfuscate(target, chunk_addr):
    return (chunk_addr >> 12) ^ target

---

3. ATTACK CATEGORIES BY GLIBC VERSION

glibc < 2.26 (tcache なし)

Attack	Primitive Needed	Result
Fastbin dup	ダブルフリー	任意割り当て
Unsortedbin attack	unsortedbin bk 破損	ターゲットに main_arena アドレスを書き込み (__malloc_hook 近くのオーバーライト に使用)
Unlink attack	ヒープ オーバーフロー (prev_size + fd/bk へ)	任意書き込み (既知のヒープ ポインタを使用)
House of Force	Top chunk size オーバーライト	任意割り当て
House of Spirit	フェイク チャンク ヘッダ書き込み	フェイク チャンク位置での fastbin 割り当て
Off-by-one null	次チャンクの size への null バイト オーバーフロー	チャンク オーバーラップ

glibc 2.26–2.28 (tcache, key なし)

Attack	Notes
Tcache poisoning	tcache fd をオーバーライト → 任意割り当て、size チェック なし
Tcache dup	tcache へのダブルフリー (ダブルフリー検出なし)
All previous attacks	依然機能するが、チャンクは最初に tcache に入る

glibc 2.29–2.31 (tcache key 導入)

Attack	tcache key バイパス
Tcache dup	2 番目の free の前に key フィールド (chunk+0x18) を破損
House of Botcake	ダブルフリー: unsortedbin に 1 つ、tcache に 1 つ → オーバーラップ
Tcache stashing unlink	smallbin→tcache リフィル を悪用して任意チャンク取得

glibc 2.32–2.33 (safe-linking / PROTECT_PTR)

Attack	Adaptation
Tcache poisoning	ターゲットを (chunk_addr >> 12) ^ target でエンコード
Heap leak 必須	safe-linked ポインタ をデコード/エンコードするにはヒープ アドレスが必要
Fastbin dup	同じエンコーディングが必須

glibc ≥ 2.34 (hooks 削除)

Change	Impact
__malloc_hook 削除	one_gadget に hook をオーバーライト不可
__free_hook 削除	hook をオーバーライト不可
__realloc_hook 削除	one_gadget 制約 で realloc トリック使用不可

Post-2.34 ターゲット: arbitrary-write-to-rce で _IO_FILE、exit_funcs、TLS_dtor_list、_dl_fini を参照してください。

---

4. COMMON VULNERABILITY PATTERNS

Vulnerability	Description	Exploitation Path
UAF (Use-After-Free)	解放後のチャンク アクセス	読み取り: fd/bk をリーク; 書き込み: tcache poisoning 用に fd を破損
Double Free	同じチャンク を 2 回 free()	Tcache dup (key バイパス) または fastbin dup
Heap Overflow	チャンク境界を超えて書き込み	次チャンクのメタデータ (size、fd、bk) を破損
Off-by-one	1 バイト オーバーフロー	Null バイト → 次チャンク size を縮小 → チャンク オーバーラップ
Off-by-null	特に \x00 オーバーフロー	PREV_INUSE をクリア → 後方統合をトリガー
Uninitialized read	ヒープ メモリを明示的にクリアせずに読み取り	リサイクルされたチャンク から fd/bk をリーク

---

5. TOOLS

# pwndbg heap inspection
pwndbg> heap                      # display all chunks
pwndbg> bins                      # show all bin contents
pwndbg> tcachebins                # tcache status
pwndbg> fastbins                  # fastbin status
pwndbg> unsortedbin               # unsortedbin content
pwndbg> vis_heap_chunks           # visual heap layout
pwndbg> find_fake_fast &__malloc_hook  # find nearby fake fastbin chunks

# how2heap — reference implementations
git clone https://github.com/shellphish/how2heap

# heapinspect
pip install heapinspect
heapinspect <pid>

# pwntools helpers
from pwn import *
libc = ELF('./libc.so.6')
print(hex(libc.symbols['__malloc_hook']))
print(hex(libc.symbols['__free_hook']))

---

6. DECISION TREE

Heap vulnerability identified
├── What is the primitive?
│   ├── UAF (read + write)
│   │   ├── Can read freed chunk? → Leak libc (unsortedbin) or heap (tcache fd)
│   │   └── Can write freed chunk? → Tcache poisoning / fastbin dup
│   ├── Double free
│   │   ├── glibc < 2.29 → direct tcache dup
│   │   ├── glibc 2.29-2.31 → corrupt tcache key first, or House of Botcake
│   │   └── glibc ≥ 2.32 → need heap leak for safe-linking encode
│   ├── Heap overflow (controlled size)
│   │   ├── Overwrite next chunk size → overlapping chunks → UAF
│   │   └── Overwrite fd directly → arbitrary allocation
│   ├── Off-by-one / off-by-null
│   │   ├── Null byte into size → House of Einherjar (backward consolidation)
│   │   └── One byte into size → shrink chunk, create overlap
│   └── Arbitrary write (from overlap or poisoned allocation)
│       ├── glibc < 2.34 → __malloc_hook / __free_hook → one_gadget
│       ├── glibc ≥ 2.34 → _IO_FILE vtable, exit_funcs, TLS_dtor_list
│       └── Partial RELRO → GOT overwrite
│
├── Need libc leak?
│   ├── Free chunk into unsortedbin (size > 0x410 or fill 7 tcache)
│   ├── Read fd/bk → main_arena offset → libc base
│   └── Alternative: stdout FILE partial overwrite for leak
│
└── Need heap leak? (glibc ≥ 2.32)
    ├── Read tcache fd from freed chunk
    └── Decode: real_addr = stored_fd ^ (chunk_addr >> 12)