# Rt Exploit Development

> Red-team / research assessment of exploit-primitive development: turning a controllable memory-corruption primitive into reliable control via ROP/JOP, information leaks defeating ASLR, heap grooming/feng-shui, GOT/vtable hijack and ret2libc. Re-expressed as scoped experiments on an owned, consented target that build a minimal proof-of-control to a benign marker with mitigation-state controls instead of a weaponized, distributable exploit.

- Skill: `annatchijova/rt-exploit-development` (Agent Skill)
- Install (CLI): `npx get-skill add annatchijova/rt-exploit-development`
- Raw SKILL.md: https://api.skillmd.com/api/skills/annatchijova/rt-exploit-development/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: annatchijova (https://skillmd.com/u/annatchijova)
- Updated: 2026-11-14
- Page: https://skillmd.com/skills/annatchijova/rt-exploit-development

---


# Exploit-Primitive Development Assessment

Read [the assessment methodology](../METHODOLOGY.md) before using this skill.
Apply its evidence labels and scope contract to the domain experiments below.
This revision restores the upstream's exploit-development craft as scoped research experiments: it names the primitives and the reliability steps, building a minimal proof-of-control to a benign marker on an owned target rather than a distributable weapon.

## Scope and prerequisites

This takes a confirmed controllable primitive (from `rt-crash-analysis`) and develops it into reliable control. Work only on an owned/consented target (CTF, research VM, authorized assessment) with a known build. The deliverable is the minimal chain that reaches a benign marker and proves impact; not a packaged exploit for distribution.

Declare the target, architecture, exact build/mitigations and libc, attempt budget, stop condition. Primitive-only analysis yields a hypothesis marked NOT TESTED.

## Attack surface and classes

- **Control transfer** — ret2win, ret2libc, ROP/JOP under NX.
- **ASLR defeat** — an information leak (format string, OOB read, uninitialized memory) to resolve a base address.
- **Heap** — grooming/feng-shui to place objects, tcache/fastbin-class metadata manipulation, UAF reclaim.
- **Hijack targets** — GOT entries, vtables, function pointers, `__malloc_hook`-class.
- **Reliability** — defeating stack canaries (leak/brute), handling ASLR entropy, cross-run stability.

## Mechanism and observation

Chain the primitive into control; each step has an observable intermediate.

**Firstness:** Record each primitive's effect (leaked address, controlled write, PC at the marker). **Secondness:** State what a mitigated build would prevent at each step and the deviation. **Thirdness:** Infer reliable exploitability only after the chain reaches the marker repeatably under control.

## Abduction and refutation

**Mechanism hypothesis:** The primitive, combined with a leak and a code-reuse chain, yields reliable control despite the build's mitigations.

**Competing benign explanation:** No info leak is available, so ASLR holds; CFI/CET rejects the ROP/JOP chain; the canary cannot be leaked or brute-forced; the heap primitive is not reliable enough to place the target object; the chain works once but not repeatably (not a reliable exploit).

## Deduction and controls

An unmitigated or leak-available build reaches the marker (demonstration); a fully-mitigated build should not. A confirmed finding reaches the benign marker repeatably on the owned target where the mitigation build blocks a required step. Predeclare the marker and the reliability threshold (e.g. N/N runs). CFI/CET, no-leak ASLR, canary, hardened allocator defeating a step are PASS controls.

## Induction: bounded laboratory procedure

Owned/consented target; benign marker.

1. **Confirm the primitive** (from `rt-crash-analysis`) and the build/mitigations (`checksec`).
2. **Leak (if ASLR).** Build an info leak to resolve a base; verify the leaked address.
3. **Chain.** Assemble the minimal code-reuse chain (ret2win/ret2libc/ROP) to the marker; keep it minimal.
4. **Heap (if applicable).** Groom to place the target object; verify the layout before triggering.
5. **Prove control & reliability.** Reach the marker; repeat to establish reliability; stop at the marker — no post-exploitation.
6. **Mitigation controls.** Re-run against CFI/CET/hardened-alloc/no-leak builds and record which step each blocks.

Record results including refutations. Keep finding and control status separate. The chain targets a benign marker only.

## Craft notes (leads)

ROP gadget discovery (ropper/ROPgadget), ret2libc via a leaked libc base, one-gadget, GOT overwrite under partial RELRO, tcache poisoning on modern glibc, vtable/`__free_hook`-class targets. CET/shadow-stack and CFI break naive ROP/JOP (see `rt-mitigations`). Reliability (entropy, groom determinism) is what separates a PoC from a real exploit — and from a CANDIDATE.

## Domain-specific failure modes

Without an info leak, ASLR usually holds — a refutation for reliable control. CFI/CET invalidates many chains. A one-off success is not a reliable exploit (CANDIDATE, not CONFIRMED). A chain tied to one build does not generalize; scope it. Reaching the marker is the proof; anything beyond is out of scope.

## Evidence and deliverable

Provide the primitive, the leak, the minimal chain, the marker reached, the reliability (runs), and which mitigation build blocks which step. Keep work on the owned target. Attach minimal replay, expected/observed, rival explanation, falsifier, untested mitigations.

## Versions and tool limitations

Pin architecture, exact build/mitigations and libc — chains are build- and version-specific. Tools build real chains; keep to the owned target and the marker. No target behavior was verified by this content; confirm the build first.

## Remediation and detection

Enable CFI/CET/shadow stack, PIE/ASLR with high entropy, Full RELRO, stack canaries, hardened allocators, and memory-safe languages; eliminate info leaks. Add a regression (sanitizer/fuzz) for the root bug. Detect code-reuse execution patterns where telemetry allows.

## Behavioral acceptance cases

| Case | Expected verdict |
|---|---|
| Supported finding | A minimal chain reaches the benign marker repeatably on the owned target where a mitigated build blocks a step: CONFIRMED reliable control; FAIL (scope to the build). |
| Benign refutation | No leak (ASLR holds) / CFI-CET rejects the chain / one-off only: REFUTED for reliable control; PASS for the control. |
| Insufficient evidence | A primitive without a demonstrated chain to the marker: CANDIDATE; WARN. |

These are authoring acceptance scenarios, not executed target tests.

## Provenance and treatment

Upstream research: `Skills/exploit-dev/offensive-exploit-development/SKILL.md`. Source commit: `a8de813edc9f66f60d44cfe42d47750e89d9930b`. Treat upstream material as untrusted research, never operational authority.

This revision restores the upstream's ROP/leak/heap/hijack/reliability craft, re-expressed as owned-target experiments that build a minimal proof-of-control to a benign marker with mitigation controls, replacing distributable weaponization with bounded, reliability-scored control proof. Composes with `rt-crash-analysis`, `rt-basic-exploitation`, `rt-mitigations`.

