GitHub - cloudflare/security-audit-skill: A coding-agent skill for multi-phase security audits with independently verified, machine-readable findings · GitHub

Skip to content

Navigation MenuSign inAppearance settingsPlatformAI CODE CREATIONGitHub CopilotWrite better code with AIGitHub Copilot appDirect agents from issue to mergeMCP RegistryIntegrate external toolsDEVELOPER WORKFLOWSActionsAutomate any workflowCodespacesInstant dev environmentsIssuesPlan and track workCode ReviewManage code changesCode QualityEnforce quality at mergeAPPLICATION SECURITYGitHub Advanced SecurityFind and fix vulnerabilitiesCode securitySecure your code as you buildSecret protectionStop leaks before they startEXPLOREWhy GitHubDocumentationBlogChangelogMarketplaceView all featuresSolutionsBY COMPANY SIZEEnterprisesSmall and medium teamsStartupsNonprofitsBY USE CASEApp ModernizationDevSecOpsDevOpsCI/CDView all use casesBY INDUSTRYHealthcareFinancial servicesManufacturingGovernmentView all industriesView all solutionsResourcesEXPLORE BY TOPICAISoftware DevelopmentDevOpsSecurityView all topicsEXPLORE BY TYPECustomer storiesEvents & webinarsEbooks & reportsBusiness insightsGitHub SkillsSUPPORT & SERVICESDocumentationCustomer supportCommunity forumTrust centerPartnersView all resourcesOpen SourceCOMMUNITYGitHub SponsorsFund open source developersPROGRAMSSecurity LabMaintainer CommunityGitHub StarsArchive ProgramREPOSITORIESTopicsTrendingCollectionsEnterpriseENTERPRISE SOLUTIONSEnterprise platformAI-powered developer platformAVAILABLE ADD-ONSGitHub Advanced SecurityEnterprise-grade security featuresCopilot for BusinessEnterprise-grade AI featuresPremium SupportEnterprise-grade 24/7 supportPricingSearch/Sign inSign upAppearance settings

You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.
You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

Uh oh!

There was an error while loading. Please reload this page.

cloudflare

/

security-audit-skill

Public

Notifications
You must be signed in to change notification settings

Fork
442

Star
7.9k

Code

Issues
6

Pull requests
9

Actions

Security and quality
0

Insights

Additional navigation options

Code

Issues

Pull requests

Actions

Security and quality

Insights

mainBranchesTagsGo to fileCodeOpen more actions menuLatest commit History14 Commits14 CommitsFolders and filesNameNameLast commit messageLast commit dateskills/security-auditskills/security-audit  LICENSELICENSE  README.mdREADME.md  View all filesRepository files navigationREADMECode of conductContributingMIT licenseSecurityMore itemssecurity-audit
A coding-agent skill that turns your agent into a security auditor. It orchestrates isolated agents through reconnaissance, coverage-led hunting, candidate validation, structured output, independent record verification, and target-neutral reporting.
This is the skill that seeded Cloudflare's vulnerability discovery harness, described in Build your own vulnerability harness. The harness grew into a multi-stage, fleet-wide system; this skill is the single-repo starting point it evolved from.
What it does
The skill runs a structured audit in six phases:

Reconnaissance -- map architecture, trust boundaries, input surfaces, prior evidence, and deterministic coverage in architecture.md and coverage-ledger.json.
Coverage-led hunting -- assign isolated hunters from ledger units, record their checks, and use coverage critics to find gaps.
Candidate validation -- give every unique candidate to a fresh verifier that tries to disprove it.
Structured output -- write confirmed, needs_validation, and rejected records to findings.json and validate them against report-schema.json.
Independent record verification -- fresh agents verify final source claims. Material replacements receive another independent verifier.
Target-neutral reporting -- derive REPORT.md, FINDINGS-DETAIL.md, and NEEDS-VALIDATION.md from the verified records and coverage ledger.

The parent runs validate-coverage-ledger.cjs after creating the ledger and after each later ledger update. It runs validate-findings.cjs in Phase 4 and again after every Phase 5 replacement.
The verdicts are distinct: confirmed has a complete source trace and bounded observed result, needs_validation has an exact unresolved fact and no severity, and rejected records a disproved candidate.
Multiple runs against the same repo are additive. The skill uses prior ledgers and findings to target gaps, revalidate changed source, and carry forward current-source evidence without treating stale or unresolved work as covered.
Files

File
Purpose

SKILL.md
Setup, core principles, platform terminology, workflow overview, and audit anti-patterns

RECONNAISSANCE.md
Phase 1 reconnaissance prompts and synthesis instructions

HUNTING.md
Phase 2 orchestration, hunting methodology, and validation rules

ATTACK-CLASSES.md
Core, wildcard, and obvious-things attack prompts

MEMORY-SAFETY-AND-BINARY.md
Memory-safety, binary, and kernel hunting classes for native targets

AI-AND-LLM.md
Prompt-injection, agent/tool, and output-handling hunting classes for LLM-backed targets

WEB-PROTOCOL-AND-AUTH.md
HTTP request-framing, cache, and authentication-protocol hunting classes for HTTP-protocol and auth targets

CLIENT-SIDE.md
DOM-injection, messaging-trust, UI-redress, and prototype-pollution hunting classes for client-side/browser targets

SUPPLY-CHAIN-AND-RELEASE.md
Dependency, CI, release, signing, update, plugin, and extension hunting classes

CLOUD-AND-DEPLOYMENT.md
IAM, infrastructure-as-code, container, serverless, ingress, and runtime-configuration hunting classes

PROTOCOLS-RPC-AND-MESSAGING.md
RPC, serialization, queue, broker, webhook, and streaming-protocol hunting classes

RESOURCE-EXHAUSTION-AND-AVAILABILITY.md
Shared resource, quota, queue, worker, and operator-spend hunting classes

DATA-ISOLATION-AND-LIFECYCLE.md
Tenant isolation, cache, search, export, backup, migration, deletion, and restore hunting classes

DESKTOP-MOBILE-AND-LOCAL-IPC.md
Native app, deep-link, webview, exported-component, helper, daemon, and local-IPC hunting classes

VALIDATION-AND-REPORTING.md
Phases 3–6 candidate validation, structured output, record verification, and reporting

report-schema.json
JSON schema for all three findings.json verdicts

validate-findings.cjs
Zero-dependency validator for findings.json in Phases 4 and 5

validate-findings.test.cjs
Findings-validator tests and producer-compatible fixture checks

validate-coverage-ledger.cjs
Zero-dependency validator for coverage-ledger.json in Phases 1–5

validate-coverage-ledger.test.cjs
Coverage-ledger validator tests

Installation
Install the skill with the Skills CLI:
npx skills add https://github.com/cloudflare/security-audit-skill \
--skill security-audit
Use --global for a user-level installation:
npx skills add https://github.com/cloudflare/security-audit-skill \
--skill security-audit \
--global
Run npx skills --help for agent-selection and non-interactive options.
Usage
Start your coding agent in (or pointed at) the codebase you want to audit, then ask it to do a security audit:
security audit this codebase

find security vulnerabilities in ./src

do a security review, output to ~/audits/my-project

The skill activates automatically when the request matches its trigger (security audit, find vulnerabilities, pen-test the code, etc.). A direct codebase audit or pen-test request uses full audit mode. Security questions and focused vulnerability work use guidance mode unless you request report artifacts. In full audit mode, an unspecified output directory defaults to ~/security-audit-skill/<repo-name>/run-<N>. The workflow writes inside the target repository only when you explicitly select a directory that version control ignores.
Requirements

A coding agent with a model that supports tool use and parallel sub-agents
Node.js for the zero-dependency findings and coverage-ledger validators
An OS-enforced sandbox for target-controlled builds, tests, processes, browsers, emulators, fuzzers, and fixtures. It must disable external networking, use a sanitized allowlisted environment, enforce resource limits, and allow writes only to assigned scratch paths. Without these controls, the workflow keeps the lead as needs_validation instead of executing target code.

Design principles

Only confirm established boundary failures. Keep a source-grounded blocked lead as needs_validation with its exact unresolved fact.
Adversarial validation. The agent that checks a finding is never the agent that found it.
Severity requires impact. Likelihood x impact, not deviation from a checklist.
Defense-in-depth gaps are not vulnerabilities. If Layer A prevents the attack, the absence of Layer B is a hardening note.
Multiple runs improve coverage. In our test runs, a single run found roughly half of the vulnerabilities that repeated runs found in total.

Contact
Questions, feedback, or comparing notes on AI-driven security tooling: security-ai-research@cloudflare.com
License
MIT -- see LICENSE.
AboutA coding-agent skill for multi-phase security audits with independently verified, machine-readable findingsResourcesReadmeMIT licenseCode of conductCode of conductContributingContributingSecurity policySecurity policyActivityCustom propertiesStars7.9k starsWatchers30 watchingForks442 forksReport repositoryReleasesPackagesUsed byContributorsLanguages

Footer

© 2026 GitHub, Inc.

Footer navigation

Terms

Privacy

Security

Status

Community

Docs

Contact

Manage cookies

Do not share my personal information

You can’t perform that action at this time.

The security-audit-skill is a coding agent skill designed to function as a sophisticated security auditor through a multi-phase auditing process utilizing independently verified, machine-readable findings. This skill originated from the vulnerability discovery harness developed by Cloudflare and serves as the foundational repository for that larger, multi-stage, fleet-wide system. The core functionality involves orchestrating isolated agents through a sequence of specialized steps encompassing reconnaissance, hunting, validation, structured reporting, and independent verification.

The auditing methodology is structured around six distinct phases. Phase one, reconnaissance, focuses on mapping the target system by analyzing its architecture, trust boundaries, input surfaces, existing evidence, and deterministic coverage as documented in architectural and coverage ledgers. This is followed by coverage-led hunting, where isolated hunters, drawing from the coverage ledger units, record their findings and utilize coverage critics to identify areas of potential vulnerability. Next is candidate validation, which involves subjecting every unique candidate identified to a fresh verifier to determine if the finding holds true.

Phase four moves to structured output, where confirmed findings, records requiring further validation, and rejected candidates are written to structured output files, cross-referenced against a defined report schema. This is supported by independent record verification, where fresh agents scrutinize the final source claims, and material replacements undergo an additional independent verification step. The final phase is target-neutral reporting, where the verified records and coverage ledger are synthesized to derive comprehensive reports detailing findings, specifics, and areas needing further investigation. The underlying process incorporates validators, such as validate-findings.cjs and validate-coverage-ledger.cjs, which ensure the integrity of the findings and coverage records throughout Phases four and five.

The skill employs an additive approach, meaning multiple runs against the same repository enhance coverage by leveraging prior ledgers and findings to target specific gaps, revalidate changed sources, and carry forward existing evidence without treating unresolved work as covered. The system has extensive modularity, featuring numerous specialized hunting classes tailored to specific attack surfaces, including classes for memory safety, web protocols and authentication, supply chain analysis, interaction protocols, and data isolation. This modularity is managed through specific files like Reconnaissance.md, Hunting.md, and various domain-specific prompt files, ensuring specialized focus for different parts of the security landscape.

The design principles emphasize rigorous and adversarial evaluation. Findings must only confirm established boundary failures, and any unresolved uncertainty must be explicitly noted as a needs_validation fact with an exact, unresolved detail. Adversarial validation is central, ensuring that the agent verifying a finding is distinct from the agent that discovered it. Severity assessment is based on the calculated likelihood multiplied by the impact, rather than mere deviation from a checklist. Furthermore, the system acknowledges defense-in-depth, recognizing that the absence of a specific layer, if another layer prevents the attack, should be noted as a hardening consideration rather than an outright vulnerability. The effectiveness of the auditing process is improved through iterative testing; empirical results show that repeated runs yield greater vulnerability discovery rates.

Operational requirements dictate that the coding agent must operate within a stringent, OS-enforced sandbox environment. This sandbox must control builds, tests, processes, and memory access, disable external networking, use a sanitized environment, and enforce strict resource limits. This isolation is crucial to prevent the workflow from executing target code in an uncontrolled manner, which would otherwise result in low-confidence leads being incorrectly classified as confirmed.