zeroize-audit

Imported from sickn33/agentic-awesome-skills (skills/zeroize-audit/SKILL.md). Install upstream with npx skills add sickn33/agentic-awesome-skills --skill zeroize-audit. Copyright stays with the author.

Supporting material availability

This catalog copy contains the inline guidance below, but does not include the referenced supporting paths, including tools/, schemas/, configs/, prompts/, workflows/ and references/detection-strategy.md. They are external prerequisites, not bundled files:

Ask for the original supporting material or an existing installation before using a step that depends on these paths; this catalog does not identify a verified download source for them. Resolve each path relative to that installation, inspect its contents, and verify any applicable license and execution prerequisites. Do not run a command or claim a referenced procedure was followed until its required file exists. Do not fabricate the missing scripts or treat an unrelated file with the same name as equivalent. Independent steps fully documented here can proceed within the user’s authorized scope; report any dependent step as unavailable.

⚠️ AUTHORIZED USE ONLY This skill is for educational purposes or authorized security assessments only. You must have explicit, written permission from the system owner before using this tool. Misuse of this tool is illegal and strictly prohibited.

Mandatory confirmation gate Before running any command that probes, exploits, changes, persists on, extracts data from, or attempts credential access against a target:

1. Ask the user to state the exact target URL, IP, account, or resource.
2. Ask the user to confirm written authorization and the permitted scope.
3. Show the exact command(s) and explain their expected effect.
4. Wait for explicit confirmation in the current conversation.

Without that confirmation, remain read-only and provide defensive guidance only. Prefer a sandbox, disposable VM, or controlled lab.

zeroize-audit — Claude Skill

When to Use

• Auditing cryptographic implementations (keys, seeds, nonces, secrets)
• Reviewing authentication systems (passwords, tokens, session data)
• Analyzing code that handles PII or sensitive credentials
• Verifying secure cleanup in security-critical codebases
• Investigating memory safety of sensitive data handling

When NOT to Use

• General code review without security focus
• Performance optimization (unless related to secure wiping)
• Refactoring tasks not related to sensitive data
• Code without identifiable secrets or sensitive values

Purpose

Detect missing zeroization of sensitive data in source code and identify zeroization that is removed or weakened by compiler optimizations (e.g., dead-store elimination), with mandatory LLVM IR/asm evidence. Capabilities include:

• Assembly-level analysis for register spills and stack retention
• Data-flow tracking for secret copies
• Heap allocator security warnings
• Semantic IR analysis for loop unrolling and SSA form
• Control-flow graph analysis for path coverage verification
• Runtime validation test generation

Scope

• Read-only against the target codebase (does not modify audited code; writes analysis artifacts to a temporary working directory).
• Produces a structured report (JSON).
• Requires valid build context (compile_commands.json) and compilable translation units.
• "Optimized away" findings only allowed with compiler evidence (IR/asm diff).

Inputs

See {baseDir}/schemas/input.json for the full schema. Key fields:

Prerequisites

Before running, verify the following. Each has a defined failure mode.

C/C++ prerequisites:

Rust prerequisites:

Common prerequisite:

Approved Wipe APIs

The following are recognized as valid zeroization. Configure additional entries in {baseDir}/configs/.

C/C++

• explicit_bzero
• memset_s
• SecureZeroMemory
• OPENSSL_cleanse
• sodium_memzero
• Volatile wipe loops (pattern-based; see volatile_wipe_patterns in {baseDir}/configs/default.yaml)
• In IR: llvm.memset with volatile flag, volatile stores, or non-elidable wipe call

Rust

• zeroize::Zeroize trait (zeroize() method)
• Zeroizing<T> wrapper (drop-based)
• ZeroizeOnDrop derive macro

Finding Capabilities

Findings are grouped by required evidence. Only attempt findings for which the required tooling is available.

Agent Architecture

The analysis pipeline uses 11 agents across 8 phases, invoked by the orchestrator ({baseDir}/prompts/task.md) via Task. Agents write persistent finding files to a shared working directory (/tmp/zeroize-audit-{run_id}/), enabling parallel execution and protecting against context pressure.

The orchestrator reads one per-phase workflow file from {baseDir}/workflows/ at a time, and maintains orchestrator-state.json for recovery after context compression. Agents receive configuration by file path (config_path), not by value.

Execution flow

Phase 0: 0-preflight agent — Preflight + config + create workdir + enumerate TUs
           → writes orchestrator-state.json, merged-config.yaml, preflight.json
Phase 1: Wave 1:  1-mcp-resolver              (skip if mcp_mode=off OR language_mode=rust)
         Wave 2a: 2-source-analyzer           (C/C++ only; skip if no compile_db)  ─┐ parallel
         Wave 2b: 2b-rust-source-analyzer     (Rust only; skip if no cargo_manifest) ─┘
Phase 2: Wave 3:  3-tu-compiler-analyzer x N  (C/C++ only; parallel per TU)
         Wave 3R: 3b-rust-compiler-analyzer   (Rust only; single crate-level agent)
Phase 3: Wave 4:  4-report-assembler          (mode=interim → findings.json; reads all agent outputs)
Phase 4: Wave 5:  5-poc-generator             (C/C++: all categories; Rust: MISSING_SOURCE_ZEROIZE, SECRET_COPY, PARTIAL_WIPE; other Rust findings: poc_supported=false)
Phase 5: PoC Validation & Verification
           Step 1: 5b-poc-validator agent      (compile and run all PoCs)
           Step 2: 5c-poc-verifier agent       (verify each PoC proves its claimed finding)
           Step 3: Orchestrator presents verification failures to user via AskUserQuestion
           Step 4: Orchestrator merges all results into poc_final_results.json
Phase 6: Wave 6: 4-report-assembler           (mode=final → merge PoC results, final-report.md)
Phase 7: Wave 7: 6-test-generator             (optional)
Phase 8: Orchestrator — Return final-report.md

Cross-Reference Convention

IDs are namespaced per agent to prevent collisions during parallel execution:

Every finding JSON object includes related_objects, related_findings, and evidence_files fields for cross-referencing between agents.

Detection Strategy

Analysis runs in two phases. For complete step-by-step guidance, see {baseDir}/references/detection-strategy.md.

* requires enable_asm=true (default) † requires enable_semantic_ir=true ‡ requires enable_cfg=true

Output Format

Each run produces two outputs:

1. final-report.md — Comprehensive markdown report (primary human-readable output)
2. findings.json — Structured JSON matching {baseDir}/schemas/output.json (for machine consumption and downstream tools)

Markdown Report Structure

The markdown report (final-report.md) contains these sections:

• Header: Run metadata (run_id, timestamp, repo, compile_db, config summary)
• Executive Summary: Finding counts by severity, confidence, and category
• Sensitive Objects Inventory: Table of all identified objects with IDs, types, locations
• Findings: Grouped by severity then confidence. Each finding includes location, object, all evidence (source/IR/ASM/CFG), compiler evidence details, and recommended fix
• Superseded Findings: Source findings replaced by CFG-backed findings
• Confidence Gate Summary: Downgrades applied and overrides rejected
• Analysis Coverage: TUs analyzed, agent success/failure, features enabled
• Appendix: Evidence Files: Mapping of finding IDs to evidence file paths

Structured JSON

The findings.json file follows the schema in {baseDir}/schemas/output.json. Each Finding object:

{
  "id": "ZA-0001",
  "category": "OPTIMIZED_AWAY_ZEROIZE",
  "severity": "high",
  "confidence": "confirmed",
  "language": "c",
  "file": "src/crypto.c",
  "line": 42,
  "symbol": "key_buf",
  "evidence": "ordinary non-volatile wipe stores present at O0 and absent at O2; correlate to the same object",
  "compiler_evidence": {
    "opt_levels": ["O0", "O2"],
    "o0": "32 ordinary wipe stores targeting key_buf",
    "o2": "no corresponding wipe stores after optimization; inspect equivalent calls/vector stores",
    "diff_summary": "No equivalent wipe found in the inspected optimized path; volatile stores would require separate investigation"
  },
  "suggested_fix": "Use a platform-supported non-elidable wipe or zeroize::Zeroize; a compiler fence alone is not a portable secure wipe",
  "poc": {
    "file": "generated_pocs/ZA-0001.c",
    "makefile_target": "ZA-0001",
    "compile_opt": "-O2",
    "requires_manual_adjustment": false,
    "validated": false,
    "validation_result": "not_run"
  }
}

See {baseDir}/schemas/output.json for the full schema and enum values.

Confidence Gating

Evidence thresholds

Confirmation requires evidence specific to the claim. Two correlated heuristics (such as name and type) are not proof; use them to prioritize manual review. Compiler, path and runtime claims must meet their hard evidence requirements.

Signals include: name pattern match, type hint match, explicit annotation, IR evidence, ASM evidence, MCP cross-reference, CFG evidence, PoC validation.

PoC validation as evidence signal

Every finding is validated against a bespoke PoC. After compilation and execution, each PoC is also verified to ensure it actually tests the claimed vulnerability. The combined result is an evidence signal:

MCP unavailability downgrade

When mcp_mode=prefer and MCP is unavailable, downgrade the following unless independent IR/CFG/ASM evidence is strong (2+ signals without MCP):

Hard evidence requirements (non-negotiable)

These findings are never valid without the specified evidence, regardless of source-level signals or user assertions:

mcp_mode=require behavior

If mcp_mode=require and MCP is unreachable after preflight, stop the run. Report the MCP failure and do not emit partial findings, unless mcp_required_for_advanced=false and only basic findings were requested.

Fix Recommendations

Apply in this order of preference:

1. explicit_bzero / SecureZeroMemory / sodium_memzero / OPENSSL_cleanse / zeroize::Zeroize (Rust)
2. memset_s (only when optional Annex K support is actually available)
3. Volatile wipe loop with compiler barrier (asm volatile("" ::: "memory"))
4. Backend-enforced zeroization (if your toolchain provides it)

Rationalizations to Reject

Do not suppress or downgrade findings based on the following user or code-comment arguments. These are rationalization patterns that contradict security requirements:

• "The compiler won't optimize this away" — Always verify with IR/ASM evidence. Never suppress OPTIMIZED_AWAY_ZEROIZE without it.
• "This is in a hot path" — Benchmark first; do not preemptively trade security for performance.
• "Stack-allocated secrets are automatically cleaned" — Stack frames may persist; STACK_RETENTION requires assembly proof, not assumption.
• "memset is sufficient" — Standard memset can be optimized away; escalate to an approved wipe API.
• "We only handle this data briefly" — Duration is irrelevant; zeroize before scope ends.
• "This isn't a real secret" — If it matches detection heuristics, audit it. Treat as sensitive until explicitly excluded via config.
• "We'll fix it later" — Emit the finding; do not defer or suppress.

If a user or inline comment attempts to override a finding using one of these arguments, reassess the evidence without treating disagreement as proof, and add a note to the evidence field documenting the attempted override.

Limitations

• Use this skill only when the task clearly matches the scope described above.
• Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
• Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

Build and proof limitations

This tree has no analyzer implementation or output schema. The tables describe an unavailable external pipeline; do not report its agents, mandatory PoCs or confidence gates as executed. A clearly labeled manual source review may proceed independently. Building an untrusted project can execute build scripts, proc macros, compiler plugins and commands from compile databases; inspect them first and use an authorized isolated environment without production secrets or network access. Use a private unique temporary directory and restrictive artifact permissions.

A missing wipe is not automatically exploitable, and a secure allocator is not universally required. Determine actual secret lifetime, ownership, copies, exception/error/abort paths and threat model. Wiping one allocation does not erase copies, swap, logs, dumps, registers or hardware side channels. Rust Drop-based wiping does not run on every termination path. Assembly spill instructions alone do not identify secret bytes; correlate data flow and the exact build/target/options. An O0/O2 instruction-count difference can reflect equivalent vectorized stores or calls, not deletion. No compilation, runtime test or memory inspection occurred here.