Skip to content
Back to search

cybersecurity-skills

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

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

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/briiirussell/cybersecurity-skills with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/briiirussell/cybersecurity-skills'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/briiirussell--cybersecurity-skills/badge.svg)](/listings/briiirussell--cybersecurity-skills)

HTML

<a href="/listings/briiirussell--cybersecurity-skills"><img src="/api/listings/briiirussell--cybersecurity-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option 1: `npx skills` (recommended)

The [vercel-labs/skills](https://github.com/vercel-labs/skills) installer reads the canonical `skills/` directory directly:

# List available skills
npx skills add briiirussell/cybersecurity-skills --list

# Install all skills
npx skills add briiirussell/cybersecurity-skills

# Install specific skills
npx skills add briiirussell/cybersecurity-skills --skill owasp-audit api-audit

Installs to your `.agents/skills/` directory with a symlink into `.claude/skills/` for Claude Code compatibility.

Option 2: Claude Code plugin marketplace

/plugin install cybersecurity-skills --marketplace briiirussell/cybersecurity-skills

That's one step on Claude Code 2.1.275 or later. On older versions, add the marketplace first:

/plugin marketplace add briiirussell/cybersecurity-skills
/plugin install cybersecurity-skills

The plugin also ships one subagent, `finding-verifier`. Audit skills hand it one candidate finding at a time, and it tries to disprove the finding in a fresh, read-only context. Cursor and Codex don't get the subagent; they follow the same steps from `verification.md`.

Option 3: Claude Code (project-level, manual)

git clone https://github.com/briiirussell/cybersecurity-skills.git
cp -r cybersecurity-skills/skills/owasp-audit .claude/skills/

Trigger naturally ("run an OWASP audit on this codebase") or invoke directly with `/owasp-audit`.

Option 4: Claude Code (personal, all projects)

cp -r cybersecurity-skills/skills/owasp-audit ~/.claude/skills/

Option 5: Cursor

cp adapters/cursor/owasp-audit.mdc .cursor/rules/

Option 6: Codex

cp adapters/codex/owasp-audit.md <your-codex-config-dir>/

Option 7: Git submodule (easy updates)

git submodule add https://github.com/briiirussell/cybersecurity-skills.git .agents/cybersecurity-skills

Then reference skills from `.agents/cybersecurity-skills/skills/`.

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 · 18 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": "cybersecurity-skills",
  3. "owner": {
  4. "name": "Bri Russell",
  5. "url": "https://github.com/briiirussell"
  6. },
  7. "metadata": {
  8. "description": "Cybersecurity skills for AI agents — source-code audits, dependency triage, cloud config review, incident response, OSINT, AI/LLM security",
  9. "version": "1.70.0"
  10. },
  11. "plugins": [
  12. {
  13. "name": "cybersecurity-skills",
  14. "description": "Cybersecurity skills for AI coding agents: OWASP source-code audit, dependency CVE triage, cloud / IAM / container hardening, recon, OSINT, incident triage, disk forensics, SIEM detection engineering, prompt-injection audit, API security, web pentest, threat modeling, mobile / crypto / secrets audit",
  15. "source": "./"
  16. }
  17. ]
  18. }
README.md · README · 300 lines

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

  1. # Cybersecurity Skills for AI Agents
  2. [![CI](https://github.com/briiirussell/cybersecurity-skills/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/briiirussell/cybersecurity-skills/actions/workflows/ci.yml)
  3. A collection of cybersecurity skills for AI coding agents. The AI does the heavy lifting; you bring the context about your stack and your priorities.
  4. **Built to be useful at every experience level:**
  5. - **Security engineers and pentesters** running formal audits — concrete grep patterns, OWASP / NIST / ATT&CK alignment, report templates that pass auditor review
  6. - **Developers** shipping safer code without a dedicated security team to lean on — security work that fits into a normal sprint, plain-English explanations of why each finding matters
  7. - **Founders, ops folks, and small-team operators** securing a stack they can't afford a CISO for — guided, opinionated playbooks for the most common security work, with the audit skill explaining what it found and why
  8. - **Red / blue / purple teams** running real engagements — offensive recon, web pentest, threat hunting, detection engineering, SOC operations
  9. You do not need to be a security expert to use these skills. The skills are written so the AI agent can run them end-to-end and explain the findings in language any technical reader can follow. If you can describe what you have and what you want to know about it, the agent can do the work.
  10. Skills are authored as Claude Code [`SKILL.md` files](https://code.claude.com/docs/en/skills) (the canonical format) and built into adapters for Cursor and Codex. Installable via [`npx skills`](https://github.com/vercel-labs/skills) or the Claude Code plugin marketplace.
  11. Built by [Bri Russell](https://github.com/briiirussell). I run real audits with these skills, then bring the gaps I find back into the skill itself — so each version is a little less opinion and a little more evidence.
  12. **Contributions welcome!** Field feedback is the most valuable contribution — whether you're a security engineer who hit a gap during an audit, a developer whose AI agent missed something obvious, or a founder who used a skill and got an answer that wasn't quite right. [Open a PR](#contributing) or [open an issue](https://github.com/briiirussell/cybersecurity-skills/issues) — every level of expertise produces useful signal.
  13. ## Where to start
  14. Not every skill is for every user on day one. A good starting point by context:
  15. - **Not sure?** Ask for `security-start` (or just say "where do I start with security?"). It asks two or three questions and picks the skill.
  16. - **Reviewing your own code or product:** start with `owasp-audit` for the source-code sweep, then `api-audit` if you have API endpoints, then `dependency-audit` for the CVE pass
  17. - **A CVE wave just dropped and you run many apps:** `patch-sweep` to work out which apps are affected and ship fixes across the fleet, with `dependency-audit` for each project
  18. - **Want deterministic scanners in CI instead of asking an agent to "hack" your app:** `scanner-pipeline` picks the tools per layer, wires them into CI, and routes findings to `finding-triage`
  19. - **Securing cloud / infrastructure:** start with `cloud-audit` (AWS / GCP / Azure misconfig), then `iam-audit` if you manage identities, then `container-audit` if you run Docker / Kubernetes
  20. - **Responding to "something happened":** `incident-triage` for the immediate response, `disk-forensics` if you need to analyze a system afterward, `malware-triage` for a suspicious file someone found, `security-comms` to draft the stakeholder / customer communications
  21. - **No SIEM, no security staff, but you have logs:** `log-watch` sets up a scheduled agent that reads the logs you already have (Vercel, Heroku, Sentry, Supabase, Stripe, CloudTrail, GitHub) and pages someone when it matters
  22. - **You are the security team (founder / solo operator):** `personal-opsec` audits your own accounts, devices and AI-agent setup first — the person holding the keys is usually the softest target
  23. - **Building a security program from scratch:** `csf-mapping` for the governance frame, `threat-modeling` before new features, `breach-patterns` to learn from public incidents
  24. - **Working under a specific regulation:** `privacy-engineering` for GDPR / CCPA / similar privacy laws, `hipaa-audit` for ePHI, `pci-audit` for payment cards, `control-audit` for SOC 2, ISO 27001 or FedRAMP audit readiness, `ai-risk-management` for AI features
  25. - **Running AI coding agents with skills, plugins, or MCP servers:** `agent-supply-chain-audit` before you install or trust them — including this catalog
  26. - **Closing the loop on findings:** `finding-triage` for any single finding from any source — gives you a defensible disposition with the right ticket fields
  27. - **Translating security work upward or outward:** `security-comms` for board / exec / customer / engineering / sales-engineering deliverables
  28. The offensive skills (`recon`, `osint-recon`, `web-pentest`, `red-team-engagement`) require explicit authorization for the target and assume more security context. They open with an authorization check and will refuse anything ambiguous. `red-team-engagement` in particular carries the strongest refusal posture in the catalog and will refuse to plan anything against systems the user cannot demonstrate authorization for.
  29. ## What are Skills?
  30. Skills are markdown files that give AI agents specialized knowledge and workflows for specific tasks. Drop them into your project and your agent recognizes when you're working on a security task and applies the right methodology — OWASP categories, NIST IR steps, MITRE ATT&CK references, the actual grep patterns that surface the bug.
  31. The goal isn't to replace a security engineer — or to pretend you have one if you don't. It's to give the agent enough structure that the first pass is useful, the report format is consistent, and the obvious stuff stops slipping through. For teams without dedicated security headcount, that closes a real gap. For teams with security engineers, it lets them spend their time on the work the AI can't do.
  32. ## How Skills Work Together
  33. The skills are organized into seven families. Most security work crosses families — an OWASP audit surfaces a dependency question, an incident kicks off an OSINT trail, cloud findings overlap with appsec, and findings have to be translated for the audience that hears them. Skills cross-reference each other where that's true; `finding-triage`, `security-comms`, and `csf-mapping` orchestrate across the whole map.
  34. ```
  35. ┌──────────────────────────────────────────┐
  36. │ Cybersecurity Skill Map │
  37. └─────────────────────┬────────────────────┘
  38. │
  39. ┌─────────┬──────────┬──────────┼─────────┬──────────┬───────────┐
  40. ▼ ▼ ▼ ▼ ▼ ▼ ▼
  41. ┌──────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌──────┐ ┌─────────┐ ┌──────────┐
  42. │AppSec│ │Offens. │ │Detect &│ │Cloud & │ │ AI │ │Design & │ │Complianc │
  43. │& Sup │ │& Recon │ │Respond │ │ Infra │ │Secur.│ │Governnce│ │& Privacy │
  44. ├──────┤ ├────────┤ ├────────┤ ├────────┤ ├──────┤ ├─────────┤ ├──────────┤
  45. │owasp-│ │recon │ │incid- │ │cloud- │ │promp-│ │threat- │ │privacy- │
  46. │ audit│ │osint- │ │ triage │ │ audit │ │ inj. │ │ modeling│ │ engineer-│
  47. │api- │ │ recon │ │disk- │ │contain-│ │ai- │ │vuln- │ │ ing │
  48. │ audit│ │web- │ │ forens.│ │ audit │ │ risk-│ │ research│ │pci-audit │
  49. │depen-│ │ pentest│ │siem- │ │iam-aud-│ │ mgmt │ │finding- │ │hipaa- │
  50. │ audit│ │red- │ │ detect.│ │ it │ │agent-│ │ triage │ │ audit │
  51. │secre-│ │ team- │ │soc- │ │ │ │supply│ │csf- │ │control- │
  52. │ audit│ │ engage-│ │ ops │ │ │ │-chain│ │ mapping │ │ audit │
  53. │crypt-│ │ ment │ │threat- │ │ │ │-audit│ │security-│ │ │
  54. │ audit│ │business│ │ hunting│ │ │ │ │ │ comms │ │ │
  55. │mobile│ │-logic- │ │breach- │ │ │ │ │ │personal-│ │ │
  56. │-audit│ │-testing│ │patterns│ │ │ │ │ │ opsec │ │ │
  57. │patch-│ │ │ │log- │ │ │ │ │ │security-│ │ │
  58. │ sweep│ │ │ │ watch │ │ │ │ │ │ start │ │ │
  59. │scan- │ │ │ │malware-│ │ │ │ │ │ │ │ │
  60. │ner- │ │ │ │ triage │ │ │ │ │ │ │ │ │
  61. │pipe- │ │ │ │ │ │ │ │ │ │ │ │ │
  62. │line │ │ │ │ │ │ │ │ │ │ │ │ │
  63. │cicd- │ │ │ │ │ │ │ │ │ │ │ │ │
  64. │ sec. │ │ │ │ │ │ │ │ │ │ │ │ │
  65. │vari- │ │ │ │ │ │ │ │ │ │ │ │ │
  66. │ ant- │ │ │ │ │ │ │ │ │ │ │ │ │
  67. │ anal.│ │ │ │ │ │ │ │ │ │ │ │ │
  68. │native│ │ │ │ │ │ │ │ │ │ │ │ │
  69. │-code-│ │ │ │ │ │ │ │ │ │ │ │ │
  70. │review│ │ │ │ │ │ │ │ │ │ │ │ │
  71. │fuzz- │ │ │ │ │ │ │ │ │ │ │ │ │
  72. │ing- │ │ │ │ │ │ │ │ │ │ │ │ │
  73. │ harn.│ │ │ │ │ │ │ │ │ │ │ │ │
  74. └──┬───┘ └───┬────┘ └───┬────┘ └───┬────┘ └──┬───┘ └────┬────┘ └────┬─────┘
  75. │ │ │ │ │ │ │
  76. └─────────┴──────────┴──────────┼─────────┴──────────┴───────────┘
  77. │
  78. Common crossovers:
  79. owasp-audit ↔ api-audit ↔ dependency-audit ↔ vuln-research
  80. web-pentest ↔ recon ↔ osint-recon ↔ red-team-engagement
  81. siem-detection → threat-hunting → incident-triage → disk-forensics
  82. cloud-audit ↔ container-audit ↔ iam-audit ↔ secrets-audit
  83. threat-modeling → owasp-audit / api-audit (pre-implementation → code)
  84. prompt-injection ⇆ ai-risk-management (security slice ⇆ whole lifecycle)
  85. privacy-engineering ⇆ hipaa-audit / pci-audit (engineering ⇆ regulatory)
  86. agent-supply-chain-audit ⇆ dependency-audit / secrets-audit (agent extensions are supply chain too)
  87. owasp-audit (source-side race patterns) → business-logic-testing (prove it live) ← web-pentest
  88. dependency-audit (one project) → patch-sweep (the whole fleet)
  89. scanner-pipeline → finding-triage → fix agents (tools find it, agents fix it)
  90. log-watch → siem-detection / soc-operations (outgrow it) → incident-triage (it's real)
  91. personal-opsec → iam-audit / secrets-audit / agent-supply-chain-audit (the person → the org → the agents)
  92. dependency-audit → cicd-security ← agent-supply-chain-audit (the pipeline is supply chain too)
  93. dependency-audit → cicd-security ← agent-supply-chain-audit (the pipeline is supply chain too)
  94. finding-triage → variant-analysis → scanner-pipeline (one bug → a rule → it can't come back)
  95. native-code-review ↔ crypto-audit (memory safety ↔ constant time and key handling)
  96. native-code-review ↔ fuzzing-harness (read the parser ↔ fuzz it)
  97. incident-triage → malware-triage → siem-detection / threat-hunting (the sample → detections and hunts)
  98. control-audit ⇆ csf-mapping / pci-audit / hipaa-audit (audit readiness ⇆ framework mapping)
  99. security-start → any skill (a vague ask → the right first step)
  100. breach-patterns → every audit skill (what to check)
  101. finding-triage ← every audit skill (closes the loop on any finding)
  102. security-comms ← every skill (translates output for non-security audience)
  103. csf-mapping ← every skill (rolls evidence into governance frame)
  104. ```
  105. ## Available Skills
  106. <!-- SKILLS:START -->
  107. | Skill | What it does |
  108. |-------|--------------|
  109. | [agent-supply-chain-audit](skills/agent-supply-chain-audit/) | Audit what your AI coding agents load and trust — skills, plugins, hooks, settings, MCP servers, `CLAUDE.md` / `AGENTS.md` / `.cursor/rules`. Hidden instructions, invisible Unicode, agent snooping, unpinned MCP servers (rug pulls), exfil hooks. Covers Claude Code, Cursor, Codex, Gemini CLI, Copilot. |
  110. | [ai-risk-management](skills/ai-risk-management/) | NIST AI Risk Management Framework + EU AI Act — model lifecycle governance, fairness, robustness, transparency, monitoring, third-party model risk. Broader than prompt-injection. |
  111. | [api-audit](skills/api-audit/) | OWASP API Security Top 10 (2023) — REST / GraphQL / RPC endpoint audit. BOLA, mass assignment, BFLA, rate-limit, webhook signature, plus a deep GraphQL playbook (schema inference with introspection off, aliased owned-vs-foreign IDOR, resolver cascade, Relay node swap, federation `_entities`, subscriptions, persisted queries). Paired owner-vs-non-owner evidence, verification pass, coverage ledger, findings.json. [Example run](examples/api-audit/report.md). |
  112. | [breach-patterns](skills/breach-patterns/) | Preemptive hardening — read public breach disclosures, extract the audit question each one implies, check your stack. Capital One / LastPass / Okta / Snowflake / MOVEit / Codecov / Equifax / Uber. |
  113. | [business-logic-testing](skills/business-logic-testing/) | The bugs scanners can't find — invariant-first testing (conservation of value, uniqueness, monotonicity, exclusivity), Actor × Action × Resource matrix, state-machine abuse, limit-slicing, and race conditions proven dynamically (HTTP/2 single-packet, idempotency-key scope, cache-before-commit). Explicit written scope required for money flows. |
  114. | [cicd-security](skills/cicd-security/) | GitHub Actions, GitLab CI and CircleCI review — pwn requests (`pull_request_target` / `workflow_run`), expression injection, token permissions, SHA pinning, OIDC trust subjects, self-hosted runners, fork secrets, cache and artifact trust, and AI agents in CI that read issue or PR text while holding a write token. zizmor and actionlint run read-only. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  115. | [cloud-audit](skills/cloud-audit/) | AWS / GCP / Azure infrastructure misconfiguration, excessive IAM, public exposure, compliance gaps — plus PaaS (Vercel / Netlify / Heroku / Render / Railway / Fly): stale manual production deploys, silently broken git deploys, legacy projects still serving old code, preview exposure, repo security defaults. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  116. | [container-audit](skills/container-audit/) | Docker + Kubernetes audit. Dockerfile, base images, pod security, RBAC, NetworkPolicy, secrets, image policy, runtime. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  117. | [control-audit](skills/control-audit/) | Audit readiness for SOC 2, ISO 27001:2022 and NIST 800-53 / FedRAMP — scope and audit period, control inventory, an evidence request per control (inquiry / observation / inspection / reperformance), read-only checks of what the repo can show, technical checks handed to the owning skill, and control gaps rated by exposure. Control matrix and evidence-request list. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  118. | [crypto-audit](skills/crypto-audit/) | Cryptography implementation review — algorithm/mode choice, KDF parameters, IV/nonce handling, authenticated encryption, signature verification, randomness, TLS posture, key lifecycle. Deeper than owasp-audit A02. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  119. | [csf-mapping](skills/csf-mapping/) | NIST CSF 2.0 posture assessment — Govern / Identify / Protect / Detect / Respond / Recover. Subcategory mapping, current/target tiers, prioritized roadmap. Translates technical findings into governance language. |
  120. | [dependency-audit](skills/dependency-audit/) | Dependencies, frameworks, runtimes, toolchain — CVEs, security anti-patterns, supply chain risk. Fixing safely (pnpm override traps, duplicate singletons, engines floor, runtime pins that must move together), CI/release trust handoffs (cache/artifact poisoning, OIDC, digest promotion), package-source redirection, agent-extension pinning. [Example run](examples/dependency-audit/report.md). |
  121. | [disk-forensics](skills/disk-forensics/) | Disk image analysis, evidence recovery, timeline reconstruction. Explicit Authorization Check covering lawful basis, chain of custody, privacy scope. |
  122. | [finding-triage](skills/finding-triage/) | Single-finding disposition workflow — accepts any source (or a findings.json record by fingerprint) and the confirmed / needs-validation / rejected verdicts. Boundary + result gate, severity capped at demonstrated impact, hardening notes kept out of findings. Fixed / Deferred / Accepted Risk / Mitigated (platform/config) / Requires major migration / False Positive, with ticket-ready writeups. Closes the loop on every audit skill. [Example run](examples/finding-triage/report.md). |
  123. | [fuzzing-harness](skills/fuzzing-harness/) | Fuzz harnesses (libFuzzer, cargo-fuzz, Go, Atheris, Jazzer.js / Jazzer) and property-based tests (Hypothesis, fast-check, proptest) for parsers, decoders and serializers — seed corpora, sanitizer runs, crash minimization and triage into findings, regression tests from crashes, and CI fuzzing (ClusterFuzzLite / OSS-Fuzz). Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  124. | [hipaa-audit](skills/hipaa-audit/) | HIPAA Security / Privacy / Breach Notification — three safeguard categories, 18 identifiers, BAA chain-of-liability, minimum-necessary, 60-day breach clock, encryption-as-safe-harbor. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  125. | [iam-audit](skills/iam-audit/) | Consultant-style IAM — audit / design / migrate. Cloud IAM (AWS/GCP/Azure), identity providers (Okta/Entra/Auth0/Workspace), application authorization (RBAC/ABAC/ReBAC), workload identity, JIT access, break-glass. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  126. | [incident-triage](skills/incident-triage/) | Security incident triage following NIST SP 800-61. |
  127. | [log-watch](skills/log-watch/) | Scheduled agent log review + paging for small teams without a SIEM — inventory the logs you already have, starter detections with thresholds (credential stuffing, new admin grants, key creation, .env/.git probing, bad webhook signatures, export spikes, CloudTrail root/IAM), a cheap-filter → strong-model pipeline with a monthly cost table, dedupe + suppression, paging. Detection only; logs treated as untrusted input. |
  128. | [malware-triage](skills/malware-triage/) | Static triage of a suspicious file without running it — safe handling, hash reputation, packers, strings / FLOSS, PE / ELF / Mach-O, script and Office macro deobfuscation, capa mapped to ATT&CK. Output: a verdict with evidence, defanged indicators (CSV / STIX 2.1), and a YARA rule tested against goodware. Hands off to siem-detection and threat-hunting. |
  129. | [mobile-audit](skills/mobile-audit/) | iOS + Android audit against OWASP MASVS / MASTG — storage, crypto, network, auth, platform IPC, code, resilience. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  130. | [native-code-review](skills/native-code-review/) | Memory-safety review of C, C++ and Rust — out-of-bounds writes and integer overflow into sizes, use-after-free, format strings, uninitialized memory, Rust `unsafe` soundness, FFI boundaries, parsers of untrusted input first, secrets left in memory, plus hardening flags and sanitizers. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  131. | [osint-recon](skills/osint-recon/) | Open source intelligence gathering and correlation. |
  132. | [owasp-audit](skills/owasp-audit/) | Source-code audit against OWASP Top 10:2025 — recon first (architecture + coverage ledger), category checklist with grep patterns, a per-finding refutation pass (confirmed / needs validation / rejected), coverage critic, findings.json → report. Quick / standard / deep run profiles, subagent orchestration, re-runs by fingerprint, diff / PR-scoped mode, inbound-webhook and parser-limit patterns. [Example run](examples/owasp-audit/report.md). |
  133. | [patch-sweep](skills/patch-sweep/) | Fleet-wide CVE response across many apps and deploy platforms — map repos → platform projects → live domains, find each project's real production branch, catch stale manual deploys, decide affectedness (runtime + dependency + code path), mitigate before patching, ship and confirm prod. Output: one status board row per app. |
  134. | [pci-audit](skills/pci-audit/) | PCI DSS v4.0.1 — scope determination first, then Req 3 (CHD storage) / 4 (transmission) / 6 (secure SDLC) / 7-8 (access) / 10 (logging) / 11 (testing) / 12 (program). Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  135. | [personal-opsec](skills/personal-opsec/) | Audit one person's own security setup — the founder or operator holding the keys. Walks Karpathy's 15-step checklist with read-only local checks where possible (disk encryption, firewall, DNS), adds operator-critical items (account recovery, SIM-swap / port-out PIN, registrar lock, hardware-key MFA), and the AI-agent-era layer (tokens your agents can read, MCP trust, inbox-agent prompt injection). Not awareness training. |
  136. | [privacy-engineering](skills/privacy-engineering/) | GDPR / CCPA / CPRA / LGPD / PIPEDA technical implementation — data classification, minimization, consent, the DSAR pipeline (access / deletion / portability with full vendor fan-out), DPIA inputs. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  137. | [prompt-injection](skills/prompt-injection/) | AI features / LLM integrations / agents — direct and indirect prompt injection, privilege escalation, authorization bypass, plus concealment checks (invisible Unicode, comment-hidden directives, whitespace padding, base64 data URIs) and MCP tool poisoning (parameter-description injection, description vs behaviour mismatch, rug-pull pinning, Unicode tool names). Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  138. | [recon](skills/recon/) | Structured attack surface enumeration for authorized pentests, bug bounty, CTF. |
  139. | [red-team-engagement](skills/red-team-engagement/) | Authorized adversary emulation methodology — distinct from web-pentest. Multi-week, objective-based, assumed-breach. Heaviest authorization framing in the catalog. |
  140. | [scanner-pipeline](skills/scanner-pipeline/) | Set up and run real scanners per layer (gitleaks / trufflehog, semgrep, osv-scanner, trivy / checkov, Supabase advisors, ZAP / nuclei on domains you own), normalize to SARIF or findings.json, dedupe, suppress with reason + expiry, schedule in CI, and hand one finding at a time to fix agents. Works across a fleet of repos. |
  141. | [secrets-audit](skills/secrets-audit/) | Find leaked secrets (code, Git history, build artifacts, CI, frontend bundles, AI agent configs and session transcripts) + audit secrets-management posture (rotation, scope, workload identity). Confirms key type (publishable vs restricted vs secret) before rating; findings.json with values redacted; exfil collector-domain list for egress hunting. [Example run](examples/secrets-audit/report.md). |
  142. | [security-comms](skills/security-comms/) | Translate security work for non-security audiences — board, executive, engineering, customer success, customers, legal, procurement. Seven audience archetypes, six templates (incident comms, post-mortem, breach disclosure, etc.). |
  143. | [security-start](skills/security-start/) | Not sure which skill you need? Start here. Looks at the repo, asks at most three questions (what you have, what's happening, who it's for), and hands off to one to three skills from this catalog, in order. Routing only — no audit of its own. |
  144. | [siem-detection](skills/siem-detection/) | SIEM detection engineering — log source coverage, Sigma rule authoring, MITRE ATT&CK mapping, FP tuning, detection-as-code. |
  145. | [soc-operations](skills/soc-operations/) | Build / run / improve a SOC — alert prioritization, runbook authoring, escalation criteria, on-call structure, KPIs (MTTD / MTTR / FP rate), alert-fatigue tuning loop. |
  146. | [threat-hunting](skills/threat-hunting/) | Proactive, hypothesis-driven adversary detection — PEAK framework, ATT&CK-driven hunt catalog, every hunt produces an artifact (rule, dead-end doc, or coverage gap). |
  147. | [threat-modeling](skills/threat-modeling/) | Pre-implementation security design — STRIDE per element + abuse cases, data flow diagrams with trust boundaries, four-question Shostack frame. |
  148. | [variant-analysis](skills/variant-analysis/) | Turn one confirmed bug into a tested Semgrep rule or CodeQL query (positive and negative cases), or a non-destructive nuclei template for HTTP-only variants. Run it across the repo or org, close every hit with a verdict linked to the original (`ext.variant_of`), and keep the rule in CI. Ships a tested Express IDOR rule and an end-to-end example. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  149. | [vuln-research](skills/vuln-research/) | CVE deep-dive — pull canonical sources, confirm versions, reachability analysis, check public PoCs / CISA KEV / EPSS, decide patch / mitigate / accept-risk. |
  150. | [web-pentest](skills/web-pentest/) | Live web application pentest against an authorized target — OWASP WSTG-structured, nine phases from config through business logic. Combined white-box + black-box mode (code ↔ endpoint Target Map) when you have source too; every PoC carries paired baseline-vs-attack evidence. Writes findings.json (confirmed / needs validation / rejected), with SARIF export. |
  151. <!-- SKILLS:END -->
  152. Want to see the output first? [`examples/`](examples/) has real runs of five audit skills against a small vulnerable app.
  153. Every offensive skill enforces an authorization check before doing anything; every skill refuses destructive or unauthorized use. Details in [Ethics & Authorization](#ethics--authorization).
  154. ## Installation
  155. ### Option 1: `npx skills` (recommended)
  156. The [vercel-labs/skills](https://github.com/vercel-labs/skills) installer reads the canonical `skills/` directory directly:
  157. ```bash
  158. # List available skills
  159. npx skills add briiirussell/cybersecurity-skills --list
  160. # Install all skills
  161. npx skills add briiirussell/cybersecurity-skills
  162. # Install specific skills
  163. npx skills add briiirussell/cybersecurity-skills --skill owasp-audit api-audit
  164. ```
  165. Installs to your `.agents/skills/` directory with a symlink into `.claude/skills/` for Claude Code compatibility.
  166. ### Option 2: Claude Code plugin marketplace
  167. ```bash
  168. /plugin install cybersecurity-skills --marketplace briiirussell/cybersecurity-skills
  169. ```
  170. That's one step on Claude Code 2.1.275 or later. On older versions, add the marketplace first:
  171. ```bash
  172. /plugin marketplace add briiirussell/cybersecurity-skills
  173. /plugin install cybersecurity-skills
  174. ```
  175. The plugin also ships one subagent, `finding-verifier`. Audit skills hand it one candidate finding at a time, and it tries to disprove the finding in a fresh, read-only context. Cursor and Codex don't get the subagent; they follow the same steps from `verification.md`.
  176. ### Option 3: Claude Code (project-level, manual)
  177. ```bash
  178. git clone https://github.com/briiirussell/cybersecurity-skills.git
  179. cp -r cybersecurity-skills/skills/owasp-audit .claude/skills/
  180. ```
  181. Trigger naturally ("run an OWASP audit on this codebase") or invoke directly with `/owasp-audit`.
  182. ### Option 4: Claude Code (personal, all projects)
  183. ```bash
  184. cp -r cybersecurity-skills/skills/owasp-audit ~/.claude/skills/
  185. ```
  186. ### Option 5: Cursor
  187. ```bash
  188. cp adapters/cursor/owasp-audit.mdc .cursor/rules/
  189. ```
  190. ### Option 6: Codex
  191. ```bash
  192. cp adapters/codex/owasp-audit.md <your-codex-config-dir>/
  193. ```
  194. ### Option 7: Git submodule (easy updates)
  195. ```bash
  196. git submodule add https://github.com/briiirussell/cybersecurity-skills.git .agents/cybersecurity-skills
  197. ```
  198. Then reference skills from `.agents/cybersecurity-skills/skills/`.
  199. ## Building Adapters
  200. After creating or modifying a skill, regenerate the Cursor + Codex adapters:
  201. ```bash
  202. node scripts/build-adapters.mjs # adapters + shared reference copies
  203. node scripts/lint-skills.mjs # frontmatter, size, cross-reference and link lint
  204. npm test # findings / coverage validators, SARIF export, build (Node ≥ 21, no dependencies)
  205. ```
  206. Files in `shared/` (the `findings.json` schema and validator, severity calibration, verification and coverage guides) are copied into each skill's `references/` folder according to `shared/manifest.json`, because `npx skills` installs one skill folder at a time. Edit `shared/`, never the copies.
  207. ## Creating a New Skill
  208. 1. Copy `templates/skill-template.md` to `skills/<your-skill>/SKILL.md`
  209. 2. Fill in the frontmatter (`name`, `description`, `allowed-tools`)
  210. 3. Write instructions in imperative form, under 500 lines
  211. 4. Add trigger prompts in `evals/triggers/<your-skill>.json` (see [`evals/README.md`](evals/README.md))
  212. 5. Run the build script to generate adapters, then `npm run check`
  213. Format details and writing guidance live in [`CLAUDE.md`](CLAUDE.md). Full contribution flow in [`CONTRIBUTING.md`](CONTRIBUTING.md).
  214. ## Security scanning
  215. Every PR is linted and scanned with [NVIDIA SkillSpector](https://github.com/NVIDIA/SkillSpector) (static mode, pinned version). Intentional example payloads — a security skill has to name `~/.aws/credentials` and show what an injection looks like — are suppressed by narrow, reasoned rules in [`.skillspector-baseline.yaml`](.skillspector-baseline.yaml). Scan it yourself before installing:
  216. skillspector scan https://github.com/briiirussell/cybersecurity-skills --recursive --no-llm
  217. Our baseline is never applied to your scan; SkillSpector only uses an author-shipped baseline for a single skill with `--use-shipped-baseline`. `allowed-tools` lists tools pre-approved to run **without a prompt** in Claude Code — it is not a sandbox — and the Cursor / Codex adapters carry no tool restrictions at all. Details: [docs/security-scanning.md](docs/security-scanning.md). You can also point `agent-supply-chain-audit` at this repo.
  218. Found a way a skill could lead an agent to do something unsafe, like an over-broad grant or an instruction that skips the authorization check? Please report it privately. [SECURITY.md](SECURITY.md) has what's in scope and how.
  219. ## Ethics & Authorization
  220. These skills are for **authorized security testing, CTF competitions, security research, and defensive use only**. Every offensive skill (`recon`, `osint-recon`, `web-pentest`, etc.) opens with an authorization check and refuses destructive techniques, mass targeting, supply-chain compromise, or evasion patterns intended for malicious use.
  221. If you're using these against a system you don't own or have explicit written authorization to test, you are using them wrong. Don't.
  222. ## Versioning
  223. This repo follows [semantic versioning](https://semver.org/). See [`VERSIONS.md`](VERSIONS.md) for the full changelog and [GitHub Releases](https://github.com/briiirussell/cybersecurity-skills/releases) for release notes.
  224. - **MAJOR** (X.0.0) — Breaking changes: skill renames, removals, or frontmatter changes that break existing installs
  225. - **MINOR** (1.X.0) — New skill, or substantive expansion of an existing one
  226. - **PATCH** (1.0.X) — Content fixes, grep-pattern updates, small additions
  227. Every new skill and every skill improvement ships as its own version, one PR each, so each skill's version in `VERSIONS.md` tells you exactly what changed and when.
  228. ## Contributing
  229. See [`CONTRIBUTING.md`](CONTRIBUTING.md). The short version: field feedback (PRs or issues with concrete patterns from a real audit) is the highest-signal contribution. If a skill missed something in your audit, that's exactly what I want to know. Open a [field report](https://github.com/briiirussell/cybersecurity-skills/issues/new?template=field-report.yml). If one found something real, I'd love a [trophy case](https://github.com/briiirussell/cybersecurity-skills/issues/new?template=trophy-case.yml) entry.
  230. ## License
  231. MIT — see [`LICENSE`](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

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