Skip to content

borghei/Claude-Skills / engineering/skill-security-auditor

skill-security-auditor

Flagged

Security audit and vulnerability scanning for AI agent skills before install. Detects prompt injection, dangerous code, exfiltration, credential harvesting, and supply chain risks. Use when evaluating untrusted skills or gating installs.

Skill Security Auditor

Scan and audit AI agent skills for security risks before installation. Performs static analysis on Python files for dangerous patterns, scans markdown, text and YAML for prompt injection, and checks dependency manifests. Produces a PASS / WARN / FAIL verdict with findings by severity and remediation guidance.

What a verdict means. The scanners match regular expressions line by line. They catch the common, unobfuscated forms of each attack and are easy to evade (string building, encoding, indirection through helpers). PASS means "nothing obvious was found", not "safe". For any skill from an untrusted source, read the scripts yourself after a PASS, and treat WARN as "read these lines before installing".

Core Capabilities

  • Code execution risk detection — command injection (os.system, subprocess shell=True, backticks), eval/exec/compile, obfuscation (base64/hex/chr()), network exfiltration, credential harvesting (~/.ssh, ~/.aws), privilege escalation.
  • Prompt injection detection — system-prompt overrides, role hijacking, safety bypass, hidden zero-width/HTML-comment instructions, data-extraction and credential-access directives, instructions to conceal actions from the user, excessive-permission requests.
  • Supply chain analysis — typosquatted Python package names, unpinned versions in requirements*.txt and package.json, inline pip/npm install. Pinned versions are not checked against advisories; run pip-audit, npm audit or OSV-Scanner for CVEs.
  • Manual structure review (checklist in references/audit-output-and-workflow.md, not automated) — out-of-scope paths, hidden or credential files, unexpected binaries, escaping symlinks, oversized payloads.
  • Verdict & reporting — PASS / WARN / FAIL with severity-categorized findings, remediation, and a strict mode for CI gates.

When to Use

  • Evaluating a skill from an untrusted source before installation
  • Pre-install security gate for CI/CD pipelines
  • Auditing a skill directory or git repository for malicious code
  • Reviewing skills before adding them to a team's approved list
  • Post-incident scanning of installed skills

Clarify First

Before the audit, settle the inputs below. When one is missing or vague and would change the result, ask about it; when it wouldn't, use a sensible default and say which one you used.

  • Target path: the skill file or directory to scan (the subject of every scanner).
  • Scan dimensions: code execution / prompt injection / supply chain (selects which of the three scanners run).
  • Strict mode / gate threshold: whether any HIGH finding forces FAIL (CI gate vs advisory report changes the verdict).

Ask about the two or three inputs that matter most for this request, not the whole list. If the user wants a result straight away, produce it and state your assumptions at the top.

Tools

ToolPurposeCommand
code_scanner.pyScan Python scripts for eval/exec, subprocess, network exfiltration, credential harvesting, obfuscation, unsafe importspython scripts/code_scanner.py <target> --strict --json
prompt_injection_scanner.pyScan markdown/text for prompt-injection patterns and hidden directivespython scripts/prompt_injection_scanner.py <target> --strict --json
supply_chain_checker.pyCheck imports/requirements for typosquatting, unpinned versions, inline installspython scripts/supply_chain_checker.py <target> --strict --json

All tools take a target (file or directory), and support --strict (any HIGH → FAIL) and --json.

Exit codes: 0 PASS or WARN, 1 FAIL (any CRITICAL, or any HIGH with --strict), 2 target does not exist. A directory with nothing scannable exits 0 with a note on stderr.

Samples: assets/sample_malicious_skill/ (hidden override comment, credential read with a clause asking the assistant to hide it, os.system concatenation, ~/.ssh exfiltration, a typosquatted reqeusts pin) fails all three scanners; assets/sample_benign_skill/ passes all three.

python scripts/code_scanner.py assets/sample_malicious_skill              # exit 1
python scripts/prompt_injection_scanner.py assets/sample_malicious_skill  # exit 1
python scripts/supply_chain_checker.py assets/sample_benign_skill         # exit 0

References

Load the reference that matches the task — keep this file lean and pull detail on demand:

  • references/threat-model-and-patterns.md — the attack-vector threat model, trust boundaries, full regex pattern sets for code-execution and prompt-injection detection, and known evasion techniques. Read when deciding what to scan for or tuning detection.
  • references/audit-output-and-workflow.md — the report format, verdict criteria (incl. strict mode), CI/CD integration YAML, and the manual audit checklist. Read when producing or interpreting an audit.
  • references/quality-and-best-practices.md — static-analysis limitations, common pitfalls, best practices, troubleshooting matrix, and success criteria. Read before shipping or relying on an audit.

Scope & Limitations

This skill covers:

  • Static pattern-based detection of dangerous code constructs in Python files (other languages need a manual read)
  • Prompt injection scanning across markdown, text, YAML, reST and AsciiDoc files within a skill package
  • Dependency checks for requirements*.txt and package.json, plus inline installs in .py and .sh files
  • A manual checklist for structure risks (symlinks, binaries, hidden files, oversized payloads)

This skill does NOT cover:

  • Runtime or dynamic analysis — code is never executed during the audit (see skill-tester for runtime validation)
  • Live CVE database lookups or real-time vulnerability feeds (see dependency-auditor for active CVE scanning)
  • Infrastructure-level security controls such as network segmentation, container hardening, or cloud IAM policies (see infrastructure-compliance-auditor in ra-qm-team)
  • Compliance framework certification against ISO 27001, SOC 2, GDPR, or other regulatory standards (see information-security-manager-iso27001 and gdpr-dsgvo-expert in ra-qm-team)

Integration Points

SkillIntegrationData Flow
dependency-auditorFeed audit findings into live CVE scanning for flagged dependenciesSecurity audit report → dependency-auditor for real-time vulnerability lookup
ci-cd-pipeline-builderEmbed the audit workflow as a required check in generated CI/CD pipelinesPipeline template ← audit job YAML from this skill's CI/CD section
skill-testerRun dynamic runtime tests on skills that pass static analysisPASS verdict from this skill → skill-tester for behavioral validation
infrastructure-compliance-auditorExtend auditing scope from skill-level to infrastructure-level security controlsSkill audit findings → infrastructure auditor for environment-wide posture review
env-secrets-managerCross-reference credential harvesting findings with secrets management policyCredential-access flags from audit → env-secrets-manager for policy verification
pr-review-expertSurface audit findings as inline PR review comments on flagged linesAudit report line references → PR review annotations for developer visibility

Anti-Patterns

Treating PASS as Safe

Mistake: Installing an untrusted skill because all three scanners returned PASS. Why it happens: A green verdict reads like a clearance. Instead: The scanners are regex tripwires. Read every script in an untrusted skill, look for string-built commands, encoded blobs and network calls, and only then install.

Running the Target's Code to Audit It

Mistake: Executing a suspicious skill's scripts (or its test runner) to "see what it does". Why it happens: Dynamic testing feels more thorough. Instead: Audit statically first. Run code only in a disposable sandbox with no credentials and no network, and only after the static pass is clean.

Equating Pinned With Patched

Mistake: Accepting a dependency list because every version is pinned. Why it happens: The checker's unpinned warnings disappear. Instead: Pinning makes builds reproducible, not safe. Run the ecosystem's advisory scanner on the pinned set.

Files

FilePurpose
scripts/code_scanner.pyPython code patterns: command injection, eval/exec, obfuscation, exfiltration, credential harvesting
scripts/prompt_injection_scanner.pyPrompt-injection patterns in markdown, text and YAML
scripts/supply_chain_checker.pyTyposquats, unpinned versions, inline installs
assets/sample_malicious_skill/Hostile fixture (all scanners exit 1)
assets/sample_benign_skill/Benign fixture (all scanners exit 0)
references/*.mdThreat model and patterns, report format and CI wiring, limitations and checklists
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 469kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 469kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 469kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 194kUpdated Claude CodeCodexVerifiedInstall