Skip to content
Back to search

secskills-marketplace

MarketplaceWorks with Claude CodeGitHub

Transform Claude Code into your personal security engineer

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/trilwu--secskills/badge.svg)](/listings/trilwu--secskills)

HTML

<a href="/listings/trilwu--secskills"><img src="/api/listings/trilwu--secskills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 85 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "secskills-marketplace",
  3. "owner": {
  4. "name": "trilwu",
  5. "url": "https://github.com/trilwu"
  6. },
  7. "metadata": {
  8. "description": "Marketplace for SecSkills - offensive and defensive security skills for Claude Code, split into offense, defense, and a shared core plugin",
  9. "version": "4.11.0"
  10. },
  11. "plugins": [
  12. {
  13. "name": "secskills-offense",
  14. "source": "./secskills-offense",
  15. "description": "Attacker tradecraft with the judgment, not just the commands. 40 offensive security skills for red teams and pentesters: web/API/auth exploitation (JWT, OAuth/OIDC, SAML, XXE, SSRF, deserialization, GraphQL, gRPC), Active Directory and Entra ID, AD CS ESC1-16, Kerberos delegation, Linux/Windows privilege escalation, cloud, managed Kubernetes, serverless, CI/CD, containers, mobile, wireless, Bluetooth/NFC, ICS/OT, Web3, reconnaissance, social engineering, persistence, and password cracking — plus deception-spotting and multi-day engagement discipline. Every skill fact-checked against primary sources. Pairs with secskills-core.",
  16. "version": "4.6.0",
  17. "category": "security",
  18. "keywords": [
  19. "security",
  20. "appsec",
  21. "penetration-testing",
  22. "red-team",
  23. "vulnerability-research",
  24. "active-directory",
  25. "cloud-security",
  26. "web-security",
  27. "mobile-security",
  28. "ctf"
  29. ],
  30. "license": "MIT",
  31. "homepage": "https://github.com/trilwu/secskills",
  32. "author": {
  33. "name": "trilwu",
  34. "url": "https://github.com/trilwu"
  35. }
  36. },
  37. {
  38. "name": "secskills-defense",
  39. "source": "./secskills-defense",
  40. "description": "DFIR and detection built on preserve-first, base-rate discipline. 22 defensive security skills for SOC analysts, incident responders, and detection engineers: alert triage, malware and shellcode analysis, memory/disk/network forensics, phishing-email analysis, Windows endpoint DFIR, Linux persistence hunting, AWS/Azure/GCP/M365-Entra incident investigation, Kubernetes defense, cloud posture hardening, threat hunting, detection-as-code (Sigma/YARA/Suricata) with real false-positive analysis, risk-based vulnerability management, and threat intelligence. Every skill fact-checked against primary sources. Pairs with secskills-core.",
  41. "version": "4.3.0",
  42. "category": "security",
  43. "keywords": [
  44. "security",
  45. "blue-team",
  46. "dfir",
  47. "incident-response",
  48. "threat-hunting",
  49. "detection-engineering",
  50. "malware-analysis",
  51. "forensics",
  52. "threat-intelligence"
  53. ],
  54. "license": "MIT",
  55. "homepage": "https://github.com/trilwu/secskills",
  56. "author": {
  57. "name": "trilwu",
  58. "url": "https://github.com/trilwu"
  59. }
  60. },
  61. {
  62. "name": "secskills-core",
  63. "source": "./secskills-core",
  64. "description": "The reverse-engineering and code-audit foundation both sides share. 30 dual-use security skills: native and Go/Rust/.NET/iOS/firmware reverse engineering, packers, and Flutter/React Native/Unity/Xamarin runtimes; source-code auditing with PHP-specific depth; webshell and backdoor hunting; multi-agent vulnerability-research orchestration; supply-chain, cryptography, MCP, and pull-request review; vetting third-party agent skills and MCP servers; AI/LLM security; ATT&CK technique mapping; engagement-state discipline; and findings reporting. Ships the ttp-index.json ATT&CK map. Every skill fact-checked against primary sources.",
  65. "version": "4.11.0",
  66. "category": "security",
  67. "keywords": [
  68. "security",
  69. "reverse-engineering",
  70. "code-audit",
  71. "cryptography",
  72. "ai-security",
  73. "supply-chain",
  74. "attack-mapping",
  75. "ctf"
  76. ],
  77. "license": "MIT",
  78. "homepage": "https://github.com/trilwu/secskills",
  79. "author": {
  80. "name": "trilwu",
  81. "url": "https://github.com/trilwu"
  82. }
  83. }
  84. ]
  85. }
README.md · README · 478 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # SecSkills
  2. **Security skills for [Claude Code](https://claude.com/claude-code) that encode
  3. the *judgment* professionals bring, not another wrapper around a scanner.**
  4. Offense, defense, and the reverse-engineering and code-audit core both sides
  5. share. Every skill is fact-checked against primary sources.
  6. Claude already knows what `nmap -sV` does. What it does not reliably hold is the
  7. discipline: trace a finding to demonstrated impact before you report it,
  8. capture memory before someone reimages the box, refuse to ship a detection that
  9. was never tested against production noise, notice the honeypot before you touch
  10. it. SecSkills is that discipline, written down and routed to the moment it
  11. applies.
  12. Three plugins in one marketplace. Install only the side you work:
  13. | Plugin | For |
  14. | --- | --- |
  15. | **`secskills-offense`** | Red team, pentest, offensive AppSec |
  16. | **`secskills-defense`** | DFIR, SOC, detection engineering, threat intel |
  17. | **`secskills-core`** | Reverse engineering, code/crypto audit, AI/MCP security, reporting; shared by both |
  18. ```bash
  19. /plugin marketplace add trilwu/secskills
  20. # Offensive — red team / pentest / offensive AppSec
  21. /plugin install secskills-offense@secskills-marketplace
  22. /plugin install secskills-core@secskills-marketplace
  23. # Defensive — DFIR / SOC / detection
  24. /plugin install secskills-defense@secskills-marketplace
  25. /plugin install secskills-core@secskills-marketplace
  26. /reload-plugins
  27. ```
  28. Skills reference their siblings by name across plugins. A hand-off to a skill
  29. you did not install is an inert mention, so nothing breaks. You get the skills
  30. you have.
  31. ---
  32. ## Who it's for
  33. SecSkills is built for four working roles. Each gets a coherent toolkit, not a
  34. grab-bag.
  35. ### 🔴 Red team / pentest → `offense` + `core`
  36. Full attack-chain methodology with the tradecraft judgment that separates a
  37. finding from a footgun: recon and enumeration, Active Directory and Entra ID
  38. (Kerberos delegation, AD CS ESC1-16, DCSync), cloud and managed Kubernetes,
  39. container escapes, mobile, wireless, and web/API/auth exploitation. Plus the
  40. engagement discipline most collections skip: **`recognizing-deception`**
  41. (spot the honeypot/canary before you trip it), **`maintaining-engagement-state`**
  42. (credential provenance and the cleanup register that survives a context
  43. window), and **`reporting-security-findings`**.
  44. ### 🛡️ AppSec / code review → `core` (+ `offense` to prove impact)
  45. Source-audit methodology with a four-question verification gate, PR review that
  46. reads the lines a change *removed*, cryptography-misuse review, supply-chain and
  47. CI/CD auditing, and AI/LLM + MCP security. Language-agnostic by default, with
  48. **`auditing-php-applications`** for PHP's specific footguns (unserialize/`phar://`
  49. POP chains, type-juggling auth bypass, `php://` wrappers) and
  50. **`hunting-web-backdoors`** for planted webshells. Reach into `offense` when you
  51. need to demonstrate the bug, not just describe it. And when the target is big
  52. enough to warrant a campaign, **`orchestrating-vulnerability-research`** runs the
  53. hunt as an adversarial loop: builders hunt each slice, an independent critic
  54. tries to *refute* every candidate against the running target, and nothing counts
  55. until it is proven, not plausible.
  56. ### 🔵 DFIR / incident response → `defense` + `core`
  57. Preserve-first response: memory/disk/network forensics, malware and shellcode
  58. analysis, Windows endpoint DFIR, Linux persistence hunting, and cross-cloud
  59. incident investigation for **AWS, Azure, GCP, and M365/Entra**. Each is built
  60. around the audit-log defaults that decide whether a question is even
  61. answerable. Backed by the RE core (native, Go/Rust/.NET, iOS, firmware,
  62. packers).
  63. ### 🟣 SOC / detection engineering → `defense` + `core`
  64. The high-volume work, done with base-rate discipline:
  65. **`triaging-security-alerts`** (the true / benign-true / false-positive
  66. distinction that keeps a detection program alive), detection-as-code across
  67. Sigma/YARA/Suricata with *real* false-positive analysis, hypothesis-driven
  68. threat hunting, risk-based vulnerability management (KEV + EPSS, not raw CVSS),
  69. and finished threat intelligence with attribution discipline.
  70. Cloud and Kubernetes are covered from **both** sides: `exploiting-cloud-platforms`
  71. / `attacking-eks-gke-aks` for red, `hardening-cloud-posture` / `defending-kubernetes`
  72. / `investigating-*-incidents` for blue, so purple-team work stays in one
  73. vocabulary.
  74. ## What makes a skill
  75. Each skill is a methodology, not a command dump, with three things a cheat
  76. sheet does not give you:
  77. - **An explicit scope and hand-off.** Every skill says when to use a *different*
  78. one, named in backticks. That is how the skills compose instead of colliding.
  79. - **A `Rationalizations to Reject` section:** the plausible-sounding shortcuts
  80. that cause missed findings and bad calls, each with why it is wrong. This is
  81. the highest-value part of most skills; it is the judgment a command list
  82. cannot carry.
  83. - **Two tiers that stay out of your way.** *Domain* skills carry methodology for
  84. a whole area and trigger on plain-language requests. *Procedure* skills cover
  85. one exact target-and-toolchain that is rare and unrecoverable from general
  86. knowledge (reversing a Flutter app with blutter, say), and load only when
  87. their identifying evidence is present. Neither costs context until it applies.
  88. ## Every skill is fact-checked, and dated
  89. **Every skill has been verified line-by-line against primary sources** (vendor
  90. docs, RFCs, tool source) and carries a `verified:` date in frontmatter. That is
  91. the whole point: the opposite of confidently-wrong AI output.
  92. ```bash
  93. python3 scripts/validate.py --strict # "Fact-checked ...: 92/92"
  94. grep -L "^verified:" secskills-*/skills/*/SKILL.md # unverified skills (none)
  95. ```
  96. What that pass caught is why it exists. The first sampled dozen skills held
  97. **31 factual errors, about 2.6 per skill**, so the whole collection was driven
  98. through the same pass. Cross-cutting sweeps then found the high-impact ones:
  99. CrackMapExec archived since 2023 (14 dead invocations → NetExec/`nxc`), the
  100. retired AzureAD PowerShell module (→ Microsoft Graph), Volatility's entry point
  101. wrong in ~40 commands (`vol`, not `volatility3`), a fabricated Sigma `utf8`
  102. modifier, and stale M365 audit-log retention that would read an empty 90-day
  103. window as "no activity" when six months of history existed.
  104. Two honest caveats:
  105. - **`verified:` is dated, not eternal.** Tool flags, CVE version bounds,
  106. retention windows, and API paths drift. Trust the methodology (the
  107. sequencing, the scope, the *Rationalizations to Reject*) and re-confirm any
  108. specific before it lands in a deliverable. The re-verification method is
  109. itself a skill: `.claude/skills/verifying-skill-accuracy`.
  110. - **CI checks form, not truth.** `validate.py`, `sync_attack.py`, and
  111. `run_evals.py` verify structure, the ATT&CK index, and routing against
  112. self-authored cases. A green run means well-formed; the `verified:` dates are
  113. the accuracy signal.
  114. ## Skills
  115. ### Code and application security
  116. | Skill | Use it for |
  117. | --- | --- |
  118. | `auditing-code-for-vulnerabilities` | Full source audit: context → attack surface → bug-class hunt → variant analysis, with a four-question verification gate |
  119. | `orchestrating-vulnerability-research` | Run a discovery campaign across a codebase, binary, or live target: split the surface into slices, hunt each with a builder agent, and have a separate critic refute every candidate against the running artifact before it counts |
  120. | `auditing-php-applications` | PHP-specific bugs: unserialize/`phar://` POP chains, type juggling, `php://` wrappers, superglobal trust, WordPress/Magento/Laravel |
  121. | `hunting-web-backdoors` | Sweep a web tree for planted webshells: static deobfuscation, append-infections, known shell families as leads |
  122. | `reviewing-code-changes` | Security review of a diff, branch, or PR, including the lines the change *removed* |
  123. | `testing-web-applications` | Black-box web testing: injection, auth, JWT, SSRF, uploads |
  124. | `testing-apis` | REST and GraphQL: BOLA, mass assignment, rate limits |
  125. | `reviewing-cryptography` | Crypto misuse: AEAD, nonces, key management, timing, TLS, JWT |
  126. | `auditing-supply-chain` | Dependencies, malicious packages, GitHub Actions, SBOM, provenance |
  127. | `auditing-mcp-servers` | Reviewing an MCP server: tool-definition injection, token passthrough, per-tool authorization |
  128. | `vetting-agent-extensions` | Deciding whether a third-party skill, plugin, or MCP server is safe to install: context-loaded content as injection surface, config that runs on startup, trust verdict |
  129. | `securing-ai-systems` | LLM and agentic security: prompt injection, tool authority, RAG isolation, the lethal trifecta |
  130. | `exploiting-web3-smart-contracts` | Solidity and smart contract auditing |
  131. ### Defense, detection, and response
  132. | Skill | Use it for |
  133. | --- | --- |
  134. | `triaging-security-alerts` | Work an alert queue to a defensible disposition: true / benign-true / false-positive, base rates, time-boxing |
  135. | `responding-to-incidents` | DFIR: evidence preservation, artifact analysis, timelining, scoping, containment |
  136. | `analyzing-malware` | Containment-first sample analysis, config and C2 extraction, IOC and YARA output |
  137. | `engineering-detections` | Sigma/YARA/Suricata authoring with real false-positive analysis |
  138. | `hunting-threats` | Hypothesis-driven hunting with stack counting and outlier analysis |
  139. | `managing-vulnerabilities` | Risk-based remediation order: KEV + EPSS + reachability + asset value, SSVC, not raw CVSS |
  140. | `producing-threat-intelligence` | Indicator pivoting, actor/campaign tracking, attribution discipline, finished intel products |
  141. | `reporting-security-findings` | Severity, proof of concept, report structure, disclosure |
  142. ### Offensive operations
  143. | Skill | Use it for |
  144. | --- | --- |
  145. | `recognizing-deception` | Spot honeypots, canary tokens, and decoy accounts before you trip them |
  146. | `maintaining-engagement-state` | Credential provenance, access inventory, and the cleanup register across a multi-day engagement |
  147. | `performing-reconnaissance` | OSINT, subdomain enumeration, attack surface mapping |
  148. | `enumerating-network-services` | Service enumeration and exploitation |
  149. | `attacking-active-directory` | Kerberoasting, BloodHound, DCSync, lateral movement |
  150. | `escalating-linux-privileges` | SUID, capabilities, sudo, cron, kernel |
  151. | `escalating-windows-privileges` | Services, DLL hijacking, tokens, potato attacks |
  152. | `exploiting-containers` | Docker and Kubernetes escapes and misconfiguration |
  153. | `exploiting-cloud-platforms` | AWS, Azure, GCP enumeration and abuse |
  154. | `testing-mobile-applications` | Android and iOS assessment |
  155. | `attacking-wireless-networks` | Wi-Fi attacks and capture |
  156. | `cracking-passwords` | Hash identification and offline cracking |
  157. | `establishing-persistence` | Post-exploitation persistence |
  158. | `transferring-files` | File transfer and exfiltration channels |
  159. | `performing-social-engineering` | Authorized phishing and pretexting |
  160. | `exploiting-memory-corruption` | Turn a crash into a working exploit: ROP, heap grooming, defeating ASLR/NX/canary/RELRO |
  161. | `testing-thick-clients` | Desktop fat-client testing: non-HTTP proxying, config/memory secrets, client-side trust bypass, two-tier DB access |
  162. | `attacking-hardware-interfaces` | Physical device surface: UART/JTAG, SPI flash-off, secure-boot triage, sub-GHz SDR replay feasibility |
  163. ### Web and API procedure skills
  164. | Skill | Triggers on |
  165. | --- | --- |
  166. | `exploiting-ssrf` | Any feature that fetches a user-supplied URL; webhooks, importers, renderers |
  167. | `exploiting-deserialization` | `rO0AB`, `AAEAAAD`, `O:`, `gAJ` in a cookie or parameter |
  168. | `attacking-graphql` | `/graphql`, a `query`/`mutation` body, `{data, errors}` envelope |
  169. | `attacking-grpc-protobuf` | HTTP/2 with `application/grpc`, opaque binary bodies |
  170. | `attacking-jwt` | A token starting `eyJ` in a header, cookie, or body |
  171. | `attacking-oauth-oidc` | `/authorize`, `redirect_uri`, `state=`, "Sign in with X", OIDC discovery |
  172. | `attacking-saml` | `SAMLResponse`, `<saml:Assertion>`, `/saml/acs`, IdP federation |
  173. | `exploiting-xxe` | An endpoint parsing XML, SOAP, SVG, or Office (OOXML) files |
  174. ### Binary and runtime procedure skills
  175. `analyzing-binaries` is the native reverse-engineering domain skill (triage,
  176. disassembly with Ghidra/radare2/IDA, and instrumentation) that the language-
  177. and framework-specific procedures below hand back to.
  178. | Skill | Triggers on |
  179. | --- | --- |
  180. | `analyzing-binaries` | An unknown native executable: format triage, disassembly, dynamic instrumentation |
  181. | `analyzing-go-binaries` | `runtime.main`, `go:buildid`, a huge "stripped" binary |
  182. | `analyzing-rust-binaries` | `rustc version`, `core::panicking`, `_R`/`_ZN` symbols |
  183. | `analyzing-dotnet-assemblies` | Managed PE, mangled names, `Assembly.Load` loaders |
  184. | `analyzing-macos-binaries` | A `.app`/Mach-O on macOS: entitlements, XPC auth, dylib hijack, TCC |
  185. | `unpacking-protected-binaries` | High entropy, three imports, `UPX0`/`.vmp0` sections |
  186. | `devirtualizing-vm-protected-code` | A giant fetch-decode-dispatch loop: VMProtect/Themida/custom VM lifting |
  187. | `reversing-obfuscated-javascript` | A minified/obfuscated web bundle, `_0x` names, a reachable `.js.map` |
  188. | `reversing-browser-extensions` | A CRX/XPI: manifest permissions and the page↔content↔background trust boundary |
  189. | `reversing-network-protocols` | A proprietary binary protocol Wireshark shows as raw bytes |
  190. | `diffing-binary-patches` | Two versions of a DLL/ELF: find the fixed bug for 1-day analysis |
  191. ### Mobile procedure skills
  192. Narrow by design: each triggers on the artifacts or the symptom that
  193. identifies the situation, and hands back to the domain skill when done.
  194. | Skill | Triggers on |
  195. | --- | --- |
  196. | `bypassing-mobile-pinning` | TLS handshake alert, empty proxy, "network error" with the proxy on |
  197. | `bypassing-root-jailbreak-detection` | App exits on a rooted device, or dies when Frida attaches |
  198. | `analyzing-ios-binaries` | IPA with `cryptid 1`, Mach-O, `class-dump` returning nothing |
  199. | `testing-mobile-ipc` | Exported components, deep links, URL schemes, content providers |
  200. | `reversing-flutter-apps` | `libapp.so`, `libflutter.so`, `flutter_assets/` |
  201. | `reversing-react-native-apps` | `index.android.bundle`, `libhermes.so`, `main.jsbundle` |
  202. | `reversing-unity-il2cpp` | `global-metadata.dat`, `libil2cpp.so`, `Assembly-CSharp.dll` |
  203. | `reversing-xamarin-maui` | `libmonodroid.so`, `assemblies.blob`, `libxamarin-app.so` |
  204. ### Active Directory and identity procedure skills
  205. | Skill | Triggers on |
  206. | --- | --- |
  207. | `abusing-adcs` | A CA in the domain, `certipy find` flagging a template, ESC1-ESC16 |
  208. | `attacking-kerberos-delegation` | Unconstrained/constrained/RBCD delegation, `GenericWrite` over a computer |
  209. | `attacking-entra-id` | Entra ID / Azure AD as the target: tokens, PRTs, consent grants, hybrid sync |
  210. ### Cloud, container, and Kubernetes skills
  211. | Skill | Triggers on |
  212. | --- | --- |
  213. | `attacking-eks-gke-aks` | A managed Kubernetes cluster: pod-to-cloud IMDS, IRSA/Workload Identity, k8s RBAC |
  214. | `defending-kubernetes` | Hardening/monitoring a cluster: RBAC by capability, Pod Security Admission, audit logging |
  215. | `hardening-cloud-posture` | Proactive AWS/Azure/GCP posture: attack-path ranking, CSPM triage, org guardrails |
  216. | `attacking-serverless` | Lambda / Azure Functions / Cloud Functions / Workers; event injection, execution-role abuse |
  217. | `abusing-ci-cd-oidc` | GitHub Actions / GitLab CI / Jenkins, OIDC federation with broad trust policies |
  218. | `escaping-hardened-containers` | Seccomp on, capabilities dropped, `--privileged` absent, obvious escapes blocked |
  219. ### DFIR and detection procedure skills
  220. | Skill | Triggers on |
  221. | --- | --- |
  222. | `analyzing-memory-images` | A RAM capture to work with Volatility: injected code, in-memory creds |
  223. | `analyzing-disk-images` | An `.E01`/`.dd`/`.vmdk`: deleted-file recovery, carving, super-timeline |
  224. | `investigating-windows-endpoints` | A Windows host: EVTX/Sysmon, prefetch, amcache, `$MFT`/USN, persistence |
  225. | `investigating-m365-entra` | A cloud-only compromise: UAL, sign-in logs, OAuth consent grants, mailbox rules |
  226. | `investigating-aws-incidents` | Exposed AWS keys, anomalous CloudTrail, a GuardDuty finding, IAM persistence |
  227. | `investigating-azure-incidents` | Anomalous Azure Activity Log, a Defender for Cloud alert, service-principal abuse |
  228. | `investigating-gcp-incidents` | A leaked service-account key, GCP audit-log gaps, a Security Command Center finding |
  229. | `analyzing-network-traffic` | A `.pcap`/`.pcapng`: C2 beacons, DNS tunneling, JA3/TLS, exfil, file carving |
  230. | `analyzing-phishing-emails` | A reported `.eml`/`.msg`: headers, SPF/DKIM/DMARC, links, attachments |
  231. | `analyzing-shellcode` | A raw position-independent blob: decoder stubs, PEB-walk/API-hash, stagers |
  232. | `analyzing-linux-persistence` | Finding how an attacker persisted on a Linux host across every init path |
  233. | `writing-sigma-rules` | Authoring a portable Sigma rule: field taxonomy, modifiers, backend conversion |
  234. | `writing-yara-rules` | Authoring a durable YARA rule for a file/memory artifact or malware family |
  235. ### Specialist procedure skills
  236. | Skill | Triggers on |
  237. | --- | --- |
  238. | `testing-ics-ot-protocols` | Modbus/502, DNP3, S7comm/102, OPC UA, BACnet on a SCADA/OT network |
  239. | `analyzing-firmware-images` | A firmware update file or dump: `binwalk`, filesystem carving, cross-arch emulation |
  240. | `attacking-bluetooth-nfc` | BLE GATT enumeration, NFC/MIFARE card cloning, RF sniffing |
  241. ### Navigation
  242. | Skill | Use it for |
  243. | --- | --- |
  244. | `mapping-attack-techniques` | Resolving an ATT&CK ID, tactic, or intel report to the skill that holds the procedure; purple-team loop and coverage reporting |
  245. Techniques are indexed in [`secskills-core/ttp-index.json`](secskills-core/ttp-index.json)
  246. (143 mapped, spanning all three plugins), which generates the `## ATT&CK
  247. Coverage` section in each skill. CI fails if a section drifts from the index,
  248. and skills that use a different framework (ATLAS for AI, the Mobile matrix,
  249. CWE for code-level work) are declared as such rather than counted as coverage.
  250. ## In practice
  251. **Hunt a hacked site (DFIR / AppSec)**
  252. ```
  253. "This WordPress site is redirecting to spam and grep for eval comes back empty."
  254. ```
  255. Explains that an empty grep is not a clean tree (concatenation and callback
  256. sinks evade it), then diffs against a pristine copy, checks `functions.php` for
  257. append-infection, and decodes any obfuscation *statically*, never by running it.
  258. **Work an alert (SOC)**
  259. ```
  260. "EDR critical: a signed vendor binary opened an LSASS handle at 03:00, 47th time."
  261. ```
  262. Reads it as a likely *benign* true positive, warns against filing it as a false
  263. positive (which weakens a working rule), and sends an authorized-context filter
  264. to detection engineering instead.
  265. **Drive a domain (Red team)**
  266. ```
  267. "BloodHound flags svc_backup_admin: DA, SPN set, but no logon history. Roast it?"
  268. ```
  269. Flags the profile as a probable honeyuser whose Kerberoast raises a
  270. high-fidelity alert, and routes around it, recording provenance as it goes.
  271. **Investigate GCP (DFIR)**
  272. ```
  273. "A leaked service-account key was used. Did they read our storage buckets?"
  274. ```
  275. Answers with the audit-log defaults: GCP Data Access logging is off unless
  276. enabled in advance, so it reports a *visibility gap*, not "no exfiltration."
  277. **Assess an AI feature (AppSec)**
  278. ```
  279. "Review this RAG agent for prompt injection."
  280. ```
  281. Checks whether the lethal trifecta closes (private data, untrusted content, and
  282. egress in one agent) before any payload, and refuses prompt-level defenses as a
  283. control.
  284. **Run a discovery campaign (AppSec / Red team)**
  285. ```
  286. "Find previously-unknown bugs in this service. Fan out agents, and don't count anything you can't prove."
  287. ```
  288. Splits the attack surface into independent slices and hunts each with its own
  289. builder agent, then hands every candidate to a *separate* critic that tries to
  290. refute it against the running target: a reproduced trigger or a live response,
  291. never the hunter's own writeup. It kills the plausible-but-safe candidate (the
  292. `subprocess` call that looks injectable but passes an argv list, so nothing
  293. executes) and confirms the real ones, then reconciles across slices to surface
  294. the chain no single hunter could see.
  295. ## Where this fits
  296. SecSkills is domain expertise, not a scanner. It complements first-party tooling
  297. rather than replacing it:
  298. | Layer | Tool |
  299. | --- | --- |
  300. | While Claude writes code | [`security-guidance`](https://code.claude.com/docs/en/security-guidance) plugin |
  301. | One-pass branch review | Built-in `/security-review` |
  302. | Deep multi-agent scan | [`claude-security`](https://code.claude.com/docs/en/claude-security) plugin |
  303. | **Domain methodology and judgment** | **SecSkills** |
  304. | In CI | Your existing SAST and dependency scanners |
  305. The scanners find what they have rules for; the skills supply the reasoning
  306. around them.
  307. ## Requirements
  308. Claude Code, and the tools a given technique calls for (`nmap`, `semgrep`,
  309. `vol` (Volatility 3), `capa`, `ghidra`, …) installed separately. The plugin
  310. supplies knowledge and method, not binaries.
  311. ## Antivirus false positives
  312. Some skills document attacker artefacts verbatim: webshell one-liners,
  313. download cradles, persistence snippets. Antivirus engines match on file
  314. *content*, not extension, so a Markdown file quoting China Chopper looks the
  315. same to a signature scanner as a live `.php` webshell. Microsoft Defender has
  316. quarantined skill files under names like `Backdoor:PHP/Chopper.B!dha` and
  317. `Backdoor:PHP/Perhetshell.B!dha`.
  318. These are false positives. Nothing in this repo executes: the files are
  319. Markdown, there are no binaries, no packed or encoded payloads, and no
  320. installer. The detections were signature hits on documented indicators,
  321. including, at one point, on `hunting-web-backdoors`, a *defensive* skill
  322. flagged for containing the IOC it teaches you to hunt.
  323. Where a payload string was getting whole skills quarantined, the identifiers
  324. are now bracket-broken (`syst[e]m`, `ev[a]l`, `$_G[E]T`) with a note at each
  325. site. Detection regexes and hunting patterns are left intact, since breaking
  326. those would make the defensive skills wrong.
  327. If your scanner still quarantines a file, exclude the plugin path rather than
  328. disabling protection:
  329. ```powershell
  330. Add-MpPreference -ExclusionPath "$env:USERPROFILE\.claude\plugins"
  331. ```
  332. Please open an issue with the detection name and file path if you hit a new
  333. one. That's what pins down which string is responsible.
  334. ## Contributing
  335. See [CONTRIBUTING.md](CONTRIBUTING.md) for the authoring standard. Before
  336. opening a PR:
  337. ```bash
  338. python3 scripts/validate.py --strict # frontmatter, sections, manifests, verified count
  339. python3 scripts/sync_attack.py --check # ATT&CK sections match the index
  340. python3 scripts/run_evals.py --check # every skill has a trigger eval
  341. python3 scripts/build_site.py --check # the docs/ site is in sync
  342. ```
  343. CI runs the same checks. Every new skill ships with at least one
  344. trigger-accuracy case in [`evals/cases.jsonl`](evals/README.md): a realistic
  345. request labelled with the skill that should activate, plus a `trap_for` case
  346. where it sits near an existing skill, so routing stays correct as the collection
  347. grows. Two repo-local skills, `authoring-security-skills` and
  348. `verifying-skill-accuracy`, encode the standard and the fact-checking method.
  349. Contributions must serve authorized security work; no working malware, implants,
  350. or evasion tooling.
  351. ## Legal
  352. **For authorized use only.** Penetration testing with written permission,
  353. in-scope bug bounty work, research on systems you control, education and CTFs,
  354. and defensive operations.
  355. Not for unauthorized access, illegal activity, or violating terms of service.
  356. You are responsible for obtaining authorization and complying with applicable
  357. law. Provided as-is, without warranty; the authors accept no liability for
  358. misuse.
  359. ## Website
  360. A browsable site (role-based prompts, a searchable catalog, and a page per
  361. skill with its full methodology) is generated from this repo into
  362. [`docs/`](docs/) by `scripts/build_site.py` (stdlib only, no drift: CI fails if
  363. it is stale). Serve it with GitHub Pages → Settings → Pages → Source: `main`
  364. / `docs`.
  365. ## License
  366. MIT. See [LICENSE](LICENSE).
  367. ## Related work
  368. Worth knowing about, and in several cases worth installing alongside this:
  369. - [trailofbits/skills](https://github.com/trailofbits/skills): deep code-audit
  370. workflows, Semgrep/CodeQL rule authoring, verification, and secure contracts
  371. - [anthropics/claude-plugins-official](https://github.com/anthropics/claude-plugins-official):
  372. the `security-guidance` and `claude-security` plugins
  373. - [OWASP ASVS](https://owasp.org/www-project-application-security-verification-standard/),
  374. [MITRE ATT&CK](https://attack.mitre.org/),
  375. [Sigma](https://github.com/SigmaHQ/sigma),
  376. [Atomic Red Team](https://github.com/redcanaryco/atomic-red-team)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.