Getting it into your agent
This one installs as part of its plugin. Adding the marketplace and installing the plugin brings it with everything else the plugin ships.
/plugin marketplace add allsmog/pwn-claude-plugin/plugin install pwn-htbWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/skills/allsmog/pwn-claude-plugin/heap-exploitation)<a href="https://agentmods.dev/skills/allsmog/pwn-claude-plugin/heap-exploitation"><img src="https://agentmods.dev/badge/skills/allsmog/pwn-claude-plugin/heap-exploitation/github.svg" alt="Measured on agentmods" height="20"></a>Or the 80×15 button, for a site that already has a row of RSS and ATOM ones. Only the verdict fits; the numbers stay here.
<a href="https://agentmods.dev/skills/allsmog/pwn-claude-plugin/heap-exploitation"><img src="https://agentmods.dev/badge/skills/allsmog/pwn-claude-plugin/heap-exploitation.svg" alt="Reviewed on agentmods" width="80" height="20"></a>What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00087 | $0.02143 |
| Opus 5.5 | $0.00035 | $0.00857 |
| Sonnet 5.5 | $0.00017 | $0.00429 |
| Haiku 4.5 | $0.00009 | $0.00214 |
Grade A, and why
Heap Exploitation scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 2mo ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
How it starts
The opening of the file, as written. The whole thing — 316 lines — stays where its author put it; the contents beside it link to each section on GitHub.
Heap Exploitation
Overview
Heap exploitation targets vulnerabilities in dynamic memory allocation (malloc/free). This skill covers glibc heap internals, common vulnerabilities, and exploitation techniques from basic to advanced.
Prerequisites
- Understanding of C memory management
- GDB with pwndbg (for heap visualization)
- Knowledge of basic binary exploitation
- Familiarity with pwntools
Heap Internals Quick Reference
Chunk Structure
┌──────────────────┐
│ prev_size │ ← Only if previous chunk is free
├──────────────────┤
│ size | AMP │ ← A=allocated, M=mmap, P=prev_inuse
├──────────────────┤
│ user data │ ← Returned by malloc()
│ ... │
└──────────────────┘
Free Chunk (adds fd/bk pointers)
┌──────────────────┐
│ prev_size │
├──────────────────┤
│ size │
├──────────────────┤
│ fd │ ← Forward pointer to next free chunk
├──────────────────┤
│ bk │ ← Back pointer to previous free chunk
├──────────────────┤
│ (fd_nextsize) │ ← Only for large chunks
├──────────────────┤
│ (bk_nextsize) │ ← Only for large chunks
└──────────────────┘
Bin Types
| Bin | Size Range | Behavior | Security |
|---|---|---|---|
| Tcache | 0x20-0x410 | Per-thread LIFO | Minimal (< 2.32) |
| Fastbin | 0x20-0x80 | Global LIFO | Size check only |
| Unsorted | Any | Temporary holding | Some checks |
| Small | < 0x400 | FIFO by size | FIFO checks |
| Large | >= 0x400 | Best fit | Complex checks |
Vulnerability Types
1. Use-After-Free (UAF)
Access freed memory - can leak or corrupt heap metadata.
Detection pattern:
free(ptr);
// ptr not nullified
ptr->field = value; // UAF write
data = ptr->field; // UAF read
2. Double Free
Free the same chunk twice - corrupts free lists.
Detection pattern:
free(ptr);
// ...
free(ptr); // Same pointer freed again
3. Heap Overflow
Write beyond chunk boundary into adjacent chunks.
What ships with it
2 files beside SKILL.md in the same directory: the scripts, references and assets a skill reads on demand. Not counted in the per-session cost; read them before you install if any of them is executable.
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 2mo ago First seen · 316 lines · 87 tokens per session scan A 6bab7751b203
Heap Exploitation is a skill published in the GitHub repository allsmog/pwn-claude-plugin (2 stars, last pushed 8mo ago), licensed MIT. It adds 87 tokens to every session and 2,143 once invoked, about $0.0003 per session on Opus 5.5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.
Other skills, from other repositories
bypassing-binary-exploitation-mitigations
Methodology for identifying and defeating common binary hardening mitigations during authorized exploitation — ASLR, PIE, stack canaries, NX/DEP, and RELRO — by leaking addresses, brute-forcing entropy, abusing forked-process behavior, and selecting the right code-reuse primitive for the protections in place.
exploiting-arbitrary-write-to-execution
Methodology for converting an arbitrary-write (write-what-where) or write-anything-anywhere primitive into code execution during authorized engagements, covering target selection among GOT/PLT entries, .finiarray/.dtors, mallochook/freehook, the atexit/exitfuncs handler list, and printfarginfotable, plus how…
exploiting-format-string-vulnerabilities
Methodology for exploiting format string bugs where attacker-controlled data reaches the format argument of printf-family functions, enabling stack/memory disclosure (info leaks for ASLR/PIE/canary defeat) and arbitrary write primitives (%n) to hijack control flow via GOT/.finiarray overwrites.
exploiting-glibc-heap-vulnerabilities
Methodology for exploiting glibc ptmalloc2 heap vulnerabilities during authorized engagements — use-after-free, double-free, heap overflow, and bin-based attacks (tcache poisoning, fast-bin dup, unsorted/large-bin) — including modern mitigations (tcache key, safe-linking, hook removal) and how to obtain leaks and…
exploiting-integer-overflow-vulnerabilities
Methodology for finding and exploiting integer overflow, underflow, truncation, and signedness bugs in native code during authorized engagements, focusing on how wrapped arithmetic in size/length calculations leads to undersized allocations, oversized copies, length-check bypasses, and downstream heap/stack overflows.
exploiting-linux-kernel-vulnerabilities
Methodology for discovering and exploiting Linux kernel memory-corruption vulnerabilities (UAF, OOB read/write, race/TOCTOU, type confusion) during authorized engagements, covering reachability analysis, building stable read/write primitives from a single bug, defeating KASLR/SMEP/SMAP/KPTI, slab/buddy heap grooming…