@cyclonedx/cdxgen 12.3.1 → 12.3.2

package/lib/helpers/jsonLike.js

@@ -1,22 +1,32 @@
+/**
+ * Returns whether the quote at `index` is escaped by an odd-length run of
+ * backslashes immediately preceding it.
+ *
+ * @param {string} raw Raw JSON-like text being scanned
+ * @param {number} index Index of the quote character to evaluate
+ * @returns {boolean} `true` when the quote is escaped and should not terminate
+ * the current string literal
+ */
+function isEscapedQuote(raw, index) {
+  let backslashCount = 0;
+  let lookBehind = index - 1;
+  while (lookBehind >= 0 && raw[lookBehind] === "\\") {
+    backslashCount += 1;
+    lookBehind -= 1;
+  }
+  return backslashCount % 2 === 1;
+}
+
 export function stripJsonComments(raw) {
   let output = "";
   let inString = false;
   let stringQuote = "";
-  let escaped = false;
   for (let index = 0; index < raw.length; index++) {
     const char = raw[index];
     const nextChar = raw[index + 1];
     if (inString) {
       output += char;
-      if (escaped) {
-        escaped = false;
-        continue;
-      }
-      if (char === "\\") {
-        escaped = true;
-        continue;
-      }
-      if (char === stringQuote) {
+      if (char === stringQuote && !isEscapedQuote(raw, index)) {
         inString = false;
         stringQuote = "";
       }
@@ -57,20 +67,11 @@ export function stripJsonTrailingCommas(raw) {
   let output = "";
   let inString = false;
   let stringQuote = "";
-  let escaped = false;
   for (let index = 0; index < raw.length; index++) {
     const char = raw[index];
     if (inString) {
       output += char;
-      if (escaped) {
-        escaped = false;
-        continue;
-      }
-      if (char === "\\") {
-        escaped = true;
-        continue;
-      }
-      if (char === stringQuote) {
+      if (char === stringQuote && !isEscapedQuote(raw, index)) {
         inString = false;
         stringQuote = "";
       }

package/lib/helpers/jsonLike.poku.js

@@ -0,0 +1,34 @@
+import { assert, describe, it } from "poku";
+
+import { parseJsonLike, stripJsonComments } from "./jsonLike.js";
+
+describe("jsonLike", () => {
+  it("preserves escaped quotes while stripping comments", () => {
+    const parsedMessage = 'escaped quote: " // not a comment';
+    const rawMessage = String.raw`escaped quote: \" // not a comment`;
+    const raw = String.raw`{
+      "message": "escaped quote: \" // not a comment",
+      // trailing comment
+      "enabled": true
+    }`;
+    const stripped = stripJsonComments(raw);
+    assert.ok(stripped.includes(rawMessage));
+    assert.ok(!stripped.includes("trailing comment"));
+    assert.deepStrictEqual(parseJsonLike(raw), {
+      enabled: true,
+      message: parsedMessage,
+    });
+  });
+
+  it("preserves comment markers after escaped backslashes inside strings", () => {
+    const raw = `{
+      "path": "C:\\\\\\\\temp\\\\\\\\file // keep",
+      /* block comment */
+      "count": 1
+    }`;
+    assert.deepStrictEqual(parseJsonLike(raw), {
+      count: 1,
+      path: "C:\\\\temp\\\\file // keep",
+    });
+  });
+});

package/lib/helpers/mcpConfigParser.js

@@ -214,6 +214,9 @@ function detectConfigCredentialSignals(serverConfig) {
     }
   }
   return {
+    credentialIndicatorCount: inlineIndicators.size,
+    credentialReferenceCount: credentialRefs.size,
+    exposureFieldCount: exposureFields.size,
     credentialRefs: Array.from(credentialRefs).sort(),
     exposureFields: Array.from(exposureFields).sort(),
     inlineIndicators: Array.from(inlineIndicators).sort(),
@@ -468,22 +471,22 @@ function createServiceFromConfig(
     addUniqueProperty(properties, "cdx:mcp:credentialExposure", "true");
     addUniqueProperty(
       properties,
-      "cdx:mcp:credentialRiskIndicators",
-      credentialSignals.inlineIndicators.join(","),
+      "cdx:mcp:credentialIndicatorCount",
+      String(credentialSignals.credentialIndicatorCount),
     );
   }
   if (credentialSignals.exposureFields.length) {
     addUniqueProperty(
       properties,
-      "cdx:mcp:credentialExposureFields",
-      credentialSignals.exposureFields.join(","),
+      "cdx:mcp:credentialExposureFieldCount",
+      String(credentialSignals.exposureFieldCount),
     );
   }
   if (credentialSignals.credentialRefs.length) {
     addUniqueProperty(
       properties,
-      "cdx:mcp:credentialRefs",
-      credentialSignals.credentialRefs.join(","),
+      "cdx:mcp:credentialReferenceCount",
+      String(credentialSignals.credentialReferenceCount),
     );
   }
   if (supportsDcr) {
@@ -593,11 +596,8 @@ function createConfigComponent(filePath, format, raw, services) {
     addUniqueProperty(properties, "cdx:mcp:credentialExposure", "true");
     addUniqueProperty(
       properties,
-      "cdx:mcp:credentialExposedServices",
-      credentialServices
-        .map((service) => service.name)
-        .sort()
-        .join(","),
+      "cdx:mcp:credentialExposedServiceCount",
+      String(credentialServices.length),
     );
   }
   return {

package/lib/helpers/mcpConfigParser.poku.js

@@ -56,4 +56,71 @@ describe("mcpConfigParser", () => {
       syntax: "json",
     });
   });
+
+  it("records credential exposure without embedding raw secret metadata", async () => {
+    const readFileSync = sinon.stub();
+    const scanTextForHiddenUnicode = sinon.stub().returns({
+      hasHiddenUnicode: false,
+    });
+    readFileSync.withArgs("/repo/.vscode/mcp.json", "utf-8").returns(
+      JSON.stringify({
+        mcpServers: {
+          releaseDocs: {
+            args: [
+              "--token",
+              "sk_test_super_secret_value",
+              "https://docs.example.com/mcp",
+            ],
+            command: "npx",
+            env: {
+              API_KEY: "$" + "{API_KEY}",
+            },
+            headers: {
+              Authorization: "Bearer sk_test_another_secret_value",
+            },
+            transport: "http",
+          },
+        },
+      }),
+    );
+    const { mcpConfigParser } = await esmock("./mcpConfigParser.js", {
+      "node:fs": { readFileSync },
+      "./unicodeScan.js": { scanTextForHiddenUnicode },
+    });
+
+    const result = mcpConfigParser.parse(["/repo/.vscode/mcp.json"]);
+    const service = result.services[0];
+    const component = result.components[0];
+
+    assert.strictEqual(getProp(service, "cdx:mcp:credentialExposure"), "true");
+    assert.strictEqual(
+      getProp(service, "cdx:mcp:credentialIndicatorCount"),
+      "3",
+    );
+    assert.strictEqual(
+      getProp(service, "cdx:mcp:credentialExposureFieldCount"),
+      "3",
+    );
+    assert.strictEqual(
+      getProp(service, "cdx:mcp:credentialReferenceCount"),
+      "1",
+    );
+    assert.strictEqual(
+      getProp(component, "cdx:mcp:credentialExposedServiceCount"),
+      "1",
+    );
+    assert.strictEqual(
+      getProp(service, "cdx:mcp:credentialRiskIndicators"),
+      undefined,
+    );
+    assert.strictEqual(
+      getProp(service, "cdx:mcp:credentialExposureFields"),
+      undefined,
+    );
+    assert.strictEqual(getProp(service, "cdx:mcp:credentialRefs"), undefined);
+    assert.strictEqual(
+      getProp(component, "cdx:mcp:credentialExposedServices"),
+      undefined,
+    );
+  });
 });

package/lib/helpers/mcpDiscovery.js

@@ -17,30 +17,20 @@ const INLINE_CREDENTIAL_PATTERNS = [
 ];
 
 export function sanitizeMcpRefToken(value) {
-  const input = String(value || "").toLowerCase();
-  const tokens = [];
-  let previousWasSeparator = false;
-  for (const char of input) {
-    const isAlphaNumeric =
-      (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
-    const isAllowedPunctuation = [".", "_", "-"].includes(char);
-    if (isAlphaNumeric || isAllowedPunctuation) {
-      tokens.push(char);
-      previousWasSeparator = false;
-      continue;
-    }
-    if (!previousWasSeparator && tokens.length) {
-      tokens.push("-");
-      previousWasSeparator = true;
-    }
+  const input = String(value || "")
+    .normalize("NFKC")
+    .trim()
+    .toLowerCase();
+  const normalized = input
+    .replaceAll(/[/\\:]/gu, "-")
+    .replaceAll(/[^a-z0-9._-]+/gu, "-")
+    .replaceAll(/[._-]{2,}/gu, "-")
+    .replaceAll(/^\.+|\.+$/gu, "")
+    .replaceAll(/^[._-]+|[._-]+$/gu, "");
+  if (!normalized || normalized === "." || normalized === "..") {
+    return "unknown";
   }
-  while (tokens[0] === "-") {
-    tokens.shift();
-  }
-  while (tokens[tokens.length - 1] === "-") {
-    tokens.pop();
-  }
-  return tokens.join("") || "unknown";
+  return normalized.slice(0, 128);
 }
 
 export function isLocalHost(hostname) {

package/lib/helpers/mcpDiscovery.poku.js

@@ -0,0 +1,21 @@
+import { assert, describe, it } from "poku";
+
+import { sanitizeMcpRefToken } from "./mcpDiscovery.js";
+
+describe("sanitizeMcpRefToken()", () => {
+  it("normalizes path traversal and punctuation-heavy input into safe tokens", () => {
+    assert.strictEqual(
+      sanitizeMcpRefToken("../Secrets/Prod Token"),
+      "secrets-prod-token",
+    );
+    assert.strictEqual(
+      sanitizeMcpRefToken("..\\..\\etc\\passwd"),
+      "etc-passwd",
+    );
+  });
+
+  it("returns unknown for empty or separator-only input", () => {
+    assert.strictEqual(sanitizeMcpRefToken("..."), "unknown");
+    assert.strictEqual(sanitizeMcpRefToken("///"), "unknown");
+  });
+});

package/lib/helpers/utils.js

@@ -918,7 +918,6 @@ export const PROJECT_TYPE_ALIASES = {
     "node20",
     "node22",
     "node23",
-    "mcp",
     "js",
     "javascript",
     "typescript",
@@ -927,6 +926,8 @@ export const PROJECT_TYPE_ALIASES = {
     "yarn",
     "rush",
   ],
+  mcp: ["mcp"],
+  "ai-skill": ["ai-skill", "skill", "skills"],
   py: [
     "py",
     "python",

package/lib/helpers/utils.poku.js

@@ -3133,7 +3133,25 @@ it("parse github actions workflow data", () => {
   dep_list = parseGitHubWorkflowData("./test/data/github-actions-tj.yaml");
   assert.deepStrictEqual(dep_list.length, 4);
   dep_list = parseGitHubWorkflowData("./.github/workflows/repotests.yml");
-  assert.deepStrictEqual(dep_list.length, 92);
+  assert.ok(dep_list.length > 0);
+  assert.ok(
+    dep_list.every((component) =>
+      component.properties?.some(
+        (property) =>
+          property.name === "cdx:github:workflow:file" &&
+          property.value === "./.github/workflows/repotests.yml",
+      ),
+    ),
+  );
+  assert.ok(
+    dep_list.some((component) =>
+      component.properties?.some(
+        (property) =>
+          property.name === "cdx:github:checkout:repository" &&
+          property.value === "AppThreat/vulnerability-db",
+      ),
+    ),
+  );
 });
 // biome-ignore-end lint/suspicious/noTemplateCurlyInString: fp
 

package/lib/stages/postgen/annotator.js

@@ -285,7 +285,8 @@ export function textualMetadata(bomJson) {
   const { bomType, bomTypeDescription } = findBomType(bomJson);
   const metadata = bomJson.metadata;
   const lifecycles = metadata?.lifecycles || [];
-  const tlpClassification = metadata.distribution;
+  const tlpClassification =
+    metadata.distributionConstraints?.tlp || metadata.distribution;
   const cryptoAssetsCount = bomJson?.components?.filter(
     (c) => c.type === "cryptographic-asset",
   ).length;

package/lib/stages/postgen/annotator.poku.js

@@ -311,3 +311,18 @@ it("extractTags tests", () => {
     "security",
   ]);
 });
+
+it("textualMetadata includes the CycloneDX 1.7 TLP classification from distributionConstraints", () => {
+  assert.match(
+    textualMetadata({
+      bomFormat: "CycloneDX",
+      specVersion: "1.7",
+      metadata: {
+        distributionConstraints: {
+          tlp: "AMBER_AND_STRICT",
+        },
+      },
+    }),
+    /TLP\) classification for this document is 'AMBER_AND_STRICT'/,
+  );
+});

package/lib/stages/postgen/auditBom.js

@@ -6,6 +6,10 @@ import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { buildAnnotationText } from "../../helpers/annotationFormatter.js";
+import {
+  expandBomAuditCategories,
+  validateBomAuditCategories,
+} from "../../helpers/auditCategories.js";
 import { table } from "../../helpers/table.js";
 import {
   DEBUG_MODE,
@@ -45,15 +49,17 @@ export async function auditBom(bomJson, options) {
   }
   let activeRules = rules;
   if (options.bomAuditCategories) {
-    const categories = options.bomAuditCategories
-      .split(",")
-      .map((c) => c.trim())
-      .filter(Boolean);
+    const { categories, expandedCategories } = validateBomAuditCategories(
+      options.bomAuditCategories,
+      rules,
+    );
     if (categories.length > 0) {
-      activeRules = rules.filter((r) => categories.includes(r.category));
+      activeRules = rules.filter((r) =>
+        expandedCategories.includes(r.category),
+      );
       if (DEBUG_MODE) {
         console.log(
-          `Filtering rules by categories: ${categories.join(", ")} (${activeRules.length} active)`,
+          `Filtering rules by categories: ${categories.join(", ")} -> ${expandBomAuditCategories(categories).join(", ")} (${activeRules.length} active)`,
         );
       }
     }

package/lib/stages/postgen/auditBom.poku.js

@@ -524,13 +524,14 @@ describe("evaluateRule", () => {
             { name: "cdx:mcp:inventorySource", value: "config-file" },
             { name: "cdx:mcp:credentialExposure", value: "true" },
             {
-              name: "cdx:mcp:credentialExposureFields",
-              value: "header:Authorization,env:OPENAI_API_KEY",
+              name: "cdx:mcp:credentialExposureFieldCount",
+              value: "2",
             },
             {
-              name: "cdx:mcp:credentialRiskIndicators",
-              value: "bearer-token,generic-secret",
+              name: "cdx:mcp:credentialIndicatorCount",
+              value: "2",
             },
+            { name: "cdx:mcp:credentialReferenceCount", value: "1" },
           ],
         },
       ],
@@ -602,6 +603,56 @@ describe("evaluateRule", () => {
     assert.ok(findings.length > 0, "Should detect token passthrough risk");
   });
 
+  it("should flag shipped AI instruction files in build/post-build BOMs (AGT-007)", async () => {
+    const rules = await loadRules(RULES_DIR);
+    const rule = rules.find((r) => r.id === "AGT-007");
+    assert.ok(rule, "AGT-007 rule should exist");
+
+    const bom = makeBom([
+      {
+        "bom-ref": "file:/repo/CLAUDE.md",
+        name: "CLAUDE.md",
+        type: "file",
+        properties: [
+          { name: "SrcFile", value: "/repo/CLAUDE.md" },
+          { name: "cdx:file:kind", value: "agent-instructions" },
+          { name: "cdx:agent:inventorySource", value: "agent-file" },
+        ],
+      },
+    ]);
+    bom.metadata.lifecycles = [{ phase: "build" }, { phase: "post-build" }];
+
+    const findings = await evaluateRule(rule, bom);
+    assert.ok(findings.length > 0, "Should detect shipped AI instructions");
+    assert.strictEqual(findings[0].severity, "medium");
+  });
+
+  it("should flag shipped MCP config files in build/post-build BOMs (MCP-008)", async () => {
+    const rules = await loadRules(RULES_DIR);
+    const rule = rules.find((r) => r.id === "MCP-008");
+    assert.ok(rule, "MCP-008 rule should exist");
+
+    const bom = makeBom([
+      {
+        "bom-ref": "file:/repo/.vscode/mcp.json",
+        name: "mcp.json",
+        type: "file",
+        properties: [
+          { name: "SrcFile", value: "/repo/.vscode/mcp.json" },
+          { name: "cdx:file:kind", value: "mcp-config" },
+          { name: "cdx:mcp:configFormat", value: "vscode" },
+          { name: "cdx:mcp:configuredServiceCount", value: "1" },
+          { name: "cdx:mcp:configuredServiceNames", value: "releaseDocs" },
+        ],
+      },
+    ]);
+    bom.metadata.lifecycles = [{ phase: "build" }];
+
+    const findings = await evaluateRule(rule, bom);
+    assert.ok(findings.length > 0, "Should detect shipped MCP config");
+    assert.strictEqual(findings[0].severity, "medium");
+  });
+
   it("should detect npm name mismatch (INT-002)", async () => {
     const rules = await loadRules(RULES_DIR);
     const rule = rules.find((r) => r.id === "INT-002");
@@ -2301,6 +2352,62 @@ describe("auditBom", () => {
     }
   });
 
+  it("expands the ai-inventory category alias", async () => {
+    const bom = makeBom(
+      [],
+      [],
+      [
+        {
+          type: "application",
+          name: "agent-guide",
+          version: "latest",
+          "bom-ref": "file:/repo/AGENTS.md",
+          properties: [
+            { name: "SrcFile", value: "/repo/AGENTS.md" },
+            { name: "cdx:agent:inventorySource", value: "agent-file" },
+            { name: "cdx:file:kind", value: "agent-instructions" },
+            {
+              name: "cdx:agent:hasNonOfficialMcpReference",
+              value: "true",
+            },
+            { name: "cdx:agent:mcpPackageRefs", value: "@acme/mcp-server" },
+          ],
+        },
+      ],
+      [
+        {
+          "bom-ref": "urn:service:mcp:demo:1",
+          group: "mcp",
+          name: "demo-server",
+          authenticated: false,
+          endpoints: ["https://mcp.example.com/mcp"],
+          properties: [
+            { name: "cdx:mcp:transport", value: "streamable-http" },
+            { name: "cdx:mcp:serviceType", value: "inferred-endpoint" },
+            { name: "cdx:mcp:inventorySource", value: "agent-file" },
+            { name: "cdx:mcp:toolCount", value: "1" },
+            { name: "cdx:mcp:officialSdk", value: "false" },
+          ],
+        },
+      ],
+    );
+
+    const findings = await auditBom(bom, {
+      bomAuditCategories: "ai-inventory",
+    });
+    assert.ok(findings.some((finding) => finding.category === "ai-agent"));
+    assert.ok(findings.some((finding) => finding.category === "mcp-server"));
+  });
+
+  it("rejects unknown audit categories with valid choices", async () => {
+    await assert.rejects(
+      auditBom(makeBom([]), {
+        bomAuditCategories: "unknown-category",
+      }),
+      /Unknown BOM audit category: unknown-category\. Valid categories: .*ai-inventory \(alias for ai-agent,mcp-server\).*ci-permission.*mcp-server/,
+    );
+  });
+
   it("should filter by minimum severity", async () => {
     const bom = makeBom([
       makeComponent("actions/setup-node", "v3", [