Rust Guard Auditor — Check Your Rust Runtime Guard Actually

You bought a runtime guard for Rust. It logs every dangerous command. It asks for confirmation. It looks secure. Then you find out the guard only wraps std::process::Command — and your agent used tokio::process::Command or libc::execl. Or the child process inherited every environment variable, including your API keys. Or there is no audit trail. None of this throws an error. The guard just silently covers less than you think.

Rust Guard Auditor is a static auditor for Rust that checks whether a runtime guard actually wraps every execution point. It finds std::process::Command, tokio::process::Command, async_std::process::Command, and the libc family — libc::execv, execve, execvp, execl, execlp, posix_spawn — then checks each against six rules: is the call wrapped by a guard, is there a network allowlist, is there an audit trail, is there a human-confirmation fallback, is the guard bypassed via libc, is the child environment isolated. It runs nothing, intercepts nothing, and returns a strict JSON report with line numbers and typed signatures.

What it does

• Guard coverage check — flags every std, tokio, and async-std Command call not wrapped by a guard function.
• libc bypass detection — catches libc::execl, execlp, execv, execve, execvp, and posix_spawn that skip process-level guards.
• Network allowlist check — verifies outbound calls are restricted.
• Audit trail check — flags calls with no logging.
• Human confirmation fallback — flags calls with no approval gate.
• Child environment isolation — flags calls with no explicit .env() or .env_clear().
• Strict JSON output — audit_status, findings with line numbers, severity, typed signatures.
• Runs nothing — static analysis only.

Why it matters

A runtime guard that covers 80% of execution points is worse than no guard at all — it gives you confidence you should not have. The 20% that slips through is where the incident happens. In Rust, libc::execl and posix_spawn bypass std::process::Command entirely — if your guard sits at the process layer, it is not protecting you. Async pipelines on tokio or async-std add another path. This auditor tells you whether your Rust guard actually covers everything, before an unguarded call reaches production.

Test Protocol — 12/12 tests passed

Verified on 2026-10-06 on Python 3.14.7. Contract testing on test harness.

• 3 positive cases: clean, warning, critical. Result: PASS.
• 3 negative cases: missing field, bad status, unknown signature. Result: PASS.
• 3 edge cases: empty findings with critical status, non-ISO timestamp, negative line number. Result: PASS.
• 3 contradiction cases: clean with findings, warning with HIGH, critical without HIGH. Result: PASS.

Verdict: contract satisfied.

Use cases

• Verifying that a runtime guard you bought actually wraps every Rust shell call.
• Auditing a multi-agent pipeline where one agent writes Rust and another executes it.
• Catching libc::execl and posix_spawn bypasses that skip process-level guards.
• Checking that async tokio or async-std Command calls are also covered.
• Checking that child processes do not inherit secrets via std::env::vars().
• Reviewing AI-generated Rust code before it reaches a CI/CD environment.

Known limitations

• Static analysis only — reads code, does not execute it. Runtime behavior is out of scope.
• Rust only — does not scan Python, JavaScript, or Go.
• Audits configuration, does not enforce — checks that the guard is wired correctly, it does not intercept commands itself.
• No correctness analysis — judges guard coverage, not whether commands are safe to run.
• Read-only — does not modify code, install packages, or write files.
• Does not detect Command::new reassigned to a variable before .output() is called. In that case the audit may flag a false positive — verify findings manually before acting on them.
• async_std::process::Command is detected when present in the scanned files, but the live run does not exercise it — detection relies on the same AST rules as tokio::process::Command.
• Severity reflects guard coverage, not command danger. An unguarded ls -la is flagged HIGH because it bypasses the guard layer — the audit judges whether the guard wraps the call, not whether the command itself is destructive.
• Requires source access. Needs the .rs files to scan.