avorelo 0.3.8 → 0.4.0-rc.2

package/scripts/lib/security-confidence/constants.js

@@ -0,0 +1,191 @@
+"use strict";
+
+const RISK_CLASSES = [
+  "prompt_injection",
+  "tool_output_injection",
+  "tool_poisoning",
+  "tool_shadowing",
+  "toxic_flow",
+  "untrusted_natural_language_content",
+  "hidden_instruction",
+  "credential_handling_risk",
+  "hardcoded_secret",
+  "malware_like_payload",
+  "mcp_command_execution_risk",
+  "excessive_filesystem_access",
+  "excessive_network_access",
+  "excessive_subprocess_access",
+  "dangerous_package_script",
+  "unpinned_npm_npx_execution",
+  "secret_env_access",
+  "deploy_publish_git_write_path",
+  "policy_override_attempt",
+  "fake_approval_instruction",
+  "destructive_action_attempt",
+  "public_static_exposure",
+  "auth_rbac_sensitive_change",
+  "activation_safety_risk",
+  "dependency_script_risk",
+  "package_script_risk",
+  "unpinned_execution",
+  "deploy_publish_git_write",
+  "scope_violation",
+  "context_drift",
+  "evidence_missing",
+  "report_quality_gap",
+  "unsafe_security_claim",
+  "out_of_scope_testing",
+  "external_target_risk",
+];
+
+const SEVERITY_LEVELS = ["low", "medium", "high", "critical"];
+
+const VERDICTS = [
+  "SAFE_TO_USE",
+  "SAFE_WITH_LIMITS",
+  "NEEDS_APPROVAL",
+  "BLOCKED",
+  "NOT_ENOUGH_EVIDENCE",
+];
+
+const RELEASE_SURFACES = [
+  "public_web",
+  "wasp_app",
+  "backend_api",
+  "db_schema",
+  "auth_oauth_rbac",
+  "activation_npm_npx",
+  "package_dependency",
+  "mcp_skill_hook_prompt",
+  "deployment_env",
+  "docs_only",
+  "security_confidence",
+];
+
+const PERMISSION_CATEGORIES = [
+  "filesystem_read",
+  "filesystem_write",
+  "network",
+  "subprocess",
+  "browser",
+  "secrets_env",
+  "db",
+  "deploy",
+  "publish",
+  "oauth_auth",
+  "package_install",
+  "git_write_push",
+  "external_api",
+  "customer_data",
+];
+
+const COMPONENT_TYPES = [
+  "claude_config",
+  "agents_instruction",
+  "codex_config",
+  "cursor_config",
+  "mcp_config",
+  "skill",
+  "hook",
+  "prompt",
+  "command",
+  "agent",
+  "package_script_bundle",
+  "activation_script",
+  "browser_capability",
+  "ci_workflow",
+  "deploy_script",
+  "unknown",
+];
+
+const FINAL_DECISIONS = [
+  "SECURITY_CONFIDENCE_GO",
+  "SECURITY_CONFIDENCE_GO_WITH_NON_BLOCKING_FINDINGS",
+  "SECURITY_CONFIDENCE_NO_GO",
+  "SECURITY_CONFIDENCE_BLOCKED",
+  "NOT_ENOUGH_EVIDENCE",
+];
+
+const CONFIDENCE_LABELS = ["measured", "estimated", "inferred", "not enough evidence"];
+
+const TRIAGE_STATES = [
+  "PASS",
+  "DOWNGRADE",
+  "KILL",
+  "NEEDS_MORE_EVIDENCE",
+  "CHAIN_REQUIRED",
+  "NOT_IN_SCOPE",
+  "CONFIRMED",
+  "FALSE_POSITIVE",
+  "ACCEPTED_RISK",
+  "FIXED",
+  "RETEST_REQUIRED",
+];
+
+const EXECUTION_MODES = [
+  "reference_only",
+  "mock",
+  "local_static",
+  "sandbox_required",
+  "future_external",
+];
+
+const SECURITY_REFERENCE_NAMES = [
+  "snyk-agent-scan",
+  "tank",
+  "decepticon",
+  "mcp-scan",
+  "claude-bughunter",
+];
+
+const SAFE_WORDING = [
+  "scoped security validation",
+  "security confidence",
+  "launch-readiness security check",
+  "defensive red-team-style fixtures",
+  "evidence-backed risk reduction",
+  "no critical blockers found under tested scope",
+];
+
+const FORBIDDEN_CLAIM_PATTERNS = [
+  /\bguarantee(d)?\b/i,
+  /\bimmune\b/i,
+  /\bfully secure\b/i,
+  /\bpentested\b/i,
+  /\bcertified\b/i,
+  /\bcompliance certified\b/i,
+  /\bformal penetration test\b/i,
+  /\bautonomous exploit/i,
+  /\bC2\b/i,
+  /\blateral movement\b/i,
+  /\bprivilege escalation\b/i,
+];
+
+const SECRET_NAME_PATTERNS = [
+  { label: "google_client_secret", pattern: /\bGOCSPX[-_A-Za-z0-9]{10,}\b/g },
+  { label: "stripe_like_key", pattern: /\bsk_(live|test)_[A-Za-z0-9_-]{8,}\b/g },
+  { label: "generic_client_secret", pattern: /\bCLIENT_SECRET\b\s*[:=]\s*["']?[A-Za-z0-9][^"'\s]+/gi },
+  { label: "database_url", pattern: /\bDATABASE_URL\b\s*[:=]\s*["']?(postgres(?:ql)?:\/\/|mysql:\/\/|mongodb(?:\+srv)?:\/\/)[^"'\s]+/gi },
+  { label: "private_key", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/g },
+  { label: "api_key", pattern: /\b(API_KEY|OPENAI_API_KEY|GITHUB_TOKEN|SLACK_BOT_TOKEN|DISCORD_TOKEN|MICROSOFT_CLIENT_SECRET)\b\s*[:=]\s*["']?[A-Za-z0-9][^"'\s]+/gi },
+];
+
+const SAFE_FILE_SIZE_BYTES = 256 * 1024;
+
+module.exports = {
+  COMPONENT_TYPES,
+  CONFIDENCE_LABELS,
+  EXECUTION_MODES,
+  FINAL_DECISIONS,
+  FORBIDDEN_CLAIM_PATTERNS,
+  PERMISSION_CATEGORIES,
+  RELEASE_SURFACES,
+  RISK_CLASSES,
+  SAFE_FILE_SIZE_BYTES,
+  SAFE_WORDING,
+  SECURITY_REFERENCE_NAMES,
+  SECRET_NAME_PATTERNS,
+  SEVERITY_LEVELS,
+  TRIAGE_STATES,
+  VERDICTS,
+};

package/scripts/lib/security-confidence/dependency-script-risk.js

@@ -0,0 +1,95 @@
+"use strict";
+
+const path = require("path");
+const { safeReadJson } = require("./file-utils");
+const { createFinding } = require("./findings");
+
+function analyzeDependencyScriptRisk({ rootDir }) {
+  const findings = [];
+  const packageResult = safeReadJson(path.join(rootDir, "package.json"), { rootDir, noSecretContent: true });
+  const scripts = packageResult.json && packageResult.json.scripts ? packageResult.json.scripts : {};
+
+  for (const [name, command] of Object.entries(scripts)) {
+    const lower = String(command).toLowerCase();
+    if (name === "preinstall" || name === "postinstall") {
+      findings.push(
+        createFinding({
+          title: `Package script '${name}' needs review`,
+          path: "package.json",
+          command,
+          expectedBehavior: "Install hooks should be absent or narrowly justified.",
+          actualBehavior: `Package script '${name}' is present.`,
+          riskClass: "dangerous_package_script",
+          safeFix: "Remove install hooks or document a reviewed, bounded need.",
+          ownerAction: "review-package-scripts",
+        }),
+      );
+    }
+    if (/curl\s+[^|]+\|\s*(bash|sh)|invoke-expression|downloadstring/.test(lower)) {
+      findings.push(
+        createFinding({
+          title: `Package script '${name}' contains download-and-run behavior`,
+          path: "package.json",
+          command,
+          expectedBehavior: "Package scripts should not pipe remote content into a shell.",
+          actualBehavior: `Package script '${name}' contains a shell-pipe execution pattern.`,
+          riskClass: "dangerous_package_script",
+          safeFix: "Replace remote shell-pipe execution with a reviewed pinned local step.",
+          ownerAction: "remove-remote-shell-pipe",
+        }),
+      );
+    }
+    if (/\bnpx\s+\S+(@latest)?\b/.test(lower)) {
+      findings.push(
+        createFinding({
+          title: `Package script '${name}' uses npx without a pinned version`,
+          path: "package.json",
+          command,
+          expectedBehavior: "npx usage should be pinned or otherwise provenance-controlled.",
+          actualBehavior: `Package script '${name}' uses npx in an unpinned or latest form.`,
+          riskClass: "unpinned_npm_npx_execution",
+          safeFix: "Pin the package version or replace with a reviewed local dependency.",
+          ownerAction: "pin-npx-version",
+        }),
+      );
+    }
+    if (/npm\s+install\s+https?:\/\//.test(lower) || /\bgithub:/i.test(command)) {
+      findings.push(
+        createFinding({
+          title: `Package script '${name}' installs from a URL`,
+          path: "package.json",
+          command,
+          expectedBehavior: "Dependency sources should be pinned and provenance-reviewed.",
+          actualBehavior: `Package script '${name}' references an install-from-URL pattern.`,
+          riskClass: "dependency_script_risk",
+          safeFix: "Replace direct URL installs with pinned registry or vendored sources.",
+          ownerAction: "replace-url-install",
+        }),
+      );
+    }
+    if (/deploy|publish/.test(name) || /npm publish|netlify|railway/.test(lower)) {
+      findings.push(
+        createFinding({
+          title: `Package script '${name}' touches release-side effects`,
+          path: "package.json",
+          command,
+          expectedBehavior: "Release scripts should stay behind explicit review and approval.",
+          actualBehavior: `Package script '${name}' includes deploy or publish semantics.`,
+          riskClass: "deploy_publish_git_write_path",
+          safeFix: "Keep release scripts separated from general automation and require explicit approval.",
+          ownerAction: "review-release-script",
+        }),
+      );
+    }
+  }
+
+  return {
+    packageJsonPresent: !!packageResult.json,
+    scripts,
+    findings,
+  };
+}
+
+module.exports = {
+  analyzeDependencyScriptRisk,
+};

package/scripts/lib/security-confidence/evidence-hygiene.js

@@ -0,0 +1,127 @@
+"use strict";
+
+const path = require("path");
+const { classifySecretLikeString, redactPathIfSensitive, redactSecrets } = require("./redaction");
+
+const EVIDENCE_CONFIDENCE = ["measured", "estimated", "inferred", "not enough evidence"];
+
+const EVIDENCE_ISSUE_PATTERNS = [
+  { code: "cookie_exposed", severity: "high", pattern: /\bcookie\b\s*[:=]/i, replacement: "[REDACTED_COOKIE]" },
+  { code: "session_exposed", severity: "high", pattern: /\bsession(id)?\b\s*[:=]/i, replacement: "[REDACTED_SESSION]" },
+  { code: "token_exposed", severity: "high", pattern: /\b(access_token|refresh_token|bearer\s+[a-z0-9._-]+)/i, replacement: "[REDACTED_TOKEN]" },
+  { code: "pii_exposed", severity: "medium", pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i, replacement: "[REDACTED_EMAIL]" },
+];
+
+function normalizeEvidenceItem(item) {
+  if (typeof item === "string") {
+    return {
+      type: "path",
+      value: item,
+      confidence: "inferred",
+    };
+  }
+  return {
+    type: item && item.type ? item.type : "note",
+    value: item && item.value !== undefined ? String(item.value) : "",
+    confidence: EVIDENCE_CONFIDENCE.includes(item && item.confidence) ? item.confidence : "inferred",
+    order: item && item.order ? item.order : null,
+    label: item && item.label ? item.label : null,
+  };
+}
+
+function sanitizeEvidenceItem(item, options = {}) {
+  const normalized = normalizeEvidenceItem(item);
+  const issues = [];
+  let value = normalized.value;
+
+  const secretScan = classifySecretLikeString(value);
+  if (secretScan.isSecretLike) {
+    issues.push({
+      code: "raw_secret_exposed",
+      severity: "critical",
+      reason: "Evidence contained secret-like text.",
+    });
+    value = redactSecrets(value);
+  }
+
+  for (const rule of EVIDENCE_ISSUE_PATTERNS) {
+    if (rule.pattern.test(value)) {
+      issues.push({
+        code: rule.code,
+        severity: rule.severity,
+        reason: `Evidence contained ${rule.code.replace(/_/g, " ")} text.`,
+      });
+      value = value.replace(rule.pattern, rule.replacement);
+    }
+  }
+
+  if (normalized.type === "private_prompt" && options.allowPrivatePrompts !== true) {
+    issues.push({
+      code: "private_prompt_redacted",
+      severity: "medium",
+      reason: "Private prompt content should not be stored in default reports.",
+    });
+    value = "[REDACTED_PRIVATE_PROMPT]";
+  }
+
+  if (normalized.type === "screenshot" && /session|token|cookie|account/i.test(value)) {
+    issues.push({
+      code: "sensitive_screenshot_reference",
+      severity: "medium",
+      reason: "Screenshot evidence should stay minimal and avoid sensitive account views.",
+    });
+  }
+
+  if (options.redactLocalPaths !== false) {
+    value = value.replace(/[A-Za-z]:\\[^ \n\r\t]+/g, (match) => redactPathIfSensitive(match));
+    value = value.replace(/\/(?:Users|home|mnt)\/[^ \n\r\t]+/g, (match) => {
+      const basename = path.posix.basename(match.replace(/\\/g, "/"));
+      return `[REDACTED_PATH:${basename}]`;
+    });
+  }
+
+  return {
+    item: {
+      ...normalized,
+      value,
+    },
+    issues,
+  };
+}
+
+function sanitizeEvidenceBundle(evidence, options = {}) {
+  const items = Array.isArray(evidence) ? evidence : [evidence];
+  const sanitized = [];
+  const issues = [];
+  let order = 1;
+  for (const item of items.filter(Boolean)) {
+    const result = sanitizeEvidenceItem({ ...normalizeEvidenceItem(item), order }, options);
+    sanitized.push(result.item);
+    issues.push(...result.issues);
+    order += 1;
+  }
+  return {
+    items: sanitized,
+    issues,
+  };
+}
+
+function evaluateEvidenceHygiene(evidence, options = {}) {
+  const sanitized = sanitizeEvidenceBundle(evidence, options);
+  const hasCritical = sanitized.issues.some((issue) => issue.severity === "critical");
+  const hasHigh = sanitized.issues.some((issue) => issue.severity === "high");
+  return {
+    ok: !hasCritical,
+    status: hasCritical ? "blocked" : hasHigh ? "review_required" : "pass",
+    issues: sanitized.issues,
+    evidence: sanitized.items,
+  };
+}
+
+module.exports = {
+  EVIDENCE_CONFIDENCE,
+  evaluateEvidenceHygiene,
+  normalizeEvidenceItem,
+  sanitizeEvidenceBundle,
+  sanitizeEvidenceItem,
+};

package/scripts/lib/security-confidence/feature-impact-classifier.js

@@ -0,0 +1,80 @@
+"use strict";
+
+const { RELEASE_SURFACES } = require("./constants");
+
+function classifyFile(file) {
+  const normalized = String(file || "").replace(/\\/g, "/");
+  if (!normalized) return "docs_only";
+  if (/^apps\/public-web\//.test(normalized) || /^public\//.test(normalized)) return "public_web";
+  if (/^src\//.test(normalized)) return "backend_api";
+  if (/main\.wasp$/.test(normalized)) return "wasp_app";
+  if (/schema\.prisma$|^prisma\/|^migrations\//.test(normalized)) return "db_schema";
+  if (/auth|oauth|rbac|login|signup|session|admin|founder/i.test(normalized)) return "auth_oauth_rbac";
+  if (/activation|install|npx|npm/i.test(normalized)) return "activation_npm_npx";
+  if (/package\.json$|package-lock\.json$/.test(normalized)) return "package_dependency";
+  if (/\.claude\/|\.codex\/|\.cursor\/|skills\/|hooks\/|prompts?\/|commands?\/|AGENTS\.md|CLAUDE\.md/i.test(normalized)) return "mcp_skill_hook_prompt";
+  if (/deploy|netlify|\.env|client_secret/i.test(normalized)) return "deployment_env";
+  if (/security-confidence/i.test(normalized)) return "security_confidence";
+  if (/^docs\//.test(normalized)) return "docs_only";
+  return "docs_only";
+}
+
+function classifyFeatureImpact({ changedFiles = [] }) {
+  const surfaces = new Set();
+  const reasons = [];
+  for (const file of changedFiles) {
+    const surface = classifyFile(file);
+    if (!RELEASE_SURFACES.includes(surface)) continue;
+    surfaces.add(surface);
+    reasons.push({ file, surface });
+  }
+
+  if (surfaces.size === 0) surfaces.add("docs_only");
+  if (surfaces.has("db_schema") || surfaces.has("deployment_env")) {
+    return {
+      affectedSurfaces: Array.from(surfaces),
+      recommendedGates: ["Launch Security Confidence Check", "Manual review required"],
+      severity: "high",
+      autoRun: false,
+      why: reasons,
+    };
+  }
+  if (surfaces.has("auth_oauth_rbac")) {
+    return {
+      affectedSurfaces: Array.from(surfaces),
+      recommendedGates: ["Auth / OAuth / RBAC Validation"],
+      severity: "high",
+      autoRun: false,
+      why: reasons,
+    };
+  }
+  if (surfaces.has("package_dependency")) {
+    return {
+      affectedSurfaces: Array.from(surfaces),
+      recommendedGates: ["Dependency & Package Script Risk Guard"],
+      severity: "high",
+      autoRun: false,
+      why: reasons,
+    };
+  }
+  if (surfaces.has("public_web")) {
+    return {
+      affectedSurfaces: Array.from(surfaces),
+      recommendedGates: ["Web/App Security Smoke"],
+      severity: "medium",
+      autoRun: false,
+      why: reasons,
+    };
+  }
+  return {
+    affectedSurfaces: Array.from(surfaces),
+    recommendedGates: surfaces.has("docs_only") ? ["No runtime gate required"] : ["Security Confidence review"],
+    severity: surfaces.has("docs_only") ? "low" : "medium",
+    autoRun: false,
+    why: reasons,
+  };
+}
+
+module.exports = {
+  classifyFeatureImpact,
+};

package/scripts/lib/security-confidence/file-utils.js

@@ -0,0 +1,161 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { SAFE_FILE_SIZE_BYTES } = require("./constants");
+const { redactPathIfSensitive, sanitizeFindingEvidence } = require("./redaction");
+
+const DEFAULT_IGNORED_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "_wasp_build_tmp",
+  ".wasp",
+  ".tmp",
+  ".tmp-agent-comfort-origin-main",
+]);
+
+function normalizeRelativePath(rootDir, filePath) {
+  return path.relative(rootDir, filePath).replace(/\\/g, "/");
+}
+
+function isSensitivePath(relativePath) {
+  return /^\.env($|\.)/i.test(relativePath) || /(^|\/)client_secret[^/]*\.json$/i.test(relativePath);
+}
+
+function isFixturePath(relativePath) {
+  return /(^|\/)tests\/fixtures\/security-confidence\//.test(relativePath);
+}
+
+function isBinaryBuffer(buffer) {
+  const sample = buffer.subarray(0, Math.min(buffer.length, 256));
+  for (const byte of sample) {
+    if (byte === 0) return true;
+  }
+  return false;
+}
+
+function classifyPath(rootDir, filePath) {
+  const relativePath = normalizeRelativePath(rootDir, filePath);
+  return {
+    relativePath,
+    isSensitive: isSensitivePath(relativePath),
+    isFixture: isFixturePath(relativePath),
+    isDocs: /^docs\//.test(relativePath),
+    isPublicLike: /(^|\/)(public|site|apps\/public-web)\//.test(relativePath) || /^public\//.test(relativePath),
+  };
+}
+
+function safeReadText(filePath, options = {}) {
+  const rootDir = options.rootDir || path.dirname(filePath);
+  const meta = classifyPath(rootDir, filePath);
+  let stats;
+  try {
+    stats = fs.statSync(filePath);
+  } catch {
+    return { ok: false, skipped: true, reason: "missing", ...meta };
+  }
+  if (!stats.isFile()) {
+    return { ok: false, skipped: true, reason: "not-file", ...meta };
+  }
+  if (stats.size > (options.maxFileSizeBytes || SAFE_FILE_SIZE_BYTES)) {
+    return { ok: false, skipped: true, reason: "max-file-size", size: stats.size, ...meta };
+  }
+  if (meta.isSensitive && options.noSecretContent !== false) {
+    return {
+      ok: true,
+      skipped: true,
+      metadataOnly: true,
+      reason: "sensitive-path",
+      size: stats.size,
+      path: redactPathIfSensitive(meta.relativePath),
+      ...meta,
+    };
+  }
+  let buffer;
+  try {
+    buffer = fs.readFileSync(filePath);
+  } catch {
+    return { ok: false, skipped: true, reason: "read-failed", ...meta };
+  }
+  if (isBinaryBuffer(buffer)) {
+    return { ok: false, skipped: true, reason: "binary-file", size: stats.size, ...meta };
+  }
+  const text = buffer.toString("utf8");
+  return {
+    ok: true,
+    text,
+    size: stats.size,
+    path: meta.relativePath,
+    ...meta,
+  };
+}
+
+function safeReadJson(filePath, options = {}) {
+  const textResult = safeReadText(filePath, options);
+  if (!textResult.ok || textResult.skipped || !textResult.text) return textResult;
+  try {
+    return {
+      ...textResult,
+      json: JSON.parse(textResult.text),
+    };
+  } catch {
+    return {
+      ...textResult,
+      ok: false,
+      skipped: true,
+      reason: "invalid-json",
+    };
+  }
+}
+
+function listFilesSafe(rootDir, options = {}) {
+  const output = [];
+  const ignoredDirs = new Set([...(options.ignoredDirs || []), ...DEFAULT_IGNORED_DIRS]);
+  const maxFiles = options.maxFiles || 3000;
+
+  function walk(currentDir) {
+    if (output.length >= maxFiles) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (output.length >= maxFiles) break;
+      const absPath = path.join(currentDir, entry.name);
+      const relativePath = normalizeRelativePath(rootDir, absPath);
+      if (entry.isDirectory()) {
+        if (ignoredDirs.has(entry.name)) continue;
+        if (!options.includeFixtures && isFixturePath(`${relativePath}/`)) continue;
+        walk(absPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!options.includeFixtures && isFixturePath(relativePath)) continue;
+      output.push({
+        absolutePath: absPath,
+        ...classifyPath(rootDir, absPath),
+      });
+    }
+  }
+
+  walk(rootDir);
+  return output;
+}
+
+function sanitizePathMetadata(value) {
+  return sanitizeFindingEvidence(value);
+}
+
+module.exports = {
+  classifyPath,
+  isFixturePath,
+  isSensitivePath,
+  listFilesSafe,
+  normalizeRelativePath,
+  safeReadJson,
+  safeReadText,
+  sanitizePathMetadata,
+};