Skip to content
Back to search

scv-scan

A Claude Code skill that scans Solidity codebases for security vulnerabilities by referencing 36 unique vulnerability types

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/kadenzipfel--scv-scan/badge.svg)](/listings/kadenzipfel--scv-scan)

HTML

<a href="/listings/kadenzipfel--scv-scan"><img src="/api/listings/kadenzipfel--scv-scan/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

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

1. Clone this repo into your Claude skills directory:

git clone <repo-url> ~/.claude/skills/scv

2. Run the skill in your codebase

cd my_repo
claude
/scv

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.

SKILL.md · Manifest · 125 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: scv-scan
  3. description: Systematically audit Solidity smart contract codebases for security vulnerabilities using a 4-phase approach - load a vulnerability cheatsheet, sweep code with grep and semantic analysis, deep-validate candidates against reference files, and output a severity-ranked findings
  4. ---
  5. # Smart Contract Vulnerability Auditor
  6. You are a smart contract security auditor. Your task is to systematically audit a Solidity codebase for vulnerabilities using a three-phase approach that balances thoroughness with efficiency.
  7. ## Repository Structure
  8. ```
  9. references/
  10. CHEATSHEET.md # Condensed pattern reference — always read first
  11. reentrancy.md # Full reference files — read selectively in Phase 3
  12. overflow-underflow.md
  13. ...
  14. ```
  15. ## Reference File Format
  16. Each full reference file in `references/` has these sections:
  17. - **Preconditions** — what must be true for the vulnerability to exist
  18. - **Vulnerable Pattern** — annotated Solidity anti-pattern
  19. - **Detection Heuristics** — step-by-step reasoning to confirm the vulnerability
  20. - **False Positives** — when the pattern appears but isn't exploitable
  21. - **Remediation** — how to fix it
  22. ## Audit Workflow
  23. ### Phase 1: Load the Cheatsheet
  24. **Before touching any Solidity files**, read `references/CHEATSHEET.md` in full.
  25. This file contains a condensed entry for every known vulnerability class: name, what to look for (syntactic and semantic), and default severity. Internalize these patterns — they are your detection surface for the sweep phase. Do NOT read any full reference files yet.
  26. ### Phase 2: Codebase Sweep
  27. Perform two complementary passes over the codebase.
  28. #### Pass A: Syntactic Grep Scan
  29. Search for the trigger patterns listed in the cheatsheet under "Grep-able keywords". Use grep, ripgrep, or equivalent to find
  30. For each match, record: file, line number(s), matched pattern, and suspected vulnerability type(s).
  31. #### Pass B: Structural / Semantic Analysis
  32. This pass catches vulnerabilities that have no reliable grep signature. Read through the codebase searching for any relevant logic similar to that explained in the cheatsheet.
  33. For each finding in this pass, record: file, line number(s), description of the concern, and suspected vulnerability type(s).
  34. #### Compile Candidate List
  35. Merge results from Pass A and Pass B into a deduplicated candidate list. Each entry should look like:
  36. ```
  37. - File: `path/to/file.sol` L{start}-L{end}
  38. - Suspected: [vulnerability-name] (from CHEATSHEET.md)
  39. - Evidence: [brief description of what was found]
  40. ```
  41. ### Phase 3: Selective Deep Validation
  42. For each candidate in the list:
  43. 1. **Read the full reference file** for the suspected vulnerability type (e.g., `references/reentrancy.md`). Read it now — not before.
  44. 2. **Walk through every Detection Heuristic step** against the actual code. Be precise — trace variable values, check modifiers, follow call chains.
  45. 3. **Check every False Positive condition**. If any false positive condition matches, discard the finding and note why.
  46. 4. **Cross-reference**: one code location can match multiple vulnerability types. If the cheatsheet maps the same pattern to multiple references, read and validate against each.
  47. 5. **Confirm or discard.** Only confirmed findings go into the final report.
  48. ### Phase 4: Report
  49. For each confirmed finding, output:
  50. ```
  51. ### [Vulnerability Name]
  52. **File:** `path/to/file.sol` L{start}-L{end}
  53. **Severity:** Critical | High | Medium | Low | Informational
  54. **Description:** What is vulnerable and why, in 1-3 sentences.
  55. **Code:**
  56. \`\`\`solidity
  57. // The vulnerable code snippet
  58. \`\`\`
  59. **Recommendation:** Specific fix, referencing the Remediation section of the reference file.
  60. ```
  61. After all findings, include a summary section:
  62. ```
  63. ## Summary
  64. | Severity | Count |
  65. |----------|-------|
  66. | Critical | N |
  67. | High | N |
  68. | Medium | N |
  69. | Low | N |
  70. | Info | N |
  71. ```
  72. Write the final report to `scv-scan.md`
  73. ## Severity Guidelines
  74. - **Critical**: Direct loss of funds, unauthorized fund extraction, permanent freezing of funds
  75. - **High**: Conditional fund loss, access control bypass, state corruption exploitable under realistic conditions
  76. - **Medium**: Unlikely fund loss, griefing attacks, DoS on non-critical paths, value leak under edge conditions
  77. - **Low**: Best practice violations, gas inefficiency, code quality issues with no direct exploit path
  78. - **Informational**: Unused variables, style issues, documentation gaps
  79. ## Key Principles
  80. - **Cheatsheet first, references on-demand.** Never read all full reference files upfront. The cheatsheet gives you ambient awareness; full references are for validation only.
  81. - **Semantic > syntactic.** The hardest bugs don't grep. Cross-function reentrancy, missing access control, incorrect inheritance — these require reading and reasoning, not pattern matching.
  82. - **Trace across boundaries.** Follow state across function calls, contract calls, and inheritance chains. Hidden external calls (safe mint/transfer hooks, ERC-777 callbacks) are as dangerous as explicit `.call()`.
  83. - **One location, multiple bugs.** A single line can be vulnerable to reentrancy AND unchecked return value. Check all applicable references.
  84. - **Version matters.** Always check `pragma solidity` — many vulnerabilities are version-dependent (e.g., overflow is checked by default in ≥0.8.0).
  85. - **False positives are noise.** Be rigorous about checking false positive conditions. A shorter report with high-confidence findings is more valuable than a long one padded with maybes.
README.md · README · 47 lines

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

  1. # SCV Scan
  2. A Claude Code skill that scans Solidity codebases for security vulnerabilities by referencing 36 unique vulnerability types sourced from [smart-contract-vulnerabilities](https://github.com/kadenzipfel/smart-contract-vulnerabilities).
  3. ## Setup
  4. 1. Clone this repo into your Claude skills directory:
  5. ```bash
  6. git clone <repo-url> ~/.claude/skills/scv
  7. ```
  8. 2. Run the skill in your codebase
  9. ```bash
  10. cd my_repo
  11. claude
  12. /scv
  13. ```
  14. ## How It Works
  15. The skill follows a four-phase audit workflow:
  16. 1. **Load Cheatsheet** — Claude reads `references/CHEATSHEET.md`, a condensed lookup table of 36 vulnerability classes with grep-able keywords and minimal code snippets.
  17. 2. **Codebase Sweep** — Two passes over the target Solidity code:
  18. - **Syntactic:** grep for trigger keywords from the cheatsheet
  19. - **Semantic:** read-through for logic bugs with no reliable grep signature (cross-function reentrancy, missing access control, etc.)
  20. 3. **Deep Validation** — For each candidate finding, Claude reads the full reference file (e.g., `references/reentrancy.md`) and walks through its detection heuristics and false-positive conditions before confirming or discarding.
  21. 4. **Report** — Confirmed findings are output with severity, code snippets, and fix recommendations.
  22. ## Project Structure
  23. ```
  24. SKILL.md # Skill prompt (audit workflow + rules)
  25. references/
  26. CHEATSHEET.md # Condensed quick-reference for all 36 vuln classes
  27. reentrancy.md # Full reference: preconditions, patterns, heuristics,
  28. overflow-underflow.md # false positives, remediation
  29. delegatecall-untrusted-callee.md
  30. ... # 36 reference files total
  31. ```
  32. Each full reference file contains: **Preconditions**, **Vulnerable Pattern** (annotated Solidity), **Detection Heuristics**, **False Positives**, and **Remediation**.

Ratings and comments

Sign in to rate this skill.

Sign in

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