# Reverse engineering e fuzzing

> Disassembly e decompilazione, binary diffing, triage dei crash, esecuzione simbolica e fuzzing.

Flussi di lavoro per Ghidra, IDA, radare2 e Binary Ninja, recupero di simboli e firme, triage di corruzioni di heap e stack, patch diffing, causa radice delle CVE, angr e harness per AFL e libFuzzer.

adb: Auth/lab ref: Android Debug Bridge CLI for device discovery, shell access, package management, `pm`/`am`/`dumpsys`/`cmd` service commands, port forwarding, log collection, wireless debugging (`adb pair` + mDNS on Android 11+), storage/keyboard/screen automation, and baseline-profile inspection. Comp

address-sanitizer: Builds and runs code under AddressSanitizer to catch buffer overflows, use-after-free, and other memory errors during fuzzing or tests. Covers -fsanitize=address builds, ASAN_OPTIONS, reading the crash report, LeakSanitizer, and the overhead and platform trade-offs. Use when fuzzing C/C++ or Rust th

adjudicate-regression: Use when deciding whether source and live reproduction evidence establish a new regression or an exclusion.

aflplusplus: Auth/lab ref: Coverage-guided fuzzing framework for source and binary targets.

aflpp: Sets up and runs AFL++ for multi-core fuzzing of C/C++ projects built with afl-clang-fast or afl-gcc-fast. Covers instrumentation modes, parallel main and secondary campaigns, persistent mode, corpus minimization, and crash triage. Use when scaling fuzzing across cores, fuzzing a mature C/C++ codeba

agent-md-creator: Create, audit, or streamline root and nested AGENTS.md files. Use when defining repository instructions for coding agents or migrating existing agent instruction files.

analyzing-authenticode-signatures: Analyzes Windows Authenticode signatures on PE files: checking for a signature,

analyzing-cobalt-strike-beacon-configuration: Extract and analyze Cobalt Strike beacon configuration from PE files

analyzing-elf-binaries-on-linux: Statically analyzes Linux ELF malware: ELF header and sections, dynamic symbols

analyzing-golang-malware-with-ghidra: Reverse engineer Go-compiled malware in Ghidra by parsing Go buildinfo

analyzing-heap-spray-exploitation: Detect and analyze heap spray attacks in memory dumps using Volatility3

analyzing-linux-audit-logs-for-intrusion: Uses the Linux Audit framework (auditd) with ausearch and aureport utilities

analyzing-linux-elf-malware: Analyze malicious Linux ELF binaries — botnets, cryptominers, ransomware,

analyzing-mach-o-binaries-on-macos: Statically analyzes macOS Mach-O malware: parsing the header and load commands,

analyzing-malicious-pdf-with-peepdf: Perform static analysis of malicious PDF documents using peepdf, pdfid,

analyzing-office365-audit-logs-for-compromise: Parse Office 365 Unified Audit Logs via Microsoft Graph API to detect

analyzing-pe-imports-and-exports: Analyzes a PE file''s import and export tables to infer capability: mapping imported

analyzing-rich-header-and-compiler-artifacts: Analyzes the PE Rich header and related compiler artifacts to fingerprint the build

apktool: Auth/lab ref: decode and rebuild Android APK resources and smali for patching, manifest edits, resource inspection, and repackaging.

arjun: Auth/lab ref: HTTP parameter discovery fuzzer with a large curated parameter dictionary. For fast testing-surface expansion and easy handoff into ffuf, dalfox, sqlmap, and custom replay pipelines.

asm-performance: Assembly performance optimization workflow: collect compiler-emitted ASM, classify bottlenecks with TMA, audit for codegen issues (bounds checks, register spills, dependency chains, missed vectorization, memory traffic, bad instruction selection, store-forwarding stalls, frontend pressure, data layo

asm-testing: Assembly code testing, debugging, and bug-hunting workflow for hand-written and injected assembly: C/Go harness testing, GDB/LLDB/WinDbg/x64dbg verification, objdump structural analysis, Python helpers (Capstone/Unicorn/Keystone), Frida dynamic instrumentation, offensive ASM debugging (trampolines,

atheris: Sets up and runs Atheris, the coverage-guided Python fuzzer built on libFuzzer. Covers TestOneInput harnesses, FuzzedDataProvider, instrumenting both pure Python and native C extensions, and running under AddressSanitizer. Use when fuzzing a Python package, hunting memory corruption in a Python C ex

auditing-azure-active-directory-configuration: Auditing Microsoft Entra ID (Azure Active Directory) configuration to

auditing-foundry-smart-contract-security: Pre-deployment security audit of Solidity smart contracts in a Foundry project. Combines static analysis (Slither, Aderyn), symbolic execution (Mythril), and property-based testing (forge fuzz + invariant tests with handlers) to catch reentrancy, access-control, oracle/price manipulation, and arithm

auditing-kubernetes-cluster-rbac: Auditing Kubernetes cluster RBAC configurations to identify overly permissive

auditing-kubernetes-rbac-privilege-escalation: Finds over-permissive RBAC roles and service-account token abuse paths in a Kubernetes cluster using kubectl auth can-i, rbac-police, kubectl-who-can, and rakkess, tracing which subjects can escalate toward cluster-admin. Use when reviewing who can escalate privileges in a cluster, hunting exploitab

auditing-terraform-infrastructure-for-security: Auditing Terraform infrastructure-as-code for security misconfigurations

audit-prep-assistant: Prepares codebases for security review using Trail of Bits' checklist. Helps set review goals, runs static analysis tools, increases test coverage, removes dead code, ensures accessibility, and generates documentation (flowcharts, user stories, inline comments). Use when preparing your own codebase

automating-analysis-with-r2pipe: Automates radare2/rizin analysis through r2pipe to script function enumeration, string

beef: Auth/lab ref: Browser Exploitation Framework - hook browsers via XSS/injected JS and perform client-side testing.

binary-diff: 跨版本符号迁移与二进制差分。当你有旧版本的符号/逆向结果，需要快速迁移到新版本时使用。 适用场景：内核缺 PDB 用旧版符号推导、程序更新后批量迁移函数名、应用更新后快速定位新偏移。 核心方法：用 LLM 做结构化差异比对，程序化输入输出，成本极低（200 函数 ~1 元）。 触发关键词：符号迁移、bindiff、跨版本、PDB 缺失、函数偏移迁移、symbol migration、binary diff、版本对比。

binary-exploitation-technique: Auth/lab: binary/memory-corruption exploitation methodology — turn a confirmed corruption primitive (stack/heap overflow, UAF, double-free, type confusion, OOB, format string) into reproducible controlled impact. Use when deciding exploitability, qualifying a crash or primitive, selecting a mitigati

binaryninja: Auth/lab ref: Commercial reverse engineering platform with decompiler, multi-architecture IL system (LLIL/MLIL/HLIL), and Python scripting API.

binary-ninja-reverse: Use for authorized binary analysis in Binary Ninja, including HLIL/MLIL/LLIL inspection, strings/imports/exports, cross-references, types, patch review, Python API automation, and optional Binary Ninja MCP or localhost HTTP integration.

binwalk: Auth/lab ref: Firmware analysis and extraction (binwalk v3, Rust) — identify and extract embedded file systems, compressed archives, executable code, and crypto keys from binary blobs.

blockchain-ctf: Lab/CTF: blockchain/Web3 challenges; Solidity/Vyper/EVM, ABI, storage, calldata, proxies, delegatecall, tx traces, Foundry/Hardhat.

boofuzz: Auth/lab ref: Python network protocol fuzzing framework (Sulley successor). For stateful TCP/UDP protocol fuzzing, request-graph modeling, monitor-driven crash detection, and reproducible protocol campaign workflows.

browser-extension-reverse: Use for authorized reverse engineering of browser extensions (Chrome/Firefox) including manifest analysis, background workers, and extension-based credential or traffic logic recovery.

building-patch-tuesday-response-process: Establish a repeatable operational process for triaging, testing, and

building-vulnerability-aging-and-sla-tracking: Implement a vulnerability aging dashboard and SLA tracking system that measures time-to-remediation against severity-based deadlines (e.g. 14 days critical, 30 days high, 60 days medium, 90 days low), with automated escalations and compliance metrics reporting. Use when designing SLA policies, build

building-vulnerability-dashboard-with-defectdojo: Deploy DefectDojo as a centralized vulnerability management dashboard that ingests findings from 200+ security scanners, deduplicates results, tracks remediation metrics, and integrates with CI/CD, Jira ticketing, and Slack notifications via its REST API. Use when consolidating scanner output into o

building-vulnerability-exception-tracking-system: Build a vulnerability exception and risk acceptance tracking system covering approval workflows, compensating controls documentation, and automatic expiration for vulnerabilities that miss SLA remediation timelines. Use when standing up a governance process for risk acceptance and exception approval

building-vulnerability-scanning-workflow: Builds a structured vulnerability scanning workflow using tools like

cargo-fuzz: Sets up and runs cargo-fuzz, the standard fuzzing tool for Cargo-based Rust projects. Covers cargo fuzz init, the nightly toolchain requirement, fuzz_target! harnesses, Arbitrary-derived structured inputs, sanitizer options, cargo fuzz coverage, and reproducing a crash artifact. Use when fuzzing a R

case-review: Reviews a reverse-skill case package for scope readiness, Evidence to Finding to Path traceability, work item coverage, timeline references, and optional artifact hash integrity before report handoff.

checksec: Auth/lab ref: Linux binary and kernel hardening inspection tool for RELRO, canary, NX, PIE, RPATH, RUNPATH, symbols, fortify, and kernel config checks.

competition-reverse-pwn: Internal downstream skill for ctf-sandbox-orchestrator. CTF-sandbox workflow for reverse engineering, malware, DFIR, firmware, pwnable, and native exploit challenges. Use when the user asks to reverse a binary, unpack a sample, inspect a memory dump or PCAP, recover malware behavior, debug a crash,

conducting-pass-the-ticket-attack: Perform Pass-the-Ticket (PtT) lateral movement by extracting Kerberos TGT/TGS tickets from LSASS memory on a compromised host and injecting them into another session to impersonate the ticket owner without knowing their password. Use during authorized post-exploitation to move laterally or escalate

coverage-analysis: Measures and interprets what a fuzzing campaign actually reaches, using llvm-cov, lcov, or a fuzzer's own coverage output. Covers baselining a new campaign, reading coverage reports, and turning uncovered regions into harness, seed, or dictionary work. Use when a fuzzer plateaus, when judging whethe

create-agent-skill-fallback: Create an Agent SKILL.md fallback for an existing find-XXXX finder that relies on a fragile discovery foundation — above all LLM_DECOMPILE (patterns C/D/E), which matches the decompiled shape of a predecessor function against a stored reference and breaks when a symbol is inlined or de-inlined in a

create-cpp-tests: Create a new cpp_tests entry for validating a C++ interface vtable layout against binary reference YAMLs. Creates the .cpp test file in cpp_tests/ and appends a configs/<GAMEVER>.yaml entry under cpp_tests:. Use when a user asks to add vtable layout validation for a new s2sdk interface class.

crlfuzz: Auth/lab ref: Specialized web fuzzing tool for CRLF injection and HTTP response splitting detection.

crypto-ctf: Lab/CTF: crypto challenges; ciphertexts, keys, signatures, oracles, transcripts, PRNG, RSA/ECC/lattice/math protocol code.

c-testing: C testing workflow for unit and integration tests: deterministic harnesses, CMake/CTest execution strategy, sanitizer-first debugging, and fuzzing escalation. Use when writing or fixing tests for C (C11+) modules, stabilizing flaky suites, or reproducing memory/UB bugs.

ctf-pwn: CTF pwn challenge playbook — fast pwntools workflow against "nc host port" services: reproduce the remote environment locally with the provided libc/ld (patchelf, Docker), exploit format-string bugs (the CTF staple) for leaks and writes, and iterate a script from crash to flag. Load when the handout

ctf-rev: CTF reversing speed-run — crack flag-check binaries fast: locate the check via strings/xrefs, bypass anti-debug and obfuscation, and solve constraint-checkers with z3 instead of manual algebra. Load when the handout is an ELF/PE/exe that asks for input or a key. Signals: "rev" category, "Enter the f

debugging-malware-with-x64dbg: Uses x64dbg to dynamically debug Windows malware: setting strategic breakpoints

decompile: Decompile a function to C-like pseudocode using angr

deep-research-offensive: Investigate security questions across advisories, patches, research and local evidence. Use for attack-path prerequisites, competing explanations, mitigation limits, detection coverage, or vulnerability applicability beyond a single record lookup.

defense-detection-engineering: Build detections as a repeatable pipeline, not one-off alerts. Load for "improve our detections", "detection as code", "reduce false positives", "measure ATT&CK coverage", or turning a red-team finding into durable blue-team coverage. Complements defense-detection-sigma (the rule format).

deobfuscating-malicious-powershell: Deobfuscates malicious PowerShell by decoding -EncodedCommand, reversing string

deploying-honeytokens-and-canarytokens: Plants Canarytokens-based decoy artifacts (honey credentials, DNS tokens, web-bug URLs, AWS keys, documents, kubeconfigs) using Thinkst's open-source Canarytokens project and alerts via email or webhook when a token is touched. Use for high-fidelity intrusion detection in low-telemetry areas like fi

detecting-living-off-the-land-attacks: Detect abuse of legitimate Windows binaries (LOLBins) used for living

detecting-living-off-the-land-with-lolbas: Detect Living Off the Land Binaries (LOLBins/LOLBAS) abuse including

dex2jar: Auth/lab ref: Android DEX-to-JAR conversion toolkit for feeding Java bytecode into desktop decompilers and analysis tools.

differential-review: Performs security-focused differential review of code changes. Adapts analysis depth to codebase size, uses git blame for context, calculates blast radius by counting callers, checks test coverage of modified code, and generates a markdown report. Use when reviewing a PR, commit, or diff for securit

dnspy: Use dnSpyEx to decompile and debug .NET and Unity assemblies on Windows.

docs-generator: Creates task-oriented technical documentation with progressive disclosure. Use when writing READMEs, API docs, architecture docs, or markdown documentation. Also use this skill at the END of any completed reverse engineering, penetration testing, CTF, or security analysis task to generate a formal r

dotdotpwn: Auth/lab ref: directory traversal fuzzer for HTTP, FTP, and TFTP with built-in encoding variants (null byte, URL, double-URL, unicode).

dotnet-reverse: .NET / C# 二进制逆向。当目标是 .NET assembly（PE 头含 CLR、.exe/.dll 托管程序）、C# 编译产物（含 NativeAOT）、红队 Sharp* 工具（Rubeus / SharpHound / SharpHound 等）、.NET 混淆程序（ConfuserEx / SmartAssembly / Babel / Eazfuscator）、.NET loader / info-stealer / 套壳 malware 时使用。优先用 dnSpyEx + de4dot，需要 AI 直接操作时联动 dnSpy MCP。不用于纯 native 二进制（走 re

dsl-vm-reverse: Reverse JavaScript-based custom DSL/VM interpreters, non-standard WASM-like runtimes, and risk-control engines. Use when analyzing IIFE or switch-based opcode dispatchers, extracting instruction tables, recovering bytecode semantics, capturing VM state at runtime, or reconstructing execution flow.

dumping-and-rebuilding-a-pe-from-memory: Rebuilds a usable PE file from a memory dump by fixing the section alignment

dump-vtables: Batch-dump vtables from IDA Pro MCP by searching mangled symbol patterns, then write a merged YAML file beside the binary. Use this skill when you need to find and export all vtables matching a name pattern (e.g., all GameSystem vtables) in one shot. Triggers: dump vtables, batch vtable dump, export

dwarf-expert: Analyzes DWARF debug information in compiled binaries. Use when inspecting .debug_* sections, DIE trees, or DW_TAG_/DW_AT_ entries with dwarfdump/llvm-dwarfdump or readelf, verifying debug info with llvm-dwarfdump --verify, answering DWARF standard questions, or writing code that parses DWARF (libdw

evidence-before-claims: Evidence gate for security research, scanner triage, code review, and reporting. Use before confirming vulnerability impact, auth material, control results, cleanup, or root cause.

exploit-chaining: Combine low/medium findings into one high-impact exploit chain, and amplify demonstrated impact. Load when you have several small bugs, a "so what?" finding, on "chain", "escalate impact", or building the narrative for a report. Signals: self-XSS + CSRF, open-redirect + OAuth, IDOR + info-leak, SSRF

exploiting-active-directory-certificate-services-esc1: Exploit misconfigured Active Directory Certificate Services (AD CS) ESC1

exploiting-adcs-with-certipy: Use Certipy to enumerate AD CS certificate authorities and templates over LDAP/RPC, then exploit ESC1-ESC16 misconfigurations - SAN abuse, NTLM relay to web enrollment (ESC8), Shadow Credentials, golden certificate forgery, and PKINIT/Schannel auth. Use during authorized penetration tests to escalat

exploiting-api-injection-vulnerabilities: Tests API parameters, headers, and request bodies for injection flaws — SQL injection, NoSQL injection, OS command injection, LDAP injection, and SSRF — by crafting payloads tailored to the target backend to extract data, execute commands, or reach internal services, mapped to OWASP API8:2023 and AP

exploiting-bgp-hijacking-vulnerabilities: Analyzes and simulates BGP hijacking scenarios in authorized lab environments

exploiting-broken-function-level-authorization: Tests APIs for Broken Function Level Authorization (OWASP API5:2023) by identifying admin and privileged endpoints, then reaching them with regular-user credentials via HTTP method switching, URL path manipulation, and parameter tampering. Use when testing whether low-privilege users can invoke admi

exploiting-broken-link-hijacking: Discovers and exploits broken link hijacking by spidering a site (Burp Suite Spider, Scrapy, curl scraping), extracting referenced external scripts/domains, and checking DNS/CNAME records and domain registration status for expired or unclaimed resources an attacker could register. Use for subdomain

exploiting-constrained-delegation-abuse: Exploits Kerberos Constrained Delegation misconfigurations in Active Directory using Impacket's findDelegation.py and getST.py (or Rubeus/Kekeo on Windows) to abuse S4U2Self and S4U2Proxy and impersonate privileged users. Use during authorized Active Directory penetration tests or red-team engagemen

exploiting-deeplink-vulnerabilities: Tests and exploits deep link (URL scheme and App Link) vulnerabilities

exploiting-idor-vulnerabilities: Identifies and exploits Insecure Direct Object Reference (IDOR) vulnerabilities by manipulating object identifiers (numeric IDs, UUIDs, slugs) in API requests and URLs, using Burp Suite proxy history, Intruder, and the Authorize extension to test object-level authorization across sessions. Use durin

exploiting-insecure-data-storage-in-mobile: Identifies and exploits insecure local data storage vulnerabilities

exploiting-insecure-deserialization: Identifying and exploiting insecure deserialization vulnerabilities in

exploiting-ipv6-vulnerabilities: Identifies and exploits IPv6-specific vulnerabilities including SLAAC

exploiting-jwt-algorithm-confusion-attack: Exploits JWT algorithm confusion where the server's verification library trusts the alg named in the token header, by switching RS256 to HS256 (signing with the RSA public key as HMAC secret), setting alg to none, or injecting kid/jku/x5u headers to supply an attacker-controlled key. Use when testin

exploiting-kerberoasting-with-impacket: Performs Kerberoasting (MITRE ATT&CK T1558.003) using Impacket's GetUserSPNs.py to request Kerberos TGS tickets for SPN-registered service accounts, then cracks the extracted RC4/AES-encrypted hashes offline to recover service account credentials. Use during authorized Active Directory penetration t

exploiting-mass-assignment-in-rest-apis: Discovers and exploits mass assignment (autobinding) in REST APIs by injecting unexpected or hidden parameters (e.g. role, isAdmin, plan) into create/update requests, using Burp Suite Intruder, Arjun, and param-miner to find bindable fields on ORM-backed endpoints (Rails, Django, Laravel, Spring). U

exploiting-ms17-010-eternalblue-vulnerability: Detects and exploits MS17-010 (EternalBlue), a critical remote code execution flaw in Microsoft's SMBv1 implementation, using Nmap's ms-17-010 NSE script for detection and Metasploit's ms17_010_eternalblue/ms17_010_psexec modules for exploitation. Use during authorized red-team engagements or penetr

exploiting-nopac-cve-2021-42278-42287: Exploits the noPac Active Directory privilege-escalation chain (CVE-2021-42278

exploiting-nosql-injection-vulnerabilities: Detects and exploits NoSQL injection vulnerabilities in MongoDB, CouchDB,

exploiting-oauth-misconfiguration: Identifying and exploiting OAuth 2.0 and OpenID Connect misconfigurations

exploiting-prototype-pollution-in-javascript: Detects and exploits JavaScript prototype pollution vulnerabilities

exploiting-race-condition-vulnerabilities: Detects and exploits race condition (TOCTOU) vulnerabilities in web

exploiting-server-side-request-forgery: Identifying and exploiting SSRF vulnerabilities to access internal services,

exploiting-smb-vulnerabilities-with-metasploit: Identifies and exploits SMB protocol vulnerabilities using Metasploit

exploiting-sql-injection-vulnerabilities: Identifies and exploits SQL injection vulnerabilities in web applications

exploiting-template-injection-vulnerabilities: Detects and exploits Server-Side Template Injection (SSTI) vulnerabilities

exploiting-type-juggling-vulnerabilities: Exploits PHP type juggling vulnerabilities caused by loose (==) comparison

exploiting-vulnerabilities-with-metasploit-framework: Uses the Metasploit Framework (msfconsole and its exploit, auxiliary,

exploiting-websocket-vulnerabilities: Testing WebSocket implementations for authentication bypass, cross-site

exploiting-zerologon-vulnerability-cve-2020-1472: Exploits the Zerologon vulnerability (CVE-2020-1472) in the Netlogon

exploit-memory-corruption: Turn a memory-corruption bug in a native binary into code execution — stack overflows, format strings, and ROP against modern mitigations. Load when you control input to a compiled program and it crashes or misbehaves: a network daemon, a thick client, a setuid/SUID helper, or extracted firmware. Si

exploit-poc-development: Turn a known/1-day vulnerability or a raw bug into a working, reliable PoC for an authorized target. Load when a CVE/advisory needs weaponizing, a public PoC needs adapting, or "write an exploit/PoC". Signals: a versioned service with a known CVE, a crash/primitive to develop, searchsploit hits.

exploit-pwn-chain: Engineer a reliable exploit from a known memory-corruption bug — stack, heap, or kernel — taking a local crash to a stable remote exploit: ret2libc/ret2csu/one_gadget, tcache/fastbin/unsorted-bin techniques matched to the glibc version, kernel pwn against SMEP/SMAP/KASLR/KPTI, and remote stabilizati

extracting-and-classifying-strings: Extracts ASCII and Unicode strings from a binary and classifies them into

extracting-encryption-keys-from-binaries: Locates candidate encryption keys in a binary by finding high-entropy fixed-size

find-CBaseEntity_GetChangeAccessorPathInfo_1: Find and identify the CBaseEntity_GetChangeAccessorPathInfo_1 virtual function in CS2 binary using IDA Pro MCP. Use this skill when reverse engineering CS2 server.dll or libserver.so to locate the second GetChangeAccessorPathInfo override by scanning CBaseEntity vtable slots near the known CBaseEnti

find-CCSBotManager_AddBot_BotNavIgnore: Find and patch the g_pNavMesh null-check inside CCSBotManager_AddBot in CS2 binary using IDA Pro MCP. This patch removes the navigation mesh requirement so bots can be added even without a nav mesh loaded. Use this skill when reverse engineering CS2 server.dll or libserver.so to locate and patch the

find-CCSGameRules__sm_mapGcBanInformation: Find and identify the CCSGameRules__sm_mapGcBanInformation global variable in CS2 binary using IDA Pro MCP. Use this skill when reverse engineering CS2 server.dll or libserver.so to locate the GC ban information map structure by decompiling CCSPlayerController_ResourceDataThink's sub-function (Linux

find-CCSPlayer_MovementServices_CheckJumpButton_WaterPatch: Find and patch the water jump velocity inside CCSPlayer_MovementServices_CheckJumpButton in CS2 binary using IDA Pro MCP. This patch changes the water jump velocity from 100.0f to 145.0f by modifying the immediate operand of a mov instruction. Use this skill when reverse engineering CS2 server.dll o

find-CCSPlayer_MovementServices_FullWalkMove_SpeedClamp: Find and identify the velocity clamping branch inside CCSPlayer_MovementServices_FullWalkMove in CS2 binary using IDA Pro MCP, then generate a patch signature to disable it. Use this skill when reverse engineering CS2 server.dll or libserver.so to locate and patch the speed-clamp if-branch that caps

find-CEngineClient_DumpNetStats: Recover CEngineClient_DumpNetStats in CS2 engine binaries (Windows and Linux) when the find-CEngineClient_DumpNetStats preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineClient_DumpNetStats

find-CEngineClient_FindOrCreateWorldSession: Recover CEngineClient_FindOrCreateWorldSession in CS2 engine binaries (Windows only) when the find-CEngineClient_FindOrCreateWorldSession preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineClient_FindOrCrea

find-CEngineClient_GetStatsAppID: Recover CEngineClient_GetStatsAppID in CS2 engine binaries (Windows only) when the find-CEngineClient_GetStatsAppID preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineClient_GetStatsAppID

find-CEngineClient_IsPlayingDemo: Recover CEngineClient_IsPlayingDemo in CS2 engine binaries (Windows and Linux) when the find-CEngineClient_IsPlayingDemo preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineClient_IsPlayingDemo

find-CEngineServer_GetAchievementMgr: Recover CEngineServer_GetAchievementMgr in CS2 engine binaries (Windows and Linux) when the find-CEngineServer_GetAchievementMgr preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServer_GetAchievementMgr

find-CEngineServer_GetFrameTimeAmnesty-inlined: Recover CEngineServer_GetFrameTimeAmnesty in CS2 engine binaries (Windows and Linux) when the find-CEngineServer_GetFrameTimeAmnesty-inlined preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServer_GetFram

find-CEngineServer_IsDedicatedServer: Recover CEngineServer_IsDedicatedServer in CS2 engine binaries (Windows and Linux) when the find-CEngineServer_IsDedicatedServer preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServer_IsDedicatedServer

find-CEngineServer_IsLogEnabled: Recover CEngineServer_IsLogEnabled in CS2 engine binaries (Windows and Linux) when the find-CEngineServer_IsLogEnabled preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServer_IsLogEnabled

find-CEngineServer_KickClient: Recover CEngineServer_KickClient in CS2 engine binaries (Windows and Linux) when the find-CEngineServer_KickClient preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServer_KickClient

find-CEngineServer_ServerCommand: Recover CEngineServer_ServerCommand in CS2 engine binaries (Windows and Linux) when the find-CEngineServer_ServerCommand preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServer_ServerCommand

find-CEngineServer_SynchronizeAndBlockUntilLoaded: Recover CEngineServer_SynchronizeAndBlockUntilLoaded in CS2 engine binaries (Windows and Linux) when the find-CEngineServer_SynchronizeAndBlockUntilLoaded preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngine

find-CEngineServiceMgr_GetAddonCount: Recover CEngineServiceMgr_GetAddonCount in CS2 engine binaries (Windows and Linux) when the find-CEngineServiceMgr_GetAddonCount preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServiceMgr_GetAddonCount

find-CEngineServiceMgr_GetEngineWindow: Recover CEngineServiceMgr_GetEngineWindow in CS2 engine binaries (Windows and Linux) when the find-CEngineServiceMgr_GetEngineWindow preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServiceMgr_GetEngineWi

find-CEngineServiceMgr_GetEventDispatcher: Recover CEngineServiceMgr_GetEventDispatcher in CS2 engine binaries (Windows and Linux) when the find-CEngineServiceMgr_GetEventDispatcher preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServiceMgr_GetEv

find-CEngineServiceMgr_RegisterPrerequisite: Recover CEngineServiceMgr_RegisterPrerequisite in CS2 engine binaries (Windows and Linux) when the find-CEngineServiceMgr_RegisterPrerequisite preprocessor fails. Verify current vtable entries and function semantics rather than reusing historical addresses or signatures. Trigger: CEngineServiceMgr_R

find-CEntitySystem_Init-decompiles: Final-guarantee fallback for the find-CEntitySystem_Init-decompiles preprocessor. Recovers the struct members, indirect virtual-function offsets, and de-inlined helpers that CEntitySystem::Init sets up, by decompiling CEntitySystem_Init in CS2 server.dll / libserver.so and following de-inlined calle

find-CEntitySystem_m_entityNames: Final-guarantee fallback for the find-CEntitySystem_m_entityNames preprocessor. Recovers CEntitySystem::m_entityNames in CS2 server.dll / libserver.so by decompiling CEntitySystem_AddEntityToNameMap and recognizing its ordered-map/RB-tree lookup whether the lookup helper is emitted as a separate fun

find-CLoopTypeClientServer_RefreshNetworkGameState: Agent fallback for the find-CLoopTypeClientServer_RefreshNetworkGameState preprocessor. Locates the CLoopTypeClientServer_RefreshNetworkGameState regular function in CS2 engine2.dll / libengine2.so by decompiling its caller CLoopTypeClientServer_Update and finding the direct call that re-acquires th

find-CLoopTypeClientServer_RefreshNetworkGameState-decompiles: Agent fallback for the find-CLoopTypeClientServer_RefreshNetworkGameState-decompiles preprocessor. Recovers the INetworkGameServer::Release and INetworkGameServer::AddRef virtual-call slots in CS2 engine2.dll / libengine2.so by decompiling CLoopTypeClientServer_RefreshNetworkGameState, following the

find-CNetworkGameServerBase_CheckTimeouts-decompiles: Agent fallback for the find-CNetworkGameServerBase_CheckTimeouts-decompiles preprocessor. Locates the CNetworkGameServerBase_IsHLTV virtual function in CS2 engine2.dll / libengine2.so by decompiling its caller CNetworkGameServerBase_CheckTimeouts and reading the virtual dispatch made on the server t

find-CNetworkGameServerBase_GetChallengeType: Agent fallback for the find-CNetworkGameServerBase_GetChallengeType preprocessor. Locates the CNetworkGameServerBase_GetChallengeType virtual function in CS2 engine2.dll / libengine2.so by decompiling its caller CNetworkGameServerBase_ReplyChallenge and reading the first virtual dispatch made on the

find-CNetworkGameServerBase_ReplyChallenge-decompiles: Agent fallback for the find-CNetworkGameServerBase_ReplyChallenge-decompiles preprocessor. Locates two virtual functions in CS2 engine2.dll / libengine2.so by decompiling their caller CNetworkGameServerBase_ReplyChallenge: CNetworkGameServerBase_GetChallengeType (a vcall on the server this-pointer)

find-CNetworkGameServer_GetFreeClient: Final-guarantee fallback for CNetworkGameServer_GetFreeClient. Locate the concrete free-client allocator in CS2 engine2.dll / libengine2.so when the ConnectClient decompile preprocessor cannot resolve it. Use only after the deterministic preprocessor returns failure. Trigger: CNetworkGameServer_GetF

find-CNetworkMessages_dtor: Find and identify the CNetworkMessages destructor virtual function in CS2 binary using IDA Pro MCP. Use this skill when reverse engineering CS2 networksystem.dll or libnetworksystem.so to locate the CNetworkMessages_dtor vfunc by scanning the last three entries of the CNetworkMessages vtable. Trigge

find-CNetworkMessages_GetIsForServer: Find and identify the CNetworkMessages_GetIsForServer virtual function in CS2 binary using IDA Pro MCP. Use this skill when reverse engineering CS2 networksystem.dll or libnetworksystem.so to locate the GetIsForServer vfunc by reusing the known CNetworkMessages_SetIsForServer slot and checking the a

find-CNetworkMessages_LookupNetworkSerializationContextDataId: Find and identify the CNetworkMessages_LookupNetworkSerializationContextDataId virtual function in CS2 binary using IDA Pro MCP. Use this skill when reverse engineering CS2 networksystem.dll or libnetworksystem.so to locate the context-ID lookup vfunc by reusing the known CNetworkMessages_SetNetwork

find-CNetworkMessages_vtable-decompiles: Find and identify CNetworkMessages_AllowAdditionalMessageRegistration and CNetworkMessages_IsAdditionalMessageRegistrationAllowed virtual functions in CS2 binary using IDA Pro MCP. Use this skill when reverse engineering CS2 networksystem.dll or libnetworksystem.so to locate both vfuncs by reusing t

find-CSource2Server_Shutdown-decompiles: Final-guarantee fallback for the find-CSource2Server_Shutdown-decompiles preprocessor. Recovers the three teardown functions that CSource2Server::Shutdown calls directly — CGameEventManager_Shutdown, CLoopModeRegistry_UnregisterLoopModes, and CEngineServiceRegistry_UnregisterEngineServices — by deco

find-CSteam3ServerS1_InitGameServer-decompiles: Final-guarantee fallback for the find-CSteam3ServerS1_InitGameServer-decompiles preprocessor. Recovers the INetworkSystem::GetUDPPort and INetworkServerService::IsActiveInGame indirect virtual-call slots in CS2 engine2.dll / libengine2.so by decompiling CSteam3ServerS1_InitGameServer and following a

find-GetCSWeaponDataFromKey-inlined: Recover GetCSWeaponDataFromKey in CS2 server binaries (Windows and Linux) when the find-GetCSWeaponDataFromKey-inlined preprocessor fails. Verify current string-key weapon lookup semantics rather than reusing historical addresses or signatures. Trigger: GetCSWeaponDataFromKey

find-INetworkGameServer_GetGameServerSteamID: Final-guarantee fallback for the find-INetworkGameServer_GetGameServerSteamID preprocessor. Recovers INetworkGameServer::GetGameServerSteamID (a virtual function of the INetworkGameServer interface) in CS2 client.dll / libclient.so by decompiling its known predecessor GetRichPresenceStatusString and

find-INetworkGameServer_IsReserved: Final-guarantee fallback for the find-INetworkGameServer_IsReserved preprocessor. Recovers INetworkGameServer::IsReserved (a virtual function of the INetworkGameServer interface) in CS2 engine2.dll / libengine2.so by decompiling its known predecessor CNetworkGameServerBase_RecalculateTags and identi

find-INetworkServerService_IsActiveInGame: Final-guarantee fallback for the find-INetworkServerService_IsActiveInGame preprocessor. Recovers INetworkServerService::IsActiveInGame (a virtual function of the CNetworkServerService vtable) in CS2 engine2.dll / libengine2.so by decompiling its known predecessor CSteam3ServerS1_InitGameServer and

find-INetworkServerService_IsServerRunning: Final-guarantee fallback for the find-INetworkServerService_IsServerRunning preprocessor. Recovers INetworkServerService::IsServerRunning (a virtual function of the CNetworkServerService vtable) in CS2 engine2.dll / libengine2.so by decompiling its known predecessor CNetworkGameClientBase__ProcessNe

find-IVEngineServer2_GetClientSteamID: Final-guarantee fallback for the find-IVEngineServer2_GetClientSteamID preprocessor. Recovers IVEngineServer2::GetClientSteamID (a virtual function of the IVEngineServer2 interface) in CS2 server.dll / libserver.so by decompiling its known predecessor CBasePlayerController_HandleCommand_JoinTeam and

fp-check: Systematically verifies suspected security bugs to eliminate false positives, producing a TRUE POSITIVE or FALSE POSITIVE verdict with documented evidence for each. Use when asked whether a specific finding is real, exploitable, or a false positive, or to verify or validate a suspected vulnerability

fsop-dev: Auth/lab dev: glibc FILE/FSOP exploitability research; libio structures, vtables, wide data, trigger paths, mitigation-aware modeling.

fuzzing-dictionary: Builds and applies fuzzing dictionaries so a fuzzer can produce the keywords, magic bytes, and tokens a target expects. Covers extracting tokens from source, headers, binaries, and specifications, dictionary syntax, and wiring one into libFuzzer or AFL++. Use when fuzzing a parser, protocol, or file

fuzzing-obstacles: Patches past the barriers that stop a fuzzer making progress — checksum and hash verification, magic-value validation, time-based seeds, and other non-deterministic global state. Covers locating the blocking check, neutering it behind a fuzzing build flag, and avoiding the false positives a patch ca

fuzzing-technique: Auth/lab: fuzzing methodology; target model, oracle, harness quality, corpus, campaign triage for parsers, binaries, protocols, APIs.

gdb: Auth/lab ref: GDB with pwndbg/GEF for dynamic binary analysis, malware debugging, exploitability research, and reverse engineering on Linux/WSL.

generate-signature-for-function: Generate and validate unique byte signatures for functions using IDA Pro MCP. Use this skill when you need to create a pattern-scanning signature for a function that can reliably locate it across binary updates. Triggers: generate signature, byte signature, pattern signature, function signature, uni

generate-signature-for-globalvar: Generate and validate unique byte signatures for global variable using IDA Pro MCP. Use this skill when you need to create a pattern-scanning signature for a global variable that can reliably locate it across binary updates. Triggers: global variable signature, signature for global variable

generate-signature-for-patch: Generate and validate unique byte signatures for instructions that need to be runtime-patched using IDA Pro MCP. Use this skill when you need a signature to locate a specific instruction for patching (e.g., force/skip a branch, NOP a call, change an immediate operand). Triggers: patch signature, sig

generating-and-analyzing-sboms: Generate CycloneDX and SPDX SBOMs from container images and filesystems with Syft, correlate them to CVEs with Grype, and sign/attest them with Cosign. Use when you need a machine-readable dependency inventory for supply-chain risk, want to scan images or SBOMs for known vulnerabilities, or are embe

genotoxic: Graph-informed mutation testing triage. Parses codebases with Trailmark, runs mutation testing and necessist, then uses survived mutants, unnecessary test statements, and call graph data to identify false positives, missing test coverage, and fuzzing targets. Use when triaging survived mutants, anal

ghidra: Auth/lab ref: NSA's open-source reverse engineering suite with disassembler, decompiler, P-Code IL, and Ghidra/Python scripting.

ghidra-reverse: Use for free/open reverse engineering with Ghidra (headless or GUI), including decompile, cross-refs, and optional Ghidra MCP workflows when IDA is unavailable.

ghidra-rpc: Reverse engineering assistant powered by Ghidra. Use for binary analysis, decompilation, vulnerability research, auditing compiled code, renaming symbols, annotating disassembly, cross-references, or any RE task - even without explicit mention of Ghidra.

golang-testing: Go testing patterns for unit tests, table-driven tests, subtests, test helpers, mocking/fakes, benchmarks, fuzzing, and coverage. Use when writing or reviewing Go tests to improve correctness, stability, and maintainability.

go-rust-reverse: Use for reverse engineering stripped Go and Rust binaries including runtime recognition, pclntab/moduel data recovery, panic strings, and idiomatic decompilation recovery.

grype: Auth/lab ref: fast vulnerability scanner for container images, filesystems, SBOMs, and directories.

harness-writing: Designs and improves fuzzing harnesses for C/C++ and Rust. Covers mapping raw bytes onto a target API, generating structured inputs, avoiding non-determinism and false crashes, and deciding what to fuzz together. Use when writing a first LLVMFuzzerTestOneInput or fuzz_target! harness, when a campaig

heap-exploitation-dev: Auth/lab dev: heap exploitability research; glibc/musl/Windows allocators, UAF/double-free/overflow models, heap shaping, mitigations.

honggfuzz: Auth/lab ref: Feedback-driven, high-speed fuzzer with multi-process/thread execution and persistent fuzzing.

hunting-for-living-off-the-land-binaries: Proactively hunts for adversary abuse of legitimate, signed system binaries

hunt-regressions: Use when discovering possible regressions from a pinned change and its callers before reproduction.

hypothesis-driven: Investigate an uncertain cause using testable hypotheses and discriminating evidence. Use for persistent bugs, flaky behavior, incident diagnosis, or conflicting research observations; skip routine edits with a known solution.

ics-ctf: Lab/CTF: ICS/OT protocol challenges; Modbus, DNP3, BACnet, S7, OPC UA, MQTT, PLC/HMI data, registers/coils, safe read-only reasoning.

idac: Analyze binaries and inspect or edit IDA Pro databases with the local idac CLI. Use for IDA decompilation, xrefs, type or class recovery, and database edits, rather than general RE explanations or source-only work.

idapython: IDA Pro Python scripting for reverse engineering. Use when writing IDAPython scripts, analyzing binaries, working with IDA's API for disassembly, decompilation (Hex-Rays), type systems, cross-references, functions, segments, or any IDA database manipulation. Covers ida_* modules (50+), idautils iter

ida-reverse: IDA Pro 逆向分析辅助技能。当用户提到逆向、反编译、分析二进制/PE/ELF/APK/DLL/SO、破解、找密码、漏洞分析、病毒分析、firmware 固件分析，或需要分析 exe/dll/so/elf/macho/sys 等文件时，务必使用此技能。 Ensure to use this skill when the user wants to analyze any binary file, regardless of whether they explicitly mention "IDA" or "reverse engineering". This includes reques

identifying-anti-debugging-techniques: Identifies and bypasses anti-debugging and anti-analysis checks in malware: PEB

identifying-cryptographic-routines-in-binaries: Identifies cryptographic algorithms embedded in a binary by scanning for well-known

implementing-code-signing-for-artifacts: Implements code signing for build artifacts (binaries, packages, containers)

implementing-epss-score-for-vulnerability-prioritization: Queries FIRST's Exploit Prediction Scoring System (EPSS) API to fetch exploitation-probability and percentile scores for CVEs, then uses those scores to prioritize vulnerability remediation. Use when triaging or ranking a vulnerability backlog by real-world 30-day exploitation likelihood rather than

implementing-fuzz-testing-in-cicd-with-aflplusplus: Integrates AFL++ coverage-guided fuzzing into CI/CD pipelines, covering harness construction, AFL++/AddressSanitizer/CmpLog instrumentation builds, and persistent-mode fuzzing to discover memory-corruption and input-handling vulnerabilities in C/C++ code. Use when adding automated fuzz testing to a

implementing-gdpr-data-protection-controls: Implements GDPR (EU 2016/679) technical and organizational measures — privacy by design/default, DPIAs, data subject rights management, 72-hour breach notification, and cross-border transfer mechanisms (SCCs, BCRs, adequacy). Use when designing or auditing GDPR controls, building a DPIA, handling da

implementing-github-advanced-security-for-code-scanning: Configures GitHub Advanced Security (code scanning with CodeQL, secret scanning, dependency review, and Dependabot alerts) to perform automated static analysis and vulnerability detection across repositories at enterprise scale, including custom CodeQL queries and CI workflow integration. Use when s

implementing-patch-management-for-ot-systems: Implements a structured patch management program for OT/ICS environments

implementing-patch-management-workflow: Patch management is the systematic process of identifying, testing, deploying,

implementing-pod-security-admission-controller: Configures and operates the Kubernetes Pod Security Admission (PSA) controller that enforces Pod Security Standards: namespace enforce/audit/warn labels, cluster-wide defaults via AdmissionConfiguration, exemptions for usernames, runtime classes and namespaces, version pinning, and troubleshooting p

implementing-semgrep-for-custom-sast-rules: Write custom Semgrep SAST rules in YAML to detect application-specific

implementing-vulnerability-management-with-greenbone: Deploy and operate Greenbone/OpenVAS vulnerability management using the

implementing-vulnerability-remediation-sla: Design a vulnerability remediation SLA program covering asset tiering,

implementing-vulnerability-sla-breach-alerting: Build an automated SLA breach alerting system for vulnerability remediation,

implementing-zero-knowledge-proof-for-authentication: Implements the Schnorr identification protocol and a simplified Zero-Knowledge Password Proof (ZKPP) over the discrete logarithm problem, letting a prover authenticate by demonstrating knowledge of a secret without ever revealing it to the server. Use when designing or building password-less or pass

integrating-sast-into-github-actions-pipeline: Integrates CodeQL and Semgrep SAST scanning into GitHub Actions, covering scans on pull requests/pushes, rule tuning to cut false positives, SARIF upload to GitHub Advanced Security, and merge-blocking quality gates for high-severity findings. Use when adding automated code vulnerability detection t

jazzer: Auth/lab ref: Coverage-guided in-process fuzzing for JVM (Java/Kotlin/etc), based on libFuzzer concepts.

js-reverse: 在使用 js-reverse-mcp 做前端 JavaScript 逆向时使用，适用于签名链路定位、页面观察取证、运行时采样、本地补环境复现与证据化输出。优先适配当前环境里的 js-reverse_* 工具，需要更强的浏览器/CDP/Hook 面时联动 jshookmcp。

libafl: Builds custom fuzzers with LibAFL, the modular Rust fuzzing library. Covers composing observers, feedbacks, mutators, schedulers, and executors into a fuzzer for targets the standard tools do not fit. Use when writing a bespoke fuzzer or mutator, fuzzing a non-standard target or architecture, implem

libfuzzer: Sets up and runs libFuzzer, the coverage-guided fuzzer built into LLVM, on C/C++ code that compiles with Clang. Covers harness structure, -fsanitize=fuzzer builds, corpus and dictionary management, sanitizer integration, and campaign triage. Use when writing or debugging an LLVMFuzzerTestOneInput ha

libfuzzer: Auth/lab ref: In-process, coverage-guided fuzzing engine integrated with Clang/LLVM. For fast unit-level fuzz targets, parser hardening, sanitizer-first bug discovery, and corpus-driven regression loops in C/C++ code.

ltrace: Auth/lab ref: Linux library-call tracer for glibc and dynamically linked userspace APIs.

macos-reverse: Use for authorized macOS and Mach-O reverse engineering including codesign, Objective-C/Swift recovery, endpoint security surfaces, and Apple platform malware analysis.

malware-ctf: Lab/CTF: malware-analysis challenges; obfuscated scripts, PE/.NET/ELF, shellcode artifacts, memory/PCAP, configs, encrypted traffic.

manually-unpacking-a-packed-binary: Manually unpacks a runtime-packed Windows binary by finding the original entry point

measuring-section-entropy-to-detect-packing: Detects packing and encryption by measuring Shannon entropy across a binary''s

misc-ctf: Lab/CTF: misc challenges; jails, encodings, esolangs, VMs, DNS oddities, Linux puzzles, Unicode, QR/audio, multi-stage artifacts.

mutation-testing: Configures mewt or muton campaigns, analyzes surviving mutants, and investigates bugs exposed by testing gaps. Use when setting up mutation testing, reviewing campaign results, identifying equivalent mutants, or finding bugs from surviving mutations.

mythril: Auth/lab ref: symbolic-execution-based security analyzer for Solidity and EVM bytecode.

nikto: Auth/lab ref: open-source web server scanner checking for 6700+ known vulnerabilities, outdated software, misconfigurations, and dangerous CGI/default files.

objdump: Auth/lab ref: binutils inspection and disassembly tool for ELF and many other object formats.

offensive-basic-exploitation:

offensive-bug-identification:

offensive-crash-analysis:

offensive-dependency-confusion: Deep-dive offensive methodology for dependency confusion and namespace attacks across all major package ecosystems. Covers npm scope confusion exploiting the gap between public and private scoped packages and .npmrc misconfigurations where registry mappings fail to pin internal scopes exclusively. A

offensive-deserialization: Insecure deserialization exploitation across Java, PHP, .NET, Python, Node.js, and Ruby. Covers gadget chain construction with ysoserial/phpggc/ysoserial.net, ObjectInputStream and BinaryFormatter sink identification, pickle __reduce__ RCE, phar:// wrapper abuse, Jackson polymorphic typing, Json.NET

offensive-exploit-dev-course:

offensive-exploit-development:

offensive-fuzzing: Practical offensive fuzzing methodology covering target identification, fuzzer selection (AFL++, libFuzzer, Honggfuzz, Boofuzz, syzkaller), harness writing, corpus curation, mutation strategies, coverage measurement, and crash triage. Use when setting up or running fuzz campaigns against any target:

offensive-fuzzing-course:

offensive-lateral-movement: Comprehensive lateral movement tradecraft for authorized red team engagements covering credential-based movement (pass-the-hash, pass-the-ticket, overpass-the-hash), NTLM relay attacks (ntlmrelayx with PetitPotam, DFSCoerce, PrinterBug coercion), remote execution protocols (WMI, WinRM, DCOM, PsExec

offensive-mitigations:

offensive-persistence: Comprehensive persistence tradecraft for authorized red team engagements covering Windows and Linux mechanisms. Windows techniques include registry Run/RunOnce keys, scheduled tasks, WMI event subscriptions, DLL search order hijacking, COM object hijacking, Startup folder drops, service creation, Se

offensive-supply-chain: Comprehensive offensive methodology for software supply chain attacks covering the full kill chain from reconnaissance through exploitation. Addresses dependency confusion across npm, PyPI, and NuGet ecosystems where internal registry override allows an attacker to inject malicious packages that sha

offensive-toctou: Time-of-Check / Time-of-Use (TOCTOU) race condition exploitation methodology across binary, kernel, filesystem, web, and container layers. Covers symbolic-link races (open/access/stat split), file-descriptor races, fopen/realpath traversal races, /proc and procfs races, FUSE-backed slow-fs races to

offensive-vuln-classes:

one-gadget: Auth/lab ref: libc gadget finder for `execve`-style code execution opportunities under known register and stack constraints.

openvas: Auth/lab ref: OpenVAS / Greenbone Community Edition: broad network vulnerability scanner checking 90,000+ NVTs across hosts, services, and web apps.

oracle-verification-technique: Machine-oracle verification for security findings: promote a finding to VERIFIED only when a named oracle re-runs the exploit N/N against the live target AND a negative control fails on a safe surface, then package a portable proof capsule the client can replay. Use before reporting web/API/auth fin

oss-fuzz: Auth/lab ref: Google-hosted continuous fuzzing service for open-source projects. For long-running, scalable fuzz campaigns, sanitizer-backed triage, and continuous bug reporting with reproducible local workflows.

ossfuzz: Enrolls a project in OSS-Fuzz, Google's free continuous fuzzing service for open source, and drives it locally. Covers project.yaml, Dockerfile and build.sh setup, the helper scripts, reproducing OSS-Fuzz crash reports, and the acceptance criteria. Use when setting up continuous fuzzing for an open-

pacu: Auth/lab ref: modular AWS exploitation framework for authorized cloud assessments.

patch-diff-exploit: N-day 补丁差分到利用。从厂商发布的补丁里反推漏洞点、写 PoC、做成可用的攻击模块。 适用场景：已知 CVE 编号但只有补丁没有 PoC、SRC/红队需要打击未及时更新的资产、N-day 武器化、Patch Tuesday 跟进。 核心方法：拿 before/after 二进制 → 对齐符号 → 二进制 diff → 看新增的安全检查反推 bug class → 写 PoC 触发漏洞。 触发关键词：N-day、Nday、补丁差分、patch diff、patch tuesday、1day、binary diff 漏洞、bindiff 利用、ghidriff、Diaphora、补丁分析、C

patchelf: Auth/lab ref: ELF patching utility for changing interpreters, RPATH/RUNPATH, DT_NEEDED entries, and SONAME fields.

performing-active-directory-vulnerability-assessment: Assess Active Directory security posture using PingCastle, BloodHound,

performing-agentless-vulnerability-scanning: Configure and execute agentless vulnerability scanning using network

performing-api-fuzzing-with-restler: Uses Microsoft RESTler to perform stateful REST API fuzzing: compiles

performing-binary-exploitation-analysis: Analyze ELF binaries for memory-corruption vulnerabilities and build proof-of-concept

performing-blind-ssrf-exploitation: Detect and exploit blind Server-Side Request Forgery (SSRF) using out-of-band

performing-clickjacking-attack-test: Testing web applications for clickjacking vulnerabilities by assessing

performing-endpoint-vulnerability-remediation: Performs vulnerability remediation on endpoints by prioritizing CVEs

performing-fuzzing-with-aflplusplus: Performs coverage-guided fuzzing of compiled binaries with AFL++, instrumenting

performing-kerberoasting-attack: Perform Kerberoasting, a post-exploitation technique that enumerates

performing-ot-vulnerability-assessment-with-claroty: Perform OT vulnerability assessments using the Claroty xDome platform for asset discovery, risk scoring, and vulnerability correlation, combining passive traffic-based identification and active safe device querying with CVE/ICS-CERT advisory correlation for remediation prioritization. Use for schedu

performing-ot-vulnerability-scanning-safely: Perform vulnerability scanning in OT/ICS environments safely using passive

performing-security-headers-audit: Auditing HTTP security headers including CSP, HSTS, X-Frame-Options,

performing-service-account-audit: Audit service accounts across enterprise infrastructure to identify orphaned,

performing-soc2-type2-audit-preparation: Automates SOC 2 Type II audit preparation including gap assessment against

performing-static-malware-analysis-with-pe-studio: Performs static analysis of Windows PE malware samples using PEStudio to examine file headers, imports, strings, and resources without executing the binary, identifying packing, anti-analysis tricks, and malicious imports. Use for pre-execution triage of a suspicious Windows executable before sandbo

performing-static-pe-analysis: Extracts structure and indicators from a Windows PE file without executing it:

performing-supply-chain-attack-simulation: Simulates and detects software supply chain attacks: typosquatting detection via Levenshtein distance against popular PyPI package names, dependency confusion testing against private registries, SHA-256 package hash verification, and known-CVE scanning with pip-audit. Use when auditing a project's d

performing-thick-client-application-penetration-test: Conduct a thick client application penetration test to identify insecure

performing-threat-landscape-assessment-for-sector: Conducts a sector-specific threat landscape assessment (financial, healthcare, energy, government, etc.) by profiling targeting threat actors, mapping attack vectors and MITRE ATT&CK TTPs with the attackcti/pandas Python stack, and analyzing exploited CVEs and incident trends from ISAC and vendor re

performing-vulnerability-scanning-with-nessus: Performs authenticated and unauthenticated vulnerability scanning using

performing-web-application-vulnerability-triage: Triages web application vulnerability findings from DAST/SAST scanners

poc-weaponization: Review an existing public or generated proof-of-concept artifact for provenance, suspicious behavior, dependency risk, and reproducibility. Use when triaging or validating a PoC referenced by a CVE or received during a security assessment.

post-exploiting-microsoft-graph-with-graphrunner: Runs GraphRunner, a PowerShell post-exploitation toolset built on

post-exploit-technique: Auth assessment: post-compromise host methodology; shell state, local privesc triage, secret-exposure review, pivot planning, evidence.

post-patch-validation: Validates security patches with reproducible baseline-versus-patched evidence, including original exploits, root-cause variants, behavior preservation, regressions, and newly introduced security failures. Use after a patch exists and before accepting, merging, or reporting it as fixed; also use when

prepare-regression: Use when pinning before/after sources and collecting PR or commit context for a regression investigation.

prioritizing-vulnerabilities-with-cvss-scoring: The Common Vulnerability Scoring System (CVSS) is the industry standard

protocol-reverse: Use for authorized reverse engineering of custom binary protocols, Protobuf/gRPC, WebSocket frames, and PCAP-driven protocol recovery.

pwn-chain: 从逆向走到可用利用 (Working Exploit) 的全链路工程化方法。 适用场景：拿到了二进制 + 漏洞点 + 目标环境，需要写出一个能稳定打通的 exploit（不是只能本地复现一下、远程一打就崩的脚本）。 覆盖三大方向：栈溢出 / 堆利用 / 内核 pwn。强调"CTF 本地通 → 真实远程稳定打通"的工程差距：libc 版本错配、堆喷射时序、SMEP/SMAP/KASLR、栈对齐、远程缓冲。 核心工具链：pwntools + GEF/pwndbg + ROPgadget/Ropper + one_gadget + libc-database + qemu-system 内核调试。

pwn-ctf: Lab/CTF: pwn/binary challenges; native binaries, memory corruption, format strings, heap/ROP/SROP, shellcode artifacts, seccomp, kernel labs.

pwntools: Auth/lab ref: Python CTF/exploitation framework for interacting with remote services, local processes, and binary exploitation.

python-reverser-patterns: Reverse binaries and Python artifacts with Python: parse ELF/PE, disassemble with pwntools/capstone, instrument with Frida, recover .pyc and PyInstaller payloads. Use when analyzing malware, packed Python, stripped binaries, or runtime hooks — not for CPython language style (python-patterns).

qemu: Auth/lab ref: QEMU user-mode and full-system emulation for cross-arch binaries, firmware, kernels, disks, serial consoles, networking, and GDB stubs.

qiling: Auth/lab ref: Qiling OS-layer binary emulation for PE/ELF/Mach-O/UEFI/shellcode with rootfs, syscall/API hooks, filesystem mapping, and runtime patching.

radamsa: Auth/lab ref: General-purpose mutation engine for generating malformed test inputs.

radare2: Use this skill whenever the user wants to analyze binaries with radare2/r2 from the command line, including reverse engineering, disassembly, function analysis, strings/import inspection, patching, binary diffing, hex inspection, or r2 scripting. Also use it when the user mentions PE/ELF/Mach-O/DEX/

radare2: Auth/lab ref: CLI reverse engineering framework with disassembly, decompilation (r2ghidra/r2dec), debugging, ESIL emulation, scripting, and binary patching.

readelf: Auth/lab ref: ELF metadata inspection utility for headers, sections, program headers, symbols, notes, relocations, and dynamic entries.

readme-md-creator: Create, audit, or update a README for a repository, package, or document folder. Use when readers need accurate orientation, usage, or navigation.

recovering-injected-code-and-shellcode: Carves injected PE images and position-independent shellcode from a memory dump or

regression-hunt: Use when investigating regressions in PRs or commits, coordinating a regression campaign, or resuming saved progress.

renode: Auth/lab ref: Renode board and SoC simulation for MCU/RTOS firmware, UART/GPIO/peripheral modeling, GDB remote debugging, REPL platforms, and RESC scripts.

replay-regression: Use when independently verifying a supplied PoC against fresh live before/after deployments.

report-regressions: Use when assembling or refreshing an evidence-linked regression report from saved campaign decisions.

reproduce-bug: Use when a named runtime or compiler bug in a local repository needs independent reproduction.

reproduce-regression: Use when deploying before/after systems and building a live-system PoC for a regression candidate.

restler: Auth/lab ref: Stateful REST API fuzzer from OpenAPI specs. For testing complex API dependency chains, producer-consumer request sequencing, and replayable bug-bucket workflows for API reliability/security testing.

reverse-ctf: Lab/CTF: reverse challenges; compiled binaries, bytecode, mobile/firmware, custom VMs, packed samples, anti-debug, validators.

reverse-eng-binary-ninja: Reverse engineer in Binary Ninja — HLIL/MLIL/LLIL inspection, strings/imports/exports, cross-references, types, patching, Python API automation, and the optional MCP/HTTP bridge. Load when the user picks Binary Ninja, when its IL levels materially help data-flow analysis, or when IDA/Ghidra/radare2

reverse-eng-binary-triage: Triage a native binary you can run or read — find the vulnerable logic, the dangerous sinks, and the input path — with static + dynamic analysis. Load when handed an ELF/PE/Mach-O, a thick client, a standalone or obfuscated binary, or a service whose source you don't have. Signals: a compiled execut

reverse-eng-deobfuscation: Peel obfuscation off code until it's readable or callable — packed native binaries, minified/ obfuscated JavaScript, WebAssembly, and JS-VM-protected (JSVMP) bundles. Load when analysis is blocked by protection layers. Signals: high-entropy sections, a tiny import table, UPX headers, string-array/co

reverse-eng-dotnet: Reverse a .NET / C# assembly — decompile, deobfuscate, debug, and IL-patch managed binaries. Load when the target is a managed PE (.exe/.dll with a CLR header), a Sharp* red-team tool (Rubeus, SharpHound, Seatbelt), a ConfuserEx/SmartAssembly/Babel/.NET-Reactor-obfuscated sample, or a .NET loader/st

reverse-eng-ghidra: Reverse engineer with Ghidra (GUI, headless, or ghidra-mcp) — decompile, cross-references, scripting — when there's no IDA license, for batch/CI decompilation, or as a free second opinion. Load for "decompile without IDA", bulk analysis of many samples, analyzeHeadless, Ghidra scripts (Jython/PyGhid

reverse-eng-go-rust: Reverse stripped Go and Rust binaries — recover symbols from pclntab/moduledata and panic metadata, then navigate language-specific idioms. Load when a stripped ELF/PE/Mach-O shows Go or Rust runtime residue. Signals: "go.buildid", "runtime.main" / "main.main", "panic:" or "rust_begin_unwind" string

reverse-eng-ida: Deep reverse engineering in IDA Pro — Hex-Rays decompile, cross-references, types, patching — via the GUI or the ida-pro-mcp bridge for agent-driven analysis. Load when a PE/ELF/Mach-O/DLL/SYS needs pseudocode-grade analysis: license/serial checks, crypto or protocol recovery, a sink found during tr

reverse-engineer-anything: Reverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runt

reverse-engineering: Provides reverse engineering techniques. Use when the main job is to understand how a compiled, obfuscated, packed, or virtualized target works before exploiting or solving it, including binaries, APKs, WASM, firmware, custom VMs, bytecode, malware-like loaders, and anti-debug or anti-analysis logic

reverse-engineering: Safely analyze, disassemble, decompile, or debug unknown binaries, executables, DLLs, malware, firmware, and packed or obfuscated code. Use for reverse engineering, suspicious-file triage, unpacking, Ghidra/IDA/radare2/x64dbg/GDB help, IOC extraction, YARA, or questions about what a binary does.

reverse-engineering: Read how a game actually works so a mod can hook it. Decompile .NET/Mono (ILSpy), IL2CPP (Cpp2IL, Il2CppDumper), Java (Vineflower) and native code (Ghidra, IDA, via MCP servers); dump data and asset formats; reverse-engineer a binary file format and prove it with a round trip; read live memory (Chea

reverse-engineering: Reverse engineer compiled software and app internals for authorized security research, CTFs, malware analysis, interoperability, and debugging. Use whenever the user wants to understand, decompile, disassemble, unpack, or trace an artifact they own or may study: native binaries (ELF/PE/Mach-O, .so/.

reverse-engineering-arm-binaries: Reverse engineers ARM/AArch64 malware by identifying the architecture and instruction

reverse-engineering-binaries-with-binary-ninja: Reverse engineers binaries with Binary Ninja using its analysis stack and Python API

reverse-engineering-binaries-with-ghidra: Uses Ghidra to disassemble and decompile a binary, navigate to key routines via

reverse-engineering-binaries-with-radare2-rizin: Reverse engineers binaries using radare2/rizin interactively, covering analysis

reverse-engineering-custom-c2-protocols: Reverses proprietary command-and-control protocols: locating send/recv routines,

reverse-engineering-dotnet-malware-with-dnspy: Reverse engineers .NET malware samples using the dnSpy decompiler and

reverse-engineering-malware-with-ghidra: Reverse engineers malware binaries using NSA''s Ghidra disassembler and

reverse-engineering-nim-and-other-exotic-binaries: Reverse engineers malware written in less-common compiled languages (Nim, Crystal,

reverse-engineering-rust-malware: Reverse engineers Rust-compiled malware using IDA Pro and Ghidra, covering

reverse-engineering-shellcode: Analyzes position-independent shellcode: disassembling raw bytes at the right

reverse-eng-js: Reverse front-end JavaScript end to end: trace which script fires a given request, capture a signing/encryption function's real inputs at runtime, then rebuild the algorithm locally in Node.js with evidence-driven environment shims until it reproduces the target parameter. Load when you need the *me

reverse-eng-macos: Reverse macOS Mach-O binaries and .app bundles — codesign/notarization state, entitlements, Objective-C/Swift symbol recovery, and lldb/Frida dynamic analysis. Load when the target is a Mach-O executable/dylib/framework, an .app bundle, a LaunchAgent/Daemon plist, or Apple-platform malware. Signals:

reverse-eng-patch-diff: Turn a vendor security patch into a working N-day: diff the patched and unpatched binaries, read the newly added safety checks back to a bug class, then write a PoC that crashes the unpatched build. Load for a CVE with a patch but no public PoC, Patch Tuesday triage (ntoskrnl / win32k / afd.sys / cl

reverse-eng-protocol: Reverse a custom network protocol from captured traffic or the client binary: recover the frame layout, message-type dictionary, field meanings, and state machine. Load for custom TCP/UDP binary protocols, Protobuf/gRPC without reflection, FlatBuffers/MessagePack, WebSocket/MQTT/private RPC framing,

reverse-eng-radare2: Command-line binary analysis with radare2/r2 — recon, disassembly, strings/imports, cross-references, patching, diffing, and scripting, no GUI needed. Load for exe/dll/so/elf/dex/wasm CLI analysis, quick triage before committing to IDA/Ghidra, r2 batch commands (-c/-A), r2pipe scripts, or help with

reverse-eng-thick-client: Security-test a desktop thick client end to end: map its trust boundaries, then work the local attack surface (config files, credential storage, IPC, update channel) and the network surface (proxying, certificate pinning, hidden APIs). Load for a C/S desktop app in scope — Electron, Qt, .NET WinForm

reverse-skill-router: Routes reverse engineering, exploitation, penetration testing, malware, mobile, firmware, browser automation, documentation, and security tasks to the appropriate specialist skill. Use when a task spans modules or the correct reverse-skill entrypoint is unclear.

reverse-ssh: Auth/lab ref: Establish reverse SSH tunnels from victim to attacker for interactive shell access behind NAT/firewall.

reversing-technique: Auth/lab: reverse engineering methodology; malware triage, patch diffing, firmware/protocol RE, OS/runtime behavior verification, protections, exploitability handoff evidence.

review-pr: Reviews the current branch's changes against its base branch as a pull request: correctness of new and modified code, test coverage for it, and documentation accuracy. Use when asked to review a branch, a diff, or a pull request.

revshellgen: Auth/lab ref: Interactive Python reverse-shell generator with auto listener setup, encoding support, and shell-type selection.

rop-development-dev: Auth/lab dev: ROP chain research; gadget quality, calling conventions, pivots, leak-first ASLR labs, NX/DEP modeling, reliability.

ropgadget: Auth/lab ref: gadget discovery utility for ELF, PE, Mach-O, and raw binaries.

run-validation-until-no-failure: Use when the user wants to run the IDA validation pipeline (`uv run ida_analyze_bin.py -debug`) repeatedly until it reports zero failures. For each failing skill, diagnose the failure, ask the user how to proceed, and offer several viable solutions. Only when the user explicitly says the failure can

run-vcall-finder: Run this repository's ad hoc vcall_finder workflow for explicitly selected CS2 modules and one or more symbol names. Use when asked to temporarily find virtual calls for named symbols without registering them in a versioned analysis config.

rust-performance: Rust performance workflow: benchmark and profile first, identify hotspots, reduce allocations and contention, improve data layout, tune release profiles, and verify gains with repeatable evidence. Use only after you have a real Rust performance symptom, regression, or hotspot in `.rs` code.

rust-testing: Rust testing patterns for unit, integration, async, doc, property, snapshot, fuzz, and benchmark-adjacent tests. Use when writing or reviewing tests for `.rs` code, reducing flakiness, designing fixtures/fakes, improving CI confidence, hardening `unsafe`/FFI/parsers with Miri and sanitizers, or test

ruzzy: Sets up and runs Ruzzy, Trail of Bits' coverage-guided Ruby fuzzer and the only production-ready one for the language. Covers harness structure, fuzzing pure Ruby and the native C extensions in gems, and sanitizer builds. Use when fuzzing a Ruby library or gem, testing a Ruby C extension for memory

satellite-ctf: Lab/CTF: satellite and space-system challenges; CCSDS Space Packets, TC/TM/AOS/USLP Space Data Link transfer frames, CLTU/BCH/Reed-Solomon coding, COP-1/FARM sequence control, ECSS PUS services, SDLS/SDLS-EP link-layer crypto and CryptoLib CVEs, CubeSat Space Protocol (CSP), TLE/SGP4 orbits, GPS L1

scanning-infrastructure-with-nessus: Tenable Nessus is the industry-leading vulnerability scanner used to

scripting-ghidra-headless-analysis: Automates batch reverse engineering by generating Ghidra analyzeHeadless commands and

scripting-ida-with-idapython: Automates IDA Pro analysis with IDAPython by generating scripts that enumerate

searchsploit: Auth/lab ref: Offline CLI search tool for Exploit-DB.

seccomp-tools: Auth/lab ref: seccomp BPF inspection toolkit for dumping, disassembling, assembling, and emulating Linux syscall filters.

secure-workflow-guide: Guides through Trail of Bits' 5-step secure development workflow. Runs Slither scans, checks special features (upgradeability/ERC conformance/token integration), generates visual security diagrams, helps document security properties for fuzzing/verification, and reviews manual security areas. Use wh

securing-historian-server-in-ot-environment: Audits and hardens process historian servers (OSIsoft PI, Honeywell PHD,

semgrep: Auth/lab ref: fast static analysis tool for finding security vulnerabilities, misconfigurations, and secrets in source code.

shellerator: Auth/lab ref: CLI reverse/bind-shell lab generator supporting 20+ languages with optional encoding.

smali-dex-patching: Auth/lab dev: patch shipped Android APKs at the DEX/smali level — bypass root/emulator checks, disable SSL pinning, strip license verification, inject logging, or alter arbitrary managed-code logic. Covers apktool decompile/rebuild, smali syntax, common patch patterns (return-void, const/4 v0 + retu

software-guidelines: Implement and review scoped code changes in a repository. Use for patch impact, dependent caller updates, repository conventions, and preserving unrelated work; use software-architecture for structural design and simplification decisions.

solving-malware-with-symbolic-execution: Uses symbolic execution (angr) to solve constraint-based malware problems — finding

sstimap: Auth/lab ref: actively maintained SSTI detection and exploitation tool with interactive and predetermined modes across Jinja2, Twig, Smarty, Freemarker, Velocity, ERB, Pug, Nunjucks, and more.

stack-exploitation-dev: Auth/lab dev: stack exploitability research; frame layout, canaries, ret2libc/ROP/SROP/JOP paths, mitigations, data-only outcomes.

state-snapshot: Capture a full debuggee state snapshot (all committed memory regions + processor state) to disk for offline analysis

strace: Auth/lab ref: Linux syscall tracer for observing file, process, network, memory, and signal behavior at runtime.

strings: Auth/lab ref: printable-string extractor for binaries, libraries, firmware blobs, and files of unknown type.

systematic-debugging: Root-cause-first debugging workflow for software, exploit tooling, fuzzing harnesses, reverse-engineering helpers, C2/client code, flaky tests, crashes, races, and environment-specific failures. Use when a failure is not immediately obvious or when repeated quick fixes risk hiding the real defect.

technique-ctf: Lab/CTF: general challenge-solving methodology across every category; artifact triage, spec/protocol identification, oracle-driven iteration from target error messages, minimal-matrix brute forcing, harness building with pwntools, parallelizing independent challenges/variants with subagents, and saf

test-driven-development: Develop behavior through a failing test or reproducer, implementation, and refactoring. Use when test-first development is requested or a new behavior or bug fix benefits from an executable regression before implementation.

testing-for-business-logic-vulnerabilities: Manually identifies flaws in application business logic - price manipulation,

testing-for-json-web-token-vulnerabilities: Tests JWT implementations for algorithm confusion, "none" algorithm bypass,

testing-for-open-redirect-vulnerabilities: Identifies and exploits open redirect vulnerabilities by analyzing URL

testing-for-xss-vulnerabilities-with-burpsuite: Identifying and validating cross-site scripting vulnerabilities using

testing-for-xxe-injection-vulnerabilities: Discovering and exploiting XML External Entity injection vulnerabilities

thick-client: Use for authorized security testing of desktop thick clients including local storage, update channels, IPC, traffic, and client-side trust boundaries.

trailmark: Builds and queries multi-language source and binary code graphs for security analysis. Includes pre-analysis passes for blast radius, taint propagation, privilege boundaries, entry point enumeration, proxy/unresolved-call tracking, type/reference queries, structural traversal, graph diffs, audit aug

triaging-vulnerabilities-with-ssvc-framework: Triages and prioritizes vulnerabilities with CISA's Stakeholder-Specific

unicorn: Auth/lab ref: Unicorn Engine CPU-only emulation for shellcode, decryptors, custom VM handlers, instruction tracing, memory hooks, and register-level experiments.

upx: Auth/lab ref: executable packer and unpacker for PE, ELF, Mach-O, and several embedded formats.

vector-forge: Mutation-driven test vector generation. Finds implementations of a cryptographic algorithm or protocol, runs mutation testing to identify escaped mutants, then generates new test vectors that deliberately exercise the uncovered code paths. Compares before/after mutation kill rates to prove vector ef

vuln-exploit-technique: Auth/lab: exploitability validation methodology; CVE/PoC triage, local repro, reliability checks, framework/tool routing, evidence handoff.

vuln-hunter: Hunt for vulnerabilities in a running debuggee by analyzing imports/exports, triaging attack surface, and iteratively testing for bugs with PoC generation.

vuln-research: Discover and validate vulnerabilities in applications, services, source code, binaries, and firmware. Use for assessment coverage and scanner-finding validation, bug-bounty investigations, patch-diff and variant analysis, and reproducible security findings.

wfuzz: Auth/lab ref: Classic web application fuzzer using FUZZ placeholders across URL, headers, forms, auth, and request components.

winafl: Auth/lab ref: Coverage-guided fuzzing framework for Windows binaries. For fuzzing desktop apps, DLL harnesses, or Windows services with DynamoRIO/TinyInst/Intel PT instrumentation and persistent-loop target functions.

windbg: Auth/lab ref: Microsoft's debugger for user-mode and kernel-mode Windows debugging, crash dump analysis, driver reversing, and rootkit analysis.

wpscan: Auth/lab ref: WordPress vulnerability and enumeration scanner.

write-func-as-yaml: Write function analysis results as YAML file beside the binary using IDA Pro MCP. Use this skill after completing function identification and signature generation to persist the results in a standardized YAML format. For virtual functions with known vtable index, use write-vfunc-as-yaml instead.

write-globalvar-as-yaml: Write global variable analysis results as YAML file beside the binary using IDA Pro MCP. Use this skill after completing global variable identification and signature generation to persist the results in a standardized YAML format.

write-patch-as-yaml: Write patch analysis results, including patch_sig match VA/RVA, as a YAML file beside the binary using IDA Pro MCP. Use this skill after identifying a patch target and generating a unique signature to persist patch_name, patch_va, patch_rva, patch_sig, optional patch_sig_disp, and patch_bytes in a s

write-structoffset-as-yaml: Write struct member offset analysis results as YAML file beside the binary using IDA Pro MCP. Use this skill after identifying a struct member offset and optionally generating a signature for it to persist the results in a standardized YAML format.

writeup-ctf: Lab/CTF: reproducible writeups; solved notes, command logs, artifacts, proof output, solver scripts, final reports, evidence checks.

write-vfunc-as-yaml: Write virtual function analysis results as YAML file beside the binary using IDA Pro MCP. Use this skill after completing virtual function identification, signature generation, and vtable analysis to persist the results in a standardized YAML format.

write-vtable-as-yaml: Write vtable analysis results as YAML file beside the binary using IDA Pro MCP. Use this skill after locating a vtable to persist the results in a standardized YAML format.

x64dbg: Auth/lab ref: User-mode debugger for Windows x64/x86 with plugin ecosystem for malware analysis, unpacking, API tracing, and anti-anti-debug.

Canonical: https://notholy.com/it/skills/category/reverse-engineering
