SkillAgentSearch skills...

heap-exploitation

Heap exploitation playbook

Install / Use

npx skills add yaklang/hack-skills --skill heap-exploitation

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

82/100

Category

Security

Supported Platforms

Universal

Tags

Our assessment of heap-exploitation

heap-exploitation scores 82/100 on our quality scale, 958th of 1,108 Security skills we index.

Its SKILL.md is 8.6 KB long, well organised into 27 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.

With 2,288 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
20/20
Description
4/15
Adoption
14/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so heap-exploitation is actively maintained.
  • Our last check on 2026-11-07 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-02. Automated pattern scan on 2026-10-02. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

heap-exploitation compared with similar skills

All 4 of these similar skills score higher than heap-exploitation; compare them before choosing.

SkillScoreStarsUpdatedFormat
heap-exploitation (this skill)by yaklang822.3k2mo agoSKILL.md
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md
pptxby anthropics100177.9k55d agoSKILL.md
designby nextlevelbuilder100149.0k6d agoSKILL.md

Frequently asked questions

How do I install heap-exploitation?
Run npx skills add yaklang/hack-skills --skill heap-exploitation. The install tabs above show the steps for each supported agent.
Which AI agents does heap-exploitation work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is heap-exploitation safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is heap-exploitation still maintained?
The repository was last updated about 2 months ago, so heap-exploitation is actively maintained.

name: heap-exploitation description: >- Heap exploitation playbook. Use when targeting ptmalloc2/glibc heap vulnerabilities including UAF, double free, overflow, off-by-one/null, and leveraging tcache/fastbin/unsortedbin attacks for arbitrary write or code execution.

SKILL: Heap Exploitation — Expert Attack Playbook

AI LOAD INSTRUCTION: Expert glibc heap exploitation techniques. Covers ptmalloc2 internals, bin structures, tcache mechanics, libc/heap leak methods, and attack selection by glibc version. Distilled from ctf-wiki heap sections, how2heap, and real-world exploitation. Base models often confuse glibc version constraints and miss safe-linking (PROTECT_PTR) introduced in 2.32.

0. RELATED ROUTING

Advanced References


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 | Contains bin heads, top chunk, system_mem | | mp_ | libc .data | malloc parameters (tcache settings, mmap threshold) | | tcache_perthread_struct | Heap (first allocation) | Per-thread tcache bins and counts |


2. LEAK METHODS

Libc Base Leak

| Method | Precondition | Technique | |---|---|---| | Unsortedbin fd/bk | Free a chunk > tcache range (or fill tcache) | fd/bk → main_arena + 0x60 (or +0x70 depending on version) → libc base | | Smallbin fd/bk | Chunk moved from unsortedbin to smallbin | Same as unsortedbin leak | | stdout FILE leak | Write to _IO_2_1_stdout_ | Corrupt _IO_write_base to leak libc data (see IO_FILE) |

Heap Base Leak

| Method | Precondition | Technique | |---|---|---| | Tcache fd pointer | Free two tcache chunks, read first's fd | fd → heap address (XOR'd in ≥ 2.32) | | Fastbin fd | Free two fastbin chunks | fd → heap address | | UAF read | Use-after-free on freed chunk | Read fd/bk directly |

Safe-Linking Decode (glibc ≥ 2.32)

# PROTECT_PTR: fd_stored = (chunk_addr >> 12) ^ real_fd
# To decode: real_fd = fd_stored ^ (chunk_addr >> 12)
# To encode: 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 (No tcache)

| Attack | Primitive Needed | Result | |---|---|---| | Fastbin dup | Double free | Arbitrary allocation | | Unsortedbin attack | Corrupt unsortedbin bk | Write main_arena addr to target (used for __malloc_hook nearby overwrite) | | Unlink attack | Heap overflow into prev_size + fd/bk | Arbitrary write (with known heap pointer) | | House of Force | Top chunk size overwrite | Arbitrary allocation | | House of Spirit | Write fake chunk header | Fastbin allocation at fake chunk | | Off-by-one null | Null byte overflow into next chunk size | Overlapping chunks |

glibc 2.26–2.28 (tcache, no key)

| Attack | Notes | |---|---| | Tcache poisoning | Overwrite tcache fd → arbitrary allocation, no size check | | Tcache dup | Double free into tcache (no double-free detection yet) | | All previous attacks | Still work, but chunks go to tcache first |

glibc 2.29–2.31 (tcache key introduced)

| Attack | Bypass for tcache key | |---|---| | Tcache dup | Corrupt key field (at chunk+0x18) before second free | | House of Botcake | Double free: one in unsortedbin, one in tcache → overlapping | | Tcache stashing unlink | Abuse smallbin→tcache refill to get arbitrary chunk |

glibc 2.32–2.33 (safe-linking / PROTECT_PTR)

| Attack | Adaptation | |---|---| | Tcache poisoning | Encode target with (chunk_addr >> 12) ^ target | | Heap leak required | Need heap addr to decode/encode safe-linked pointers | | Fastbin dup | Same encoding required |

glibc ≥ 2.34 (hooks removed)

| Change | Impact | |---|---| | __malloc_hook removed | Cannot overwrite hook for one_gadget | | __free_hook removed | Cannot overwrite hook | | __realloc_hook removed | Cannot use realloc trick for one_gadget constraints |

Post-2.34 targets: see arbitrary-write-to-rce for _IO_FILE, exit_funcs, TLS_dtor_list, _dl_fini.


4. COMMON VULNERABILITY PATTERNS

| Vulnerability | Description | Exploitation Path | |---|---|---| | UAF (Use-After-Free) | Access chunk after free | Read: leak fd/bk; Write: corrupt fd for tcache poisoning | | Double Free | free() same chunk twice | Tcache dup (bypass key) or fastbin dup | | Heap Overflow | Write past chunk boundary | Corrupt next chunk's metadata (size, fd, bk) | | Off-by-one | One byte overflow | Null byte → shrink next chunk size → overlapping chunks | | Off-by-null | Specifically \x00 overflow | Clear PREV_INUSE → trigger backward consolidation | | Uninitialized read | Read heap memory without clearing | Leak fd/bk from recycled chunk |


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)

Related Skills

View on GitHub
GitHub Stars2.3k
CategorySecurity
Updated2mo ago
Forks303

Languages

CSS

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions