codegate-ai 0.10.0 → 0.12.0

package/dist/layer2-static/detectors/workflow-unsafe-checkout-ref.js

@@ -0,0 +1,102 @@
+import { buildFindingEvidence } from "../evidence.js";
+import { extractWorkflowFacts, isGitHubWorkflowPath } from "../workflow/parser.js";
+const UNTRUSTED_REF_PATTERNS = [
+    /\bgithub\.event\.pull_request\.head\.ref\b/iu,
+    /\bgithub\.head_ref\b/iu,
+    /\bgithub\.event\.workflow_run\.head_branch\b/iu,
+];
+function hasWritePermission(value) {
+    if (typeof value === "string") {
+        return value.trim().toLowerCase() === "write-all";
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    return Object.values(value).some((permission) => typeof permission === "string" && permission.trim().toLowerCase() === "write");
+}
+function hasIdTokenWrite(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const idTokenPermission = value["id-token"];
+    return (typeof idTokenPermission === "string" && idTokenPermission.trim().toLowerCase() === "write");
+}
+function hasInheritedSecrets(secrets) {
+    return typeof secrets === "string" && secrets.trim().toLowerCase() === "inherit";
+}
+function isCheckoutStep(stepUses) {
+    if (typeof stepUses !== "string") {
+        return false;
+    }
+    return /^actions\/checkout@/iu.test(stepUses.trim());
+}
+function hasUnsafeRef(ref) {
+    if (typeof ref !== "string") {
+        return false;
+    }
+    return UNTRUSTED_REF_PATTERNS.some((pattern) => pattern.test(ref));
+}
+export function detectWorkflowUnsafeCheckoutRef(input) {
+    if (!isGitHubWorkflowPath(input.filePath)) {
+        return [];
+    }
+    const facts = extractWorkflowFacts(input.parsed);
+    if (!facts) {
+        return [];
+    }
+    const hasRelevantTrigger = facts.triggers.some((trigger) => {
+        const normalized = trigger.trim().toLowerCase();
+        return normalized === "pull_request_target" || normalized === "workflow_run";
+    });
+    if (!hasRelevantTrigger) {
+        return [];
+    }
+    const workflowPrivileged = hasWritePermission(facts.workflowPermissions) || hasIdTokenWrite(facts.workflowPermissions);
+    const findings = [];
+    facts.jobs.forEach((job, jobIndex) => {
+        const jobPrivileged = workflowPrivileged ||
+            hasWritePermission(job.permissions) ||
+            hasIdTokenWrite(job.permissions) ||
+            hasInheritedSecrets(job.secrets);
+        if (!jobPrivileged) {
+            return;
+        }
+        job.steps.forEach((step, stepIndex) => {
+            if (!isCheckoutStep(step.uses)) {
+                return;
+            }
+            const refValue = step.with?.ref;
+            if (!hasUnsafeRef(refValue)) {
+                return;
+            }
+            const evidence = buildFindingEvidence({
+                textContent: input.textContent,
+                searchTerms: [step.uses ?? "", refValue ?? "", "head.ref", "head_branch"],
+                fallbackValue: `jobs.${job.id}.steps[${stepIndex}].with.ref`,
+            });
+            findings.push({
+                rule_id: "workflow-unsafe-checkout-ref",
+                finding_id: `WORKFLOW_UNSAFE_CHECKOUT_REF-${input.filePath}-${jobIndex}-${stepIndex}`,
+                severity: "HIGH",
+                category: "CI_TEMPLATE_INJECTION",
+                layer: "L2",
+                file_path: input.filePath,
+                location: { field: `jobs.${job.id}.steps[${stepIndex}].with.ref` },
+                description: "Privileged checkout references attacker-influenced ref names; prefer immutable commit SHA values",
+                affected_tools: ["github-actions"],
+                cve: null,
+                owasp: ["ASI02"],
+                cwe: "CWE-20",
+                confidence: "HIGH",
+                fixable: false,
+                remediation_actions: [
+                    "Use github.event.pull_request.head.sha (or an immutable SHA) instead of head.ref/head_branch values",
+                    "Avoid checking out attacker-controlled refs in privileged workflows",
+                ],
+                evidence: evidence?.evidence ?? refValue ?? null,
+                suppressed: false,
+            });
+        });
+    });
+    return findings;
+}

package/dist/layer2-static/engine.js

@@ -15,6 +15,7 @@ import { detectWorkflowUnpinnedUses } from "./detectors/workflow-unpinned-uses.j
 import { detectWorkflowArtipacked } from "./detectors/workflow-artipacked.js";
 import { detectWorkflowCachePoisoning } from "./detectors/workflow-cache-poisoning.js";
 import { detectWorkflowGithubEnv } from "./detectors/workflow-github-env.js";
+import { detectWorkflowRunUntrustedArtifact } from "./detectors/workflow-run-untrusted-artifact.js";
 import { detectWorkflowInsecureCommands } from "./detectors/workflow-insecure-commands.js";
 import { detectWorkflowSelfHostedRunner } from "./detectors/workflow-self-hosted-runner.js";
 import { detectWorkflowOverprovisionedSecrets } from "./detectors/workflow-overprovisioned-secrets.js";
@@ -28,7 +29,9 @@ import { detectWorkflowForbiddenUses } from "./detectors/workflow-forbidden-uses
 import { detectWorkflowRefConfusion } from "./detectors/workflow-ref-confusion.js";
 import { detectWorkflowRefVersionMismatch } from "./detectors/workflow-ref-version-mismatch.js";
 import { detectWorkflowImpostorCommit } from "./detectors/workflow-impostor-commit.js";
+import { detectWorkflowUnsafeCheckoutRef } from "./detectors/workflow-unsafe-checkout-ref.js";
 import { detectWorkflowUnpinnedImages } from "./detectors/workflow-unpinned-images.js";
+import { detectWorkflowFloatingActionVersion } from "./detectors/workflow-floating-action-version.js";
 import { detectWorkflowAnonymousDefinition } from "./detectors/workflow-anonymous-definition.js";
 import { detectWorkflowConcurrencyLimits } from "./detectors/workflow-concurrency-limits.js";
 import { detectWorkflowSuperfluousActions } from "./detectors/workflow-superfluous-actions.js";
@@ -307,6 +310,16 @@ function buildFileAudits() {
                 })
                 : [],
         },
+        {
+            id: "workflow-run-untrusted-artifact",
+            run: ({ file, input }) => input.config.workflowAuditsEnabled
+                ? detectWorkflowRunUntrustedArtifact({
+                    filePath: file.filePath,
+                    parsed: file.parsed,
+                    textContent: file.textContent,
+                })
+                : [],
+        },
         {
             id: "workflow-insecure-commands",
             run: ({ file, input }) => input.config.workflowAuditsEnabled
@@ -432,6 +445,26 @@ function buildFileAudits() {
                 })
                 : [],
         },
+        {
+            id: "workflow-unsafe-checkout-ref",
+            run: ({ file, input }) => input.config.workflowAuditsEnabled
+                ? detectWorkflowUnsafeCheckoutRef({
+                    filePath: file.filePath,
+                    parsed: file.parsed,
+                    textContent: file.textContent,
+                })
+                : [],
+        },
+        {
+            id: "workflow-floating-action-version",
+            run: ({ file, input }) => input.config.workflowAuditsEnabled
+                ? detectWorkflowFloatingActionVersion({
+                    filePath: file.filePath,
+                    parsed: file.parsed,
+                    textContent: file.textContent,
+                })
+                : [],
+        },
         {
             id: "workflow-impostor-commit",
             onlineRequired: true,

package/dist/layer2-static/github/client.js

@@ -9,6 +9,15 @@ function normalizeAdvisoryMap(value) {
     }
     return normalized;
 }
+function mergeAdvisoryMaps(bundled, cached) {
+    const merged = {};
+    const allKeys = new Set([...Object.keys(bundled), ...Object.keys(cached)]);
+    for (const key of allKeys) {
+        const versions = new Set([...(bundled[key] ?? []), ...(cached[key] ?? [])]);
+        merged[key] = Array.from(versions);
+    }
+    return merged;
+}
 export function createGithubMetadataClient(options = {}) {
     const runtimeMode = options.runtimeMode ?? "offline";
     const cacheDir = options.cacheDir ?? join(homedir(), ".codegate", "cache");
@@ -31,7 +40,10 @@ export function createGithubMetadataClient(options = {}) {
             }
             const cached = loadCachedAdvisoryPayload(cacheDir, cacheMaxAgeMs, now);
             if (cached) {
-                return cached;
+                return {
+                    generatedAt: Math.max(payload.generatedAt, cached.generatedAt),
+                    advisories: mergeAdvisoryMaps(payload.advisories, cached.advisories),
+                };
             }
             saveCachedAdvisoryPayload(cacheDir, payload);
             return payload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codegate-ai",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Pre-flight security scanner for AI coding tool configurations.",
   "license": "MIT",
   "type": "module",