securevibe 0.1.0

package/dist/engine/detectors/secrets.js

@@ -0,0 +1,71 @@
+/**
+ * Hardcoded-secret detection (doc 03). Text-level so it covers .env, config,
+ * and any file — not just parseable source. Provider-format + high-entropy.
+ */
+import { createHash } from "node:crypto";
+// Ordered most-specific → most-generic. One finding per line: the first rule
+// that matches wins, so a provider key isn't also reported as a generic secret.
+const RULES = [
+    { name: "Anthropic API key", re: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/, severity: "high" },
+    { name: "OpenAI API key", re: /\bsk-(proj-)?[A-Za-z0-9_-]{20,}\b/, severity: "high" },
+    { name: "AWS access key id", re: /\bAKIA[0-9A-Z]{16}\b/, severity: "critical" },
+    { name: "GitHub token", re: /\bghp_[A-Za-z0-9]{36,}\b/, severity: "high" },
+    { name: "Google API key", re: /\bAIza[0-9A-Za-z_-]{35}\b/, severity: "high" },
+    { name: "Stripe secret key", re: /\bsk_live_[0-9a-zA-Z]{24,}\b/, severity: "critical" },
+    { name: "Slack token", re: /\bxox[baprs]-[0-9A-Za-z-]{10,}\b/, severity: "high" },
+    { name: "Private key block", re: /-----BEGIN (RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/, severity: "critical" },
+    { name: "Password in connection string", re: /[a-z]+:\/\/[^:\s/]+:[^@\s/]{4,}@/i, severity: "high" },
+    // Case-sensitive: real env keys are UPPER_SNAKE; this won't match `liveSecret = x`.
+    // Gated to env files so `const X = process.env.Y` in code isn't flagged.
+    { name: "Secret in env assignment", re: /\b[A-Z][A-Z0-9_]*(?:SECRET|PASSWORD|PASSWD|API_?KEY|TOKEN|ACCESS_?KEY|PRIVATE_?KEY)[A-Z0-9_]*\s*=\s*[^\s"'#]{8,}/, severity: "high", envOnly: true },
+    { name: "Generic assigned secret", re: /(?:secret|password|passwd|api[_-]?key|token)\s*[:=]\s*["'][A-Za-z0-9_\-./+]{12,}["']/i, severity: "medium" },
+];
+/** True for files where a committed secret is especially dangerous. */
+function isEnvLike(relPath) {
+    return /(^|\/|\\)\.env(\.|$)|\.env\.|config\.(json|ya?ml)$/i.test(relPath);
+}
+export function detectSecrets(relPath, code) {
+    const out = [];
+    const envLike = isEnvLike(relPath);
+    const activeRules = RULES.filter((r) => !r.envOnly || envLike);
+    const lines = code.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // First matching rule wins for this line (rules ordered specific→generic).
+        const rule = activeRules.find((r) => r.re.test(line));
+        if (!rule)
+            continue;
+        const m = rule.re.exec(line);
+        if (!m)
+            continue;
+        {
+            const envBoost = isEnvLike(relPath);
+            const dedupeKey = `${relPath}:${i}:${rule.name}`;
+            out.push({
+                id: createHash("sha1").update(dedupeKey).digest("hex").slice(0, 12),
+                detector: "hardcoded-secret",
+                title: `Hardcoded secret: ${rule.name}`,
+                category: "classic",
+                severity: envBoost && rule.severity !== "critical" ? "high" : rule.severity,
+                confidence: rule.name === "Generic assigned secret" ? 0.55 : 0.9,
+                reachable: true,
+                cwe: "CWE-798",
+                owasp: "A07:2021 Identification and Authentication Failures",
+                mitre: "T1552.001",
+                file: relPath,
+                line: i + 1,
+                column: Math.max(1, line.indexOf(m[0]) + 1),
+                evidence: redact(line.trim(), m[0]),
+                why: "A live credential is committed to the repository. Anyone with repo access (or anyone the repo is leaked to) can use it directly.",
+                fix: "Remove the secret, rotate it immediately, load it from a secrets manager / environment at runtime, and add the file to .gitignore. Treat the committed value as compromised.",
+            });
+        }
+    }
+    return out;
+}
+function redact(line, secret) {
+    if (secret.length <= 8)
+        return line.replace(secret, "****");
+    const masked = secret.slice(0, 4) + "…" + secret.slice(-2);
+    return line.replace(secret, masked);
+}

package/dist/engine/detectors/util.js

@@ -0,0 +1,28 @@
+import { createHash } from "node:crypto";
+import { loc, lineOf } from "../ast.js";
+/** Build a finding with a stable id (the `node_key` analogue from doc 03/10). */
+export function mkFinding(ctx, draft) {
+    const position = draft.node ? loc(draft.node) : { line: draft.line ?? 1, column: draft.column ?? 1 };
+    const evidence = draft.evidence ?? lineOf(ctx.file.code, position.line);
+    const stableKey = `${ctx.file.relPath}:${draft.detector}:${position.line}:${draft.title}`;
+    const id = createHash("sha1").update(stableKey).digest("hex").slice(0, 12);
+    return {
+        id,
+        detector: draft.detector,
+        title: draft.title,
+        category: draft.category,
+        severity: draft.severity,
+        confidence: draft.confidence,
+        reachable: draft.reachable,
+        cwe: draft.cwe,
+        owasp: draft.owasp,
+        mitre: draft.mitre,
+        file: ctx.file.relPath,
+        line: position.line,
+        column: position.column,
+        evidence,
+        why: draft.why,
+        fix: draft.fix,
+        taint: draft.taint,
+    };
+}

package/dist/engine/fix/deterministic.js

@@ -0,0 +1,335 @@
+/**
+ * Deterministic fixers (doc 05) — the offline floor. These are safe, rule-based
+ * code transforms for vulnerability classes whose fix is unambiguous. They run
+ * with zero setup (no API key, no network) and are fully reproducible.
+ *
+ * Each fixer rewrites *all* occurrences of its pattern in a file in one pass, so
+ * we never depend on stale line numbers (no offset drift between edits).
+ * Anything ambiguous is deliberately left to the LLM fixer or to a manual note —
+ * a transform that might break the app is worse than no transform.
+ */
+import path from "node:path";
+import { parse, langForExtension } from "../parser.js";
+import { walk, isCall, calleeLastSegment } from "../ast.js";
+import { lookup } from "../deps/db.js";
+import { parseManifest } from "../deps/manifests.js";
+import { isVulnerable, minFixedVersion } from "../deps/match.js";
+/** Detectors a deterministic fixer can address. */
+export const DETERMINISTIC_DETECTORS = new Set([
+    "cors-misconfig",
+    "weak-jwt",
+    "hardcoded-secret",
+    "sql-injection",
+    "vulnerable-dependency",
+]);
+export async function deterministicFix(input) {
+    const result = {
+        code: input.code,
+        attempted: new Set(),
+        manual: new Map(),
+        sideEffects: [],
+    };
+    fixCors(input, result);
+    fixJwt(input, result);
+    fixSecrets(input, result);
+    await fixSql(input, result);
+    fixDeps(input, result);
+    return result;
+}
+/** Mark every finding of `detector` in the file as attempted. */
+function markAttempted(input, result, detector) {
+    for (const f of input.findings) {
+        if (f.detector === detector)
+            result.attempted.add(f.id);
+    }
+}
+// ── CORS ──────────────────────────────────────────────────────────────────
+// Wildcard Access-Control-Allow-Origin → an env-driven allowlist. Never pair a
+// wildcard with credentials.
+function fixCors(input, result) {
+    if (!input.findings.some((f) => f.detector === "cors-misconfig"))
+        return;
+    let code = result.code;
+    const before = code;
+    // Next.js header form: { key: "Access-Control-Allow-Origin", value: "*" }
+    code = code.replace(/(["']Access-Control-Allow-Origin["'][\s\S]{0,40}?value\s*:\s*)["']\*["']/gi, '$1process.env.ALLOWED_ORIGIN ?? ""');
+    // setHeader / header form: "Access-Control-Allow-Origin", "*"
+    code = code.replace(/(["']Access-Control-Allow-Origin["']\s*,\s*)["']\*["']/gi, '$1process.env.ALLOWED_ORIGIN ?? ""');
+    // cors() lib form: origin: "*"
+    code = code.replace(/(\borigin\s*:\s*)["']\*["']/gi, "$1process.env.ALLOWED_ORIGIN");
+    if (code !== before) {
+        result.code = code;
+        markAttempted(input, result, "cors-misconfig");
+    }
+}
+// ── Weak JWT ─────────────────────────────────────────────────────────────
+// The 'none' algorithm → RS256.
+function fixJwt(input, result) {
+    if (!input.findings.some((f) => f.detector === "weak-jwt"))
+        return;
+    const before = result.code;
+    const code = before.replace(/(alg(?:orithm)?s?\s*[:=]\s*\[?\s*["'])none(["'])/gi, "$1RS256$2");
+    if (code !== before) {
+        result.code = code;
+        markAttempted(input, result, "weak-jwt");
+    }
+}
+// ── Secrets ──────────────────────────────────────────────────────────────
+// A committed secret cannot be "fixed" in place — the value is already leaked
+// and must be rotated. What we *can* do safely: ensure .env is gitignored and
+// surface a rotate-now instruction. Source-file literals are replaced with an
+// env reference so the literal stops being committed.
+function fixSecrets(input, result) {
+    const secretFindings = input.findings.filter((f) => f.detector === "hardcoded-secret");
+    if (secretFindings.length === 0)
+        return;
+    const isEnvFile = /(^|\/)\.env(\.|$)/i.test(input.relPath);
+    if (isEnvFile) {
+        // Helpful side effect, but the finding stays (the value is still in the file
+        // and was likely already committed) → honest outcome is "manual: rotate".
+        result.sideEffects.push({
+            kind: "ensure-line",
+            relPath: ".gitignore",
+            content: ".env",
+            reason: "prevent committing .env going forward",
+        });
+        for (const f of secretFindings) {
+            result.manual.set(f.id, "Added .env to .gitignore. The committed value is already exposed — rotate this credential now and load it from a secrets manager.");
+        }
+        return;
+    }
+    // Source file: replace the literal assignment with an env reference.
+    const lang = langForExtension(path.extname(input.relPath));
+    let code = result.code;
+    let changed = false;
+    const exampleKeys = [];
+    for (const f of secretFindings) {
+        const lineIdx = f.line - 1;
+        const lines = code.split(/\r?\n/);
+        const line = lines[lineIdx];
+        if (!line)
+            continue;
+        // Match `<lhs> = "<secret>"` / `<lhs>: "<secret>"` and swap the literal.
+        const m = line.match(/^(\s*(?:const|let|var|public|private)?\s*([A-Za-z_$][\w$]*)\s*[:=]\s*)(["'])(.+?)\3/);
+        if (!m)
+            continue;
+        const envName = toEnvName(m[2]);
+        const ref = lang === "python" ? `os.environ["${envName}"]` : `process.env.${envName}`;
+        lines[lineIdx] = line.replace(/(["']).+?\1/, ref);
+        code = lines.join("\n");
+        exampleKeys.push(envName);
+        changed = true;
+        result.attempted.add(f.id);
+    }
+    if (changed) {
+        result.code = code;
+        result.sideEffects.push({
+            kind: "ensure-line",
+            relPath: ".gitignore",
+            content: ".env",
+            reason: "keep real secrets out of version control",
+        });
+        if (exampleKeys.length > 0) {
+            result.sideEffects.push({
+                kind: "write-if-absent",
+                relPath: ".env.example",
+                content: exampleKeys.map((k) => `${k}=`).join("\n") + "\n",
+                reason: "document the required environment variables",
+            });
+        }
+    }
+}
+function toEnvName(identifier) {
+    return identifier
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[^A-Za-z0-9]+/g, "_")
+        .toUpperCase();
+}
+function sqlPlaceholder(lang, inv) {
+    const deps = inv.dependencies.map((d) => d.toLowerCase());
+    if (lang === "python") {
+        if (deps.some((d) => /psycopg|mysqlclient|pymysql|mariadb/.test(d)))
+            return "percent";
+        return "qmark"; // sqlite3 (stdlib) and most DB-API qmark drivers
+    }
+    if (deps.includes("pg") || deps.includes("postgres") || deps.includes("postgresql"))
+        return "numbered";
+    if (deps.some((d) => /mysql|sqlite|better-sqlite3/.test(d)))
+        return "qmark";
+    return null; // unknown driver → don't guess, leave to the LLM
+}
+const SQL_SINKS = new Set(["query", "execute", "exec", "raw", "$queryRawUnsafe", "$executeRawUnsafe"]);
+const SIMPLE_EXPR = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[(?:'[^']*'|"[^"]*"|\d+)\])*$/;
+async function fixSql(input, result) {
+    if (!input.findings.some((f) => f.detector === "sql-injection"))
+        return;
+    const lang = langForExtension(path.extname(input.relPath));
+    if (!lang)
+        return;
+    const style = sqlPlaceholder(lang, input.inventory);
+    if (!style)
+        return;
+    let root;
+    try {
+        ({ root } = await parse(result.code, lang));
+    }
+    catch {
+        return;
+    }
+    const edits = [];
+    walk(root, (n) => {
+        if (!isCall(n))
+            return;
+        const last = calleeLastSegment(n);
+        if (!last || !SQL_SINKS.has(last))
+            return;
+        const argsNode = n.childForFieldName("arguments");
+        if (!argsNode || argsNode.namedChildCount !== 1)
+            return; // already has params, or none
+        const arg = argsNode.namedChild(0);
+        if (!arg)
+            return;
+        const converted = lang === "python" ? convertPyFString(arg, style) : convertJsTemplate(arg, style);
+        if (converted)
+            edits.push({ start: arg.startIndex, end: arg.endIndex, text: converted });
+    });
+    if (edits.length === 0)
+        return;
+    // Apply from last to first so earlier offsets stay valid.
+    edits.sort((a, b) => b.start - a.start);
+    let code = result.code;
+    for (const e of edits)
+        code = code.slice(0, e.start) + e.text + code.slice(e.end);
+    result.code = code;
+    markAttempted(input, result, "sql-injection");
+}
+/** `` `… ${a} …` `` → `'… <ph> …', [a]`  (returns null if not safely convertible). */
+function convertJsTemplate(arg, style) {
+    if (arg.type !== "template_string")
+        return null;
+    const raw = arg.text;
+    if (!raw.startsWith("`") || !raw.endsWith("`"))
+        return null;
+    const inner = raw.slice(1, -1);
+    if (/[\r\n]/.test(inner))
+        return null; // keep it to single-line, simple cases
+    const params = [];
+    let bad = false;
+    let n = 0;
+    const sql = inner.replace(/\$\{\s*([^}]+?)\s*\}/g, (_m, expr) => {
+        if (!SIMPLE_EXPR.test(expr.trim()))
+            bad = true;
+        params.push(expr.trim());
+        n += 1;
+        return placeholder(style, n);
+    });
+    if (bad || params.length === 0)
+        return null;
+    return `'${escapeSingle(sql)}', [${params.join(", ")}]`;
+}
+/** `f"… {a} …"` → `"… <ph> …", (a,)`  (returns null if not safely convertible). */
+function convertPyFString(arg, style) {
+    if (arg.type !== "string")
+        return null;
+    const raw = arg.text;
+    const m = raw.match(/^([a-zA-Z]*)(['"]{1,3})([\s\S]*)\2$/);
+    if (!m)
+        return null;
+    const prefix = m[1].toLowerCase();
+    if (!prefix.includes("f"))
+        return null; // only f-strings carry interpolation
+    if (prefix.includes("r"))
+        return null; // raw f-strings: leave alone
+    const quote = m[2];
+    if (quote.length !== 1)
+        return null; // skip triple-quoted multi-line
+    const inner = m[3];
+    if (/\{\{|\}\}/.test(inner))
+        return null; // escaped braces → too subtle, bail
+    const params = [];
+    let bad = false;
+    let n = 0;
+    const sql = inner.replace(/\{\s*([^}{]+?)\s*\}/g, (_mm, expr) => {
+        const e = expr.split(/[:!]/)[0].trim(); // drop format spec / conversion
+        if (!SIMPLE_EXPR.test(e))
+            bad = true;
+        params.push(e);
+        n += 1;
+        return placeholder(style, n);
+    });
+    if (bad || params.length === 0)
+        return null;
+    const tuple = params.length === 1 ? `(${params[0]},)` : `(${params.join(", ")})`;
+    return `${quote}${sql}${quote}, ${tuple}`;
+}
+function placeholder(style, n) {
+    if (style === "numbered")
+        return `$${n}`;
+    if (style === "percent")
+        return "%s";
+    return "?";
+}
+function escapeSingle(s) {
+    return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+// ── Vulnerable dependencies ─────────────────────────────────────────────────
+// Bump the manifest spec to the minimum fixed version, preserving the range
+// operator (^14.x stays caret). Re-derives the target from the db so there is a
+// single source of truth. The verify gate re-matches the new version.
+function fixDeps(input, result) {
+    if (!input.depDb)
+        return;
+    if (!input.findings.some((f) => f.detector === "vulnerable-dependency"))
+        return;
+    let code = result.code;
+    let changed = false;
+    for (const dep of parseManifest(input.relPath, code)) {
+        const advisories = lookup(input.depDb, dep.ecosystem, dep.name);
+        const vulnerable = advisories.filter((a) => isVulnerable(dep.baseVersion, a.ranges));
+        if (vulnerable.length === 0)
+            continue;
+        // Highest minimum-fix across all advisories so one bump clears them all.
+        let target = null;
+        for (const a of vulnerable) {
+            const f = minFixedVersion(dep.baseVersion, a.ranges);
+            if (f && (target === null || cmpVer(f, target) > 0))
+                target = f;
+        }
+        if (!target)
+            continue; // no patched release → leave for the manual note
+        const newSpec = `${dep.rangePrefix}${target}`;
+        const replaced = replaceSpec(code, dep.ecosystem, dep.name, dep.version, newSpec);
+        if (replaced !== code) {
+            code = replaced;
+            changed = true;
+        }
+    }
+    if (changed) {
+        result.code = code;
+        markAttempted(input, result, "vulnerable-dependency");
+    }
+}
+function cmpVer(a, b) {
+    // local re-export of the deps comparator to avoid a wider import surface
+    const pa = a.split(/[-+]/)[0].split(".").map((n) => parseInt(n, 10) || 0);
+    const pb = b.split(/[-+]/)[0].split(".").map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const x = pa[i] ?? 0, y = pb[i] ?? 0;
+        if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    return 0;
+}
+function replaceSpec(code, ecosystem, name, oldSpec, newSpec) {
+    if (ecosystem === "npm") {
+        // "name": "<oldSpec>"  →  "name": "<newSpec>"
+        const re = new RegExp(`("${escapeReDep(name)}"\\s*:\\s*")${escapeReDep(oldSpec)}(")`);
+        return code.replace(re, `$1${newSpec}$2`);
+    }
+    // requirements.txt: name<op><version> on its own line
+    const re = new RegExp(`(^|\\n)(\\s*${escapeReDep(name)}\\s*)${escapeReDep(oldSpec)}`);
+    return code.replace(re, `$1$2${newSpec}`);
+}
+function escapeReDep(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/engine/fix/llm.js

@@ -0,0 +1,118 @@
+/** Detectors routed to the LLM fixer. */
+export const LLM_DETECTORS = new Set([
+    "code-execution",
+    "ai-tool-hijack",
+    "ai-missing-firewall",
+    "ai-prompt-injection",
+    "ai-overprivileged-tool",
+    "ai-rag-injection",
+    "ai-mcp-unauth",
+    "xss",
+    "broken-access-control",
+    "sql-injection", // the shapes the deterministic fixer declined
+]);
+/** Files larger than this are left to manual review (a single rewrite gets unreliable). */
+const MAX_FILE_CHARS = 16_000;
+export function defaultModel() {
+    return process.env.SECUREVIBE_MODEL || "claude-sonnet-4-6";
+}
+export function llmAvailability(disabled) {
+    const model = defaultModel();
+    if (disabled)
+        return { available: false, reason: "disabled (--no-llm)", model };
+    if (!process.env.ANTHROPIC_API_KEY)
+        return { available: false, reason: "no ANTHROPIC_API_KEY", model };
+    return { available: true, model };
+}
+const SYSTEM = [
+    "You are a senior application-security engineer fixing vulnerabilities in source code.",
+    "You will receive one file and a list of confirmed security findings in it.",
+    "Rewrite the file to remediate EVERY listed finding, using the smallest change that is correct:",
+    "- Parameterize SQL; never build queries by string interpolation.",
+    "- For AI/agent tool execution: enforce a strict tool allowlist AND validate tool-call arguments",
+    "  against an explicit schema before dispatch; constrain dangerous tools (filesystem/shell) to a",
+    "  safe, fixed scope. Inline the guard logic in this file — do not import a new module.",
+    "- Replace eval/exec/os.system on untrusted input with safe APIs or a fixed allowlist of commands.",
+    "- Add ownership/authorization checks before returning a resource fetched by a client-supplied id.",
+    "Preserve the file's language, imports, style, and all unrelated behavior. Do not add commentary.",
+    "Return ONLY the complete corrected file content, wrapped exactly as:",
+    "<file>",
+    "...full file...",
+    "</file>",
+].join("\n");
+/** Returns the corrected file content, or null if unavailable / declined / unreliable. */
+export async function llmFix(input) {
+    if (!process.env.ANTHROPIC_API_KEY)
+        return null;
+    if (input.code.length > MAX_FILE_CHARS)
+        return null;
+    let Anthropic;
+    try {
+        ({ default: Anthropic } = await import("@anthropic-ai/sdk"));
+    }
+    catch {
+        return null; // SDK not installed → graceful fallback
+    }
+    const findingList = input.findings
+        .map((f, i) => `${i + 1}. [${f.severity}] ${f.detector} at line ${f.line}: ${f.title}\n   Why: ${f.why}\n   Intended fix: ${f.fix}`)
+        .join("\n");
+    const user = [
+        `File: ${input.relPath} (${input.lang})`,
+        "",
+        "Findings to fix:",
+        findingList,
+        "",
+        "Current file content:",
+        "<file>",
+        input.code,
+        "</file>",
+    ].join("\n");
+    try {
+        const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+        const msg = await client.messages.create({
+            model: defaultModel(),
+            max_tokens: 4096,
+            system: SYSTEM,
+            messages: [{ role: "user", content: user }],
+        });
+        const text = extractText(msg);
+        return parseFile(text, input.code);
+    }
+    catch {
+        return null; // network / auth / quota failure → fall back to manual
+    }
+}
+/** Exported for unit testing the response plumbing without a live API call. */
+export function extractText(msg) {
+    const blocks = Array.isArray(msg?.content) ? msg.content : [];
+    return blocks
+        .filter((b) => b?.type === "text" && typeof b.text === "string")
+        .map((b) => b.text)
+        .join("");
+}
+/**
+ * Pull the rewritten file out of the response and sanity-check it. We reject a
+ * result that is suspiciously short relative to the original (likely truncated),
+ * since the verification gate can't catch "valid but incomplete".
+ */
+export function parseFile(text, original) {
+    if (!text)
+        return null;
+    let body = null;
+    const tagged = text.match(/<file>\n?([\s\S]*?)\n?<\/file>/);
+    if (tagged)
+        body = tagged[1];
+    if (body == null) {
+        const fenced = text.match(/```[a-zA-Z0-9]*\n([\s\S]*?)```/);
+        if (fenced)
+            body = fenced[1];
+    }
+    if (body == null)
+        body = text;
+    body = body.replace(/\s+$/, "") + "\n";
+    if (body.trim().length === 0)
+        return null;
+    if (body.length < original.length * 0.5)
+        return null; // likely truncated
+    return body;
+}