Exploit-Primitive Development Assessment
Read the assessment methodology 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.
- Confirm the primitive (from
rt-crash-analysis) and the build/mitigations (checksec). - Leak (if ASLR). Build an info leak to resolve a base; verify the leaked address.
- Chain. Assemble the minimal code-reuse chain (ret2win/ret2libc/ROP) to the marker; keep it minimal.
- Heap (if applicable). Groom to place the target object; verify the layout before triggering.
- Prove control & reliability. Reach the marker; repeat to establish reliability; stop at the marker — no post-exploitation.
- 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.