coldvault.dev — by ZONOVA RESEARCH — a drop-in sandbox for auditing code you don't trust. Clone it, open a GitHub Codespace, point Claude Code at a suspect repository, receive a consolidated security report.

Cold because the code is never executed — it stays frozen while you inspect it. Vault because the analysis happens behind armoured walls.

License: MIT (ZONOVA RESEARCH) Powered by Claude Code Devcontainer

A public, reproducible audit environment that lets a security analyst (or a Claude Code agent) statically review an untrusted repository without ever executing its code. A curated set of core scanners — SAST, SCA, secrets, malware, IaC — is pre-baked into a lean Debian devcontainer. Language-specific and heavyweight optional tools can be added on demand in under a minute.

Design tenets

• 🧊 Never run untrusted code. The suspect repo is mounted as a read-only git submodule under target/. All analysis is static.
• 🪶 Lean core, extensible. The base image ships only the tools needed for a full general-purpose audit. Optional tool groups (Rust, Java, PHP, C/C++, extra scanners...) are installed on demand via a single script.
• 🤖 Agent-assisted. A curated set of Claude Code skills (inspired by trailofbits/skills, anthropics/claude-code-security-review and Snyk's workflow) turn the analyst's intent into reproducible scans.
• 📖 Reproducible. Findings land in reports/ as JSON/SARIF plus a Markdown summary — nothing is left to memory.

flowchart LR
 U[Analyst] -->|1. clone public audit repo| R[coldvault]
 R -->|2. Open in Codespace| CS{{GitHub Codespace}}
 CS -->|3. gh auth login<br/>claude login| A[Authenticated session]
 A -->|4. git submodule add SUSPECT target/| T[target/ read-only]
 A -->|5. claude → /audit| C[Claude Code + skills]
 C -->|invokes wrappers| S[scripts/scan-*.sh]
 S --> TL[[Pre-installed tool stack]]
 TL -->|SARIF/JSON| RP[reports/]
 RP -->|findings.json + SUMMARY.md| U
 classDef toxic fill:#fee,stroke:#c00,stroke-width:2px;
 class T toxic;

Five commands, start to finish:

git clone https://github.com/rasata/coldvault.dev
cd coldvault.dev
# → Click "Open in GitHub Codespaces"
gh auth login && claude login
git submodule add <SUSPECT-REPO-URL> target/
export COLDVAULT_ACCEPTABLE_USE=defensive-security-research-only
claude # then type /audit

flowchart TB
 subgraph INPUT["target/ — untrusted submodule"]
 SRC[source files]
 LOCK[lockfiles]
 CI[.github/workflows]
 BIN[binaries / images]
 IAC[Terraform / K8s / Dockerfile]
 end
 subgraph SECRETS["🔑 Secrets"]
 gitleaks
 trufflehog
 detect-secrets
 ggshield
 end
 subgraph SCA["📦 Supply-chain / SCA"]
 osv[osv-scanner]
 trivy
 grype
 syft
 depcheck[OWASP Dependency-Check]
 npm-audit
 pip-audit
 govulncheck
 cargo-audit
 cargo-deny
 bundler-audit
 snyk
 end
 subgraph SAST["🔍 SAST"]
 semgrep
 bandit
 njsscan
 gosec
 staticcheck
 clippy
 cppcheck
 flawfinder
 clang-tidy
 psalm
 phpstan
 brakeman
 eslint-sec[eslint + security plugins]
 retire
 end
 subgraph MAL["🦠 Malware / binary"]
 yara
 yarax[YARA-X]
 capa
 binwalk
 clamav
 oletools
 radare2
 end
 subgraph IACSCAN["🏗️ IaC / container"]
 tfsec
 terrascan
 checkov
 hadolint
 dockle
 kubesec
 kubescore[kube-score]
 trivyfs[trivy fs/image/config]
 end
 SRC --> SECRETS
 SRC --> SAST
 LOCK --> SCA
 CI --> SAST
 CI --> MAL
 BIN --> MAL
 IAC --> IACSCAN
 SECRETS --> REP[(reports/)]
 SCA --> REP
 SAST --> REP
 MAL --> REP
 IACSCAN --> REP

flowchart LR
 subgraph HOST["Your laptop"]
 UA[Analyst]
 end
 subgraph CODESPACE["GitHub Codespace (ephemeral VM)"]
 direction TB
 CL[Claude Code CLI]
 FS[".devcontainer image<br/>core security tools"]
 TG[target/ submodule<br/>READ-ONLY]
 RS[reports/]
 end
 UA -- browser / VS Code --> CL
 CL -- static scans --> TG
 CL -- writes --> RS
 CL -. never executes .-> TG
 style TG fill:#fee,stroke:#c00,stroke-width:2px
 style CODESPACE fill:#f5f7ff,stroke:#446

• Ephemeral VM: compromise of the audit run cannot persist to the analyst's laptop — only the Codespace is at risk, and it is thrown away.
• No local installs: avoids "npm install is already RCE" on the host.
• Submodule pointer only: the target/ commit is recorded, so the audit is reproducible and its scope is auditable.
• Read-only tool paths: system tools live under /usr/local/bin owned by root; the agent runs as vscode.

.
├── .devcontainer/
│ ├── Dockerfile # Debian + core security tools (minimal base)
│ ├── devcontainer.json # Codespace config, no-new-privileges, dropped caps
│ ├── post-create.sh # DB warm-up, core tool smoke-test
│ └── install-optional-tools.sh # On-demand optional tool groups
├── .claude/
│ ├── settings.json # Restrictive permissions for target/
│ ├── commands/ # /audit, /scan-secrets, /scan-deps, /scan-malware, /security-review
│ └── skills/ # 15+ curated security skills
├── scripts/ # Bash wrappers (SARIF/JSON output to reports/)
│ ├── audit-all.sh
│ ├── scan-secrets.sh
│ ├── scan-deps.sh
│ ├── scan-sast.sh
│ ├── scan-malware.sh
│ ├── scan-iac.sh
│ └── scan-containers.sh
├── rules/
│ ├── semgrep/ # Custom project-specific rules
│ └── yara/ # Custom malware signatures
├── reports/ # (gitignored) — audit output lives here
├── target/ # Suspect code (git submodule)
├── CLAUDE.md # Audit protocol & safety rules
├── LICENSE # MIT — ZONOVA RESEARCH variant
└── README.md

Inspired by Trail of Bits' skills, Anthropic's security-review action, and Snyk's Code/OS workflow:

See .claude/skills/ for full documentation of each.

/audit Full pipeline — context → secrets → SCA → SAST → malware → report
/scan-secrets Run secret scanners only
/scan-deps Supply-chain / SCA pass only
/scan-sast Static analysis pass only
/scan-malware YARA + capa + binary triage
/scan-iac Terraform / K8s / Dockerfile
/security-review PR-mode: review only the diff in target/ (HEAD vs. base)

Every run produces:

• reports/findings.json — machine-readable, matches the schema in CLAUDE.md §4.
• reports/SUMMARY.md — human-readable executive summary.
• reports/<tool>.sarif / reports/<tool>.json — raw per-tool output.
• reports/sbom.cdx.json — CycloneDX SBOM of target/.

# 1. Clone this repo
git clone https://github.com/rasata/coldvault.dev.git
cd coldvault.dev
# 2. Open in GitHub Codespaces
# (click the "Code" button → "Codespaces" → "Create codespace on main")
# The devcontainer image pre-installs all scanners.
# 3. Inside the Codespace terminal.
# Claude CLI and GitHub CLI are ALREADY installed by the devcontainer image
# (see .devcontainer/Dockerfile §7). You only need to authenticate:
gh auth login # browser flow
claude login # Claude Code auth
# 4. Attach the suspect repo as a READ-ONLY submodule
git submodule add --depth=1 https://github.com/<suspect>/<repo>.git target/
# 5. Acknowledge defensive-use policy (required by scan scripts)
export COLDVAULT_ACCEPTABLE_USE=defensive-security-research-only
# 6. Launch the audit
claude
# > /audit
# 7. Open reports/SUMMARY.md

The public landing page served at https://coldvault.dev lives in this same repo under website/ — a Vite + React + TanStack Router static SPA. It is self-contained (no external submodule, no private upstream, no on-premise deployment path).

cd website
npm ci
npm run dev # local preview on :8080
npm run build # static artifact in website/dist

Deployment is automated by .github/workflows/deploy-pages.yml — every push to main that touches website/** builds the SPA and publishes it to GitHub Pages behind the coldvault.dev custom domain. The only authoritative origin is https://coldvault.dev; see website/IMPERSONATION.md for the anti-impersonation controls and the one-time DNS setup.

The base devcontainer image ships a lean core stack. Language-specific and heavyweight tools are installed on demand using the bundled installer script.

# Install everything (all groups)
bash .devcontainer/install-optional-tools.sh
# Install one or more specific groups
bash .devcontainer/install-optional-tools.sh rust
bash .devcontainer/install-optional-tools.sh sca iac

When run as a non-root user (the default vscode devcontainer user), the installer automatically redirects pipx, npm -g, and go install outputs to user-writable paths (~/.local/bin, ~/.npm-global/bin, ~/go/bin) — no sudo required for those operations. Only apt-get and system-level package operations still use sudo.

Note: Add the user paths to your shell profile to make them permanent:

export PATH="$HOME/.local/bin:$HOME/.npm-global/bin:$HOME/go/bin:$PATH"

Tip: The installer is idempotent — re-running it for a group that is already installed is safe.

If you regularly use a set of optional tools, create a derived image:

FROM ghcr.io/rasata/coldvault.dev:latest
RUN bash .devcontainer/install-optional-tools.sh rust sca malware

Or add the groups you need to the postCreateCommand in your fork's devcontainer.json:

"postCreateCommand": "bash .devcontainer/post-create.sh && bash .devcontainer/install-optional-tools.sh rust sca"

• Add a new core scanner → edit .devcontainer/Dockerfile + a wrapper in scripts/.
• Add a new optional scanner → edit .devcontainer/install-optional-tools.sh + a wrapper in scripts/.
• Add a new Claude skill → drop a SKILL.md under .claude/skills/<name>/.
• Add project-specific Semgrep rules → rules/semgrep/*.yml.
• Add project-specific YARA rules → rules/yara/*.yar.

PRs welcome. Do not include real-world malware samples or live secrets.

• Forks and redistributions must keep LICENSE, DISCLAIMER.md, and visible attribution to ZONOVA RESEARCH — https://zonova.io .
• Scan scripts now require explicit acknowledgement: COLDVAULT_ACCEPTABLE_USE=defensive-security-research-only.
• This project is for authorized defensive security work only; offensive or unlawful use is prohibited.

See DISCLAIMER.md and LICENSE for full terms.

MIT License — ZONOVA RESEARCH variant. See LICENSE.

If you redistribute or build on this project, credit ZONOVA RESEARCH — https://zonova.io in your README or About dialog.

This project assembles, wraps, and credits the work of many open-source teams:

• Semgrep, Trail of Bits, Anchore, Aqua Security, Google OSV, GitLeaks, Trufflehog, YARA / VirusTotal, Snyk OSS, OWASP, Anthropic (Claude Code + security-review).
• Skill patterns derived from trailofbits/skills and anthropics/claude-code-security-review.

coldvault.dev · Powered by ZONOVA RESEARCH · Made for defenders.