@cdxgen/cdxgen 13.3.0 → 13.5.0

package/bin/sign.js

@@ -20,6 +20,7 @@ import {
   getNonCycloneDxErrorMessage,
   isCycloneDxBom,
 } from "../lib/inventory/bomUtils.js";
+import { parseStrictJson } from "../lib/parsers/strictJson.js";
 
 const _yargs = yargs(hideBin(process.argv));
 
@@ -55,13 +56,19 @@ const args = _yargs
     type: "array",
     string: true,
     description:
-      "Public key (PEM) of an earlier signer. With --mode chain, every existing chain entry must verify with one of these keys before a new entry is appended.",
+      "Public key (PEM) of an earlier signer. Before a new entry is appended, every existing chain entry (--mode chain), or at least one existing entry (--mode signers), must verify with one of these keys.",
   })
   .option("allow-unverified-history", {
     type: "boolean",
     default: false,
     description:
-      "With --mode chain, append even when existing chain entries cannot be verified with --verify-existing-with.",
+      "With --mode chain or signers, append even when the existing signature entries cannot be verified with --verify-existing-with.",
+  })
+  .option("embed-public-key", {
+    type: "boolean",
+    default: true,
+    description:
+      "Embed the signer's public key in the root signature, which binds the signature to that key. Not used for HMAC (HS*) algorithms. Pass --no-embed-public-key to leave it out.",
   })
   .option("key-id", {
     description:
@@ -173,16 +180,19 @@ function describeEntry(result) {
     : `entry ${result.index}`;
 }
 
-// A new chain entry covers every earlier entry, so the signer vouches for
-// that history. Check it with the earlier signers' keys before appending.
-function checkChainHistory(bomJson) {
+// A new chain entry covers every earlier entry, so the signer vouches for that
+// history, and every entry must verify. A new signers entry covers the same
+// content as the existing entries, so at least one must verify to show the
+// content is still what an earlier signer signed.
+function checkExistingSignatures(bomJson) {
   const existing = bomJson.signature;
+  const otherForm = args.mode === "chain" ? "signers" : "chain";
   if (
-    args.mode !== "chain" ||
+    args.mode === "replace" ||
     existing === undefined ||
     (existing !== null &&
       typeof existing === "object" &&
-      Object.hasOwn(existing, "signers"))
+      Object.hasOwn(existing, otherForm))
   ) {
     return;
   }
@@ -192,10 +202,10 @@ function checkChainHistory(bomJson) {
     }
     return fs.readFileSync(keyFile, "utf8");
   });
-  const unverified = checkSignatureEntries(bomJson, keys).filter(
-    (result) => !result.verified,
-  );
-  if (!unverified.length) {
+  const results = checkSignatureEntries(bomJson, keys);
+  const unverified = results.filter((result) => !result.verified);
+  const chain = args.mode === "chain";
+  if (chain ? !unverified.length : unverified.length < results.length) {
     return;
   }
   const details = unverified.map(
@@ -205,7 +215,9 @@ function checkChainHistory(bomJson) {
   if (args.allowUnverifiedHistory) {
     console.warn(
       [
-        `Warning: appending to a chain with ${unverified.length} unverified entry(s):`,
+        chain
+          ? `Warning: appending to a chain with ${unverified.length} unverified entry(s):`
+          : `Warning: appending a signers entry although none of the ${unverified.length} existing entry(s) verified:`,
         ...details,
       ].join("\n"),
     );
@@ -213,7 +225,9 @@ function checkChainHistory(bomJson) {
   }
   throw new Error(
     [
-      `the new chain entry would vouch for ${unverified.length} existing entry(s) that could not be verified:`,
+      chain
+        ? `the new chain entry would vouch for ${unverified.length} existing entry(s) that could not be verified:`
+        : `none of the ${unverified.length} existing signature entry(s) could be verified, so the content may have changed since it was signed:`,
       ...details,
       "Pass --verify-existing-with <public key> for each earlier signer, or --allow-unverified-history to sign anyway.",
     ].join("\n"),
@@ -221,7 +235,7 @@ function checkChainHistory(bomJson) {
 }
 
 try {
-  const bomJson = JSON.parse(fs.readFileSync(args.input, "utf8"));
+  const bomJson = parseStrictJson(fs.readFileSync(args.input));
   if (!isCycloneDxBom(bomJson)) {
     console.error(getNonCycloneDxErrorMessage(bomJson, "cdx-sign"));
     process.exit(1);
@@ -229,10 +243,12 @@ try {
 
   let signedBom = bomJson;
   if (hasPrivateKey && privateKeyContent) {
-    checkChainHistory(bomJson);
+    checkExistingSignatures(bomJson);
     signedBom = signBom(bomJson, {
       privateKey: privateKeyContent,
       algorithm: args.algorithm,
+      embedPublicKey: args.embedPublicKey,
+      embedPublicKeyNested: false,
       keyId: args.keyId,
       mode: args.mode,
       signComponents: args.signComponents,
@@ -247,6 +263,20 @@ try {
     console.log(
       `Mode: ${args.mode} | Algorithm: ${args.algorithm}${args.keyId ? ` | KeyId: ${args.keyId}` : ""}`,
     );
+    const rootSignature = signedBom.signature;
+    const newEntry =
+      rootSignature?.signers?.at(-1) ??
+      rootSignature?.chain?.at(-1) ??
+      rootSignature;
+    if (
+      args.embedPublicKey &&
+      !String(args.algorithm).startsWith("HS") &&
+      newEntry?.publicKey === undefined
+    ) {
+      console.warn(
+        "Warning: this key type has no JWK form, so the public key was not embedded in the signature.",
+      );
+    }
   } else {
     if (!hasAnySignature(bomJson)) {
       console.error(

package/bin/tracebom.js

@@ -14,6 +14,7 @@ import {
   safeWriteSync,
 } from "../lib/ecosystems/utils.js";
 import { DEFAULT_CDX_SPEC_VERSION } from "../lib/inventory/bomUtils.js";
+import { applySpecVersionCompatibility } from "../lib/stages/postgen/specVersionCompat.js";
 
 const _yargs = yargs(hideBin(process.argv));
 
@@ -166,7 +167,7 @@ const args = _yargs
   })
   .option("trace-crypto", {
     description:
-      "Enable eBPF-based cryptographic library and cipher suite tracing (Linux only).",
+      "Trace cryptographic libraries and TLS parameters: eBPF on Linux, crypto DLLs on Windows (elevated prompt), and TLS handshakes through --proxy-egress on every platform.",
     default: true,
     type: "boolean",
   })
@@ -337,6 +338,9 @@ const options = {
     console.error("Dynamic SBOM generation failed: no output was produced.");
     process.exit(1);
   }
+  // tracebom skips postProcess, so the downgrade to an older --spec-version
+  // (for example dropping the 1.7 algorithmFamily of traced crypto) runs here.
+  applySpecVersionCompatibility(bomJson, options);
 
   const jsonPayload = JSON.stringify(bomJson, null, DEBUG_MODE ? 2 : null);
 

package/bin/validate.js

@@ -26,6 +26,7 @@ import {
   safeMkdirSync,
   safeWriteSync,
 } from "../lib/ecosystems/utils.js";
+import { displayValue } from "../lib/helpers/bomSigner.js";
 import {
   getNonCycloneDxErrorMessage,
   isCycloneDxBom,
@@ -35,6 +36,7 @@ import {
   isProtoBomPath,
 } from "../lib/inventory/protobomLoader.js";
 import { getBomWithOras } from "../lib/managers/oci.js";
+import { parseStrictJson } from "../lib/parsers/strictJson.js";
 import { shouldFail, validateBomAdvanced } from "../lib/validator/index.js";
 import { render as renderReport } from "../lib/validator/reporters/index.js";
 
@@ -126,9 +128,8 @@ const args = _yargs
   })
   .option("require-signature", {
     type: "boolean",
-    default: false,
     description:
-      "Exit non-zero (4) when --public-key or --secret-key is provided but signature verification fails.",
+      "Exit non-zero (4) when signature verification fails. On by default when --public-key or --secret-key is given; pass --no-require-signature to only report the result.",
   })
   .option("strict", {
     type: "boolean",
@@ -143,7 +144,11 @@ const args = _yargs
   .help()
   .wrap(Math.min(120, yargs().terminalWidth())).argv;
 
-async function loadBom(input, platform) {
+/**
+ * Loads the BOM. When signatures are verified, the text must also pass
+ * parseStrictJson(), and `strictError` explains why it did not.
+ */
+async function loadBom(input, platform, strict, requireSignature) {
   if (safeExistsSync(input)) {
     try {
       if (isProtoBomPath(input)) {
@@ -151,9 +156,18 @@ async function loadBom(input, platform) {
           "cdx-validate",
           "protobuf BOM input",
         );
-        return readBinary(input, true);
+        return { bomJson: readBinary(input, true) };
       }
-      return JSON.parse(fs.readFileSync(input, "utf8"));
+      const bytes = fs.readFileSync(input);
+      const bomJson = JSON.parse(bytes.toString("utf8"));
+      if (strict) {
+        try {
+          parseStrictJson(bytes);
+        } catch (err) {
+          return { bomJson, strictError: err.message };
+        }
+      }
+      return { bomJson };
     } catch (err) {
       console.error(`Failed to parse ${input}: ${err.message}`);
       process.exit(1);
@@ -164,8 +178,27 @@ async function loadBom(input, platform) {
     input.includes("docker") ||
     input.includes("ghcr")
   ) {
-    const bom = await getBomWithOras(input, platform);
-    if (bom) return bom;
+    let strictError;
+    try {
+      const bom = await getBomWithOras(
+        input,
+        platform,
+        strict ? { checkBytes: parseStrictJson } : {},
+      );
+      if (bom) return { bomJson: bom };
+    } catch (err) {
+      if (requireSignature) {
+        console.error(
+          `cdx-validate: signature verification failed — the attached BOM cannot be verified: ${err.message}`,
+        );
+        process.exit(4);
+      }
+      strictError = err.message;
+    }
+    if (strictError) {
+      const bom = await getBomWithOras(input, platform);
+      if (bom) return { bomJson: bom, strictError };
+    }
   }
   console.error(`Input '${input}' is not a readable SBOM.`);
   process.exit(1);
@@ -173,12 +206,21 @@ async function loadBom(input, platform) {
 }
 
 function loadKeyFile(path, label, encoding) {
-  if (!path) return null;
+  if (path === undefined) return null;
+  if (typeof path !== "string" || !path.trim()) {
+    console.error(`cdx-validate: ${label} needs exactly one file path.`);
+    process.exit(1);
+  }
   if (!safeExistsSync(path)) {
     console.error(`${label} '${path}' not found.`);
     process.exit(1);
   }
-  return fs.readFileSync(path, encoding);
+  const content = fs.readFileSync(path, encoding);
+  if (!content.toString().trim()) {
+    console.error(`${label} '${path}' is empty.`);
+    process.exit(1);
+  }
+  return content;
 }
 
 function splitCsv(value) {
@@ -208,14 +250,21 @@ function isLocalProtoBomInput(input) {
   return isProtoBomPath(input);
 }
 
-const bomJson = await loadBom(args.input, args.platform);
-if (args.publicKey && args.secretKey) {
+const keyGiven = args.publicKey !== undefined || args.secretKey !== undefined;
+const requireSignature = args.requireSignature ?? keyGiven;
+const { bomJson, strictError } = await loadBom(
+  args.input,
+  args.platform,
+  keyGiven,
+  requireSignature,
+);
+if (args.publicKey !== undefined && args.secretKey !== undefined) {
   console.error("cdx-validate: use either --public-key or --secret-key.");
   process.exit(1);
 }
 const publicKeyStr = loadKeyFile(args.publicKey, "Public key", "utf8");
 const secretKey = loadKeyFile(args.secretKey, "Shared secret");
-const verificationRequested = Boolean(publicKeyStr || secretKey);
+const verificationRequested = keyGiven;
 const inputIsLocalProtoBom = isLocalProtoBomInput(args.input);
 if (!isCycloneDxBom(bomJson)) {
   console.error(getNonCycloneDxErrorMessage(bomJson, "cdx-validate"));
@@ -226,7 +275,7 @@ if (inputIsLocalProtoBom && verificationRequested) {
   console.error(
     "cdx-validate: protobuf BOM input does not currently preserve JSF signature blocks. Verify signatures against the source JSON BOM instead.",
   );
-  process.exit(args.requireSignature ? 4 : 1);
+  process.exit(requireSignature ? 4 : 1);
 }
 
 const report = await validateBomAdvanced(bomJson, {
@@ -237,10 +286,17 @@ const report = await validateBomAdvanced(bomJson, {
   minSeverity: args.minSeverity,
   includeManual: args.includeManual,
   includePass: args.includePass,
-  publicKey: publicKeyStr || undefined,
-  secretKey: secretKey || undefined,
+  publicKey: publicKeyStr ?? undefined,
+  secretKey: secretKey ?? undefined,
   nestedSignatures: args.nestedSignatures,
 });
+if (strictError && verificationRequested) {
+  report.signatureVerified = false;
+  report.signatureEntries = null;
+  report.signatureDetails = {
+    error: `the BOM cannot be verified: ${strictError}`,
+  };
+}
 
 let output;
 try {
@@ -267,14 +323,24 @@ for (const e of report.validationErrors || []) {
 const { shouldFail: fail, reason } = shouldFail(report, {
   failSeverity: args.failSeverity,
   strict: args.strict,
-  requireSignature: Boolean(args.requireSignature && verificationRequested),
+  requireSignature: Boolean(requireSignature && verificationRequested),
 });
 
-if (report.signatureVerified === false && args.requireSignature) {
+if (report.signatureVerified === false && verificationRequested) {
   console.error(
     `cdx-validate: signature verification failed — ${report.signatureDetails?.error || "no matching key"}.`,
   );
-  process.exit(4);
+  if (requireSignature) {
+    process.exit(4);
+  }
+}
+const unverifiedEntries = (report.signatureEntries || []).filter(
+  (entry) => !entry.verified,
+);
+if (report.signatureVerified && unverifiedEntries.length) {
+  console.error(
+    `cdx-validate: warning — ${unverifiedEntries.length} of ${report.signatureEntries.length} signature entries did not verify with the given key: ${unverifiedEntries.map((entry) => `entry ${entry.index}${entry.keyId === undefined ? "" : ` (keyId '${displayValue(entry.keyId)}')`}`).join(", ")}.`,
+  );
 }
 
 if (args.strict && report.schemaValid === false) {

package/bin/verify.js

@@ -17,7 +17,7 @@ import {
   displayValue,
   loadSharedSecret,
   loadVerificationKey,
-  verifyNode,
+  verifyBomSignatures,
 } from "../lib/helpers/bomSigner.js";
 import {
   getNonCycloneDxErrorMessage,
@@ -25,6 +25,7 @@ import {
 } from "../lib/inventory/bomUtils.js";
 import { isProtoBomPath } from "../lib/inventory/protobomLoader.js";
 import { getBomWithOras } from "../lib/managers/oci.js";
+import { parseStrictJson } from "../lib/parsers/strictJson.js";
 
 const dirName = dirNameStr;
 
@@ -41,10 +42,13 @@ const args = _yargs
     description: "The platform to validate. No default",
   })
   .option("public-key", {
+    type: "array",
+    string: true,
     description:
-      "Public key in PEM format. Default public.key unless --secret-key is used",
+      "Trusted public key in PEM format. Repeat to trust several keys; a signature entry verifies when one of them verifies it.",
   })
   .option("secret-key", {
+    type: "string",
     description:
       "File holding the shared secret for HMAC (HS256, HS384, HS512) signatures. HMAC signatures are only accepted with this option.",
   })
@@ -52,7 +56,19 @@ const args = _yargs
     type: "boolean",
     default: true,
     description:
-      "Strictly verify all nested component, service, and annotation signatures against the provided public key. Pass --no-deep to verify only the root signature.",
+      "Strictly verify all nested component, service, and annotation signatures against the provided keys. Pass --no-deep to verify only the root signature.",
+  })
+  .option("require-all", {
+    type: "boolean",
+    default: false,
+    description:
+      "Require every entry of a signers or chain signature to verify with one of the keys, instead of at least one.",
+  })
+  .option("allow-nested-only", {
+    type: "boolean",
+    default: false,
+    description:
+      "Accept a BOM without a root signature when every component, service, and annotation carries a signature that verifies. No signature then covers the other members of the BOM.",
   })
   .completion("completion", "Generate bash/zsh completion")
   .epilogue("for documentation, visit https://cdxgen.github.io/cdxgen")
@@ -96,7 +112,7 @@ async function getBom(args) {
       process.exit(1);
     }
     try {
-      return JSON.parse(fs.readFileSync(args.input, "utf8"));
+      return parseStrictJson(fs.readFileSync(args.input));
     } catch (error) {
       console.log(`Failed to parse '${args.input}': ${error.message}`);
       process.exit(1);
@@ -107,11 +123,32 @@ async function getBom(args) {
     args.input.includes("docker") ||
     args.input.includes("ghcr")
   ) {
-    return await getBomWithOras(args.input, args.platform);
+    try {
+      return await getBomWithOras(args.input, args.platform, {
+        checkBytes: parseStrictJson,
+      });
+    } catch (error) {
+      console.log(
+        `Failed to parse the BOM attached to '${args.input}': ${error.message}`,
+      );
+      process.exit(1);
+    }
   }
   return undefined;
 }
 
+const publicKeyFiles = args.publicKey || [];
+if (publicKeyFiles.length && args.secretKey) {
+  console.log("Use either --public-key or --secret-key, not both.");
+  process.exit(1);
+}
+if (!publicKeyFiles.length && !args.secretKey) {
+  console.log(
+    "Name the trusted key with --public-key <file>, or --secret-key <file> for HMAC signatures.",
+  );
+  process.exit(1);
+}
+
 const bomJson = await getBom(args);
 
 if (!bomJson) {
@@ -123,107 +160,139 @@ if (!isCycloneDxBom(bomJson)) {
   process.exit(1);
 }
 
-if (args.publicKey && args.secretKey) {
-  console.log("Use either --public-key or --secret-key, not both.");
-  process.exit(1);
-}
-const keyFile = args.secretKey || args.publicKey || "public.key";
-if (!args.secretKey && !args.publicKey) {
-  console.log(
-    `No --public-key given; using '${keyFile}' from the current directory. Pass --public-key to name the trusted key explicitly.`,
-  );
-}
-if (!safeExistsSync(keyFile)) {
-  console.log(
-    args.secretKey
-      ? "Shared secret for signature verification is missing!"
-      : "Public key for signature verification is missing!",
-  );
-  process.exit(1);
-}
-
-let verificationKey;
-try {
-  verificationKey = args.secretKey
-    ? loadSharedSecret(fs.readFileSync(keyFile))
-    : loadVerificationKey(fs.readFileSync(keyFile, "utf8"));
-} catch (error) {
-  console.log(`Unable to use '${keyFile}': ${error.message}`);
-  process.exit(1);
+const verificationKeys = [];
+for (const keyFile of args.secretKey ? [args.secretKey] : publicKeyFiles) {
+  if (!safeExistsSync(keyFile)) {
+    console.log(
+      args.secretKey
+        ? `Shared secret '${keyFile}' for signature verification is missing!`
+        : `Public key '${keyFile}' for signature verification is missing!`,
+    );
+    process.exit(1);
+  }
+  try {
+    verificationKeys.push(
+      args.secretKey
+        ? loadSharedSecret(fs.readFileSync(keyFile))
+        : loadVerificationKey(fs.readFileSync(keyFile, "utf8")),
+    );
+  } catch (error) {
+    console.log(`Unable to use '${keyFile}': ${error.message}`);
+    process.exit(1);
+  }
 }
 
-function verify(node) {
-  const reasons = [];
-  const match = verifyNode(node, verificationKey, { reasons });
-  return { match, reasons };
+function describeEntry(node, entry) {
+  const parts = [displayValue(entry.algorithm)];
+  if (entry.keyId !== undefined) {
+    parts.push(`keyId '${displayValue(entry.keyId)}'`);
+  }
+  const position =
+    node.form === "single" ? "" : `${node.form}[${entry.index}] `;
+  return `${position}(${parts.join(", ")})`;
 }
 
-function printReasons(reasons) {
-  for (const reason of new Set(reasons)) {
+function printRejections(node) {
+  for (const reason of node.reasons) {
     console.log(`  - ${reason}`);
   }
-}
-
-let rootResult = null;
-if (bomJson.signature) {
-  rootResult = verify(bomJson);
-}
-
-const verifyNested = args.deep || !bomJson.signature;
-let hasInvalidNested = false;
-let checkedNested = 0;
-
-if (verifyNested) {
-  const nestedTargets = [
-    ["components", "Component", (c) => c["bom-ref"] || c.name],
-    ["services", "Service", (s) => s["bom-ref"] || s.name],
-    ["annotations", "Annotation", (a) => a["bom-ref"] || a.subject],
-  ];
-  for (const [field, label, nameOf] of nestedTargets) {
-    for (const node of bomJson[field] || []) {
-      if (node?.signature) {
-        checkedNested++;
-        const result = verify(node);
-        if (!result.match) {
-          console.log(
-            `${label} '${displayValue(nameOf(node))}' signature is invalid!`,
-          );
-          printReasons(result.reasons);
-          hasInvalidNested = true;
-        }
-      }
+  for (const entry of node.entries) {
+    for (const reason of entry.reasons) {
+      console.log(
+        `  - ${node.form === "single" ? "" : `${node.form}[${entry.index}]: `}${reason}`,
+      );
     }
   }
 }
 
-if (hasInvalidNested) {
+const report = verifyBomSignatures(bomJson, verificationKeys, {
+  deep: args.deep,
+  allowNestedOnly: args.allowNestedOnly,
+  requireAll: args.requireAll,
+});
+
+for (const error of report.errors) {
+  console.log(error);
+}
+const keyFiles = args.secretKey ? [args.secretKey] : publicKeyFiles;
+if (args.requireAll && report.root?.form) {
+  report.root.keysMatched.forEach((matched, index) => {
+    if (!matched) {
+      console.log(`  - key #${index + 1}: ${keyFiles[index]}`);
+    }
+  });
+}
+const invalidNested = report.nested.filter((item) => !item.verified);
+for (const item of invalidNested) {
+  console.log(`${item.label} signature is invalid!`);
+  printRejections(item);
+}
+if (invalidNested.length) {
   console.log("One or more nested signatures are invalid!");
-  if (rootResult?.match) {
+  if (report.root?.verified) {
     console.log(
       "The root signature verifies with this key. Nested signatures belong to the party that created them, so pass --no-deep to verify only the root signature with this key.",
     );
   }
+}
+if (report.root && !report.root.verified) {
+  console.log("BOM signature is invalid!");
+  printRejections(report.root);
+  if (!report.root.reasons.length && !report.root.match) {
+    console.log(
+      "If this BOM was signed with cdxgen 13.2.0 or earlier, re-sign it with this version of cdx-sign.",
+    );
+  }
+}
+if (!report.root && !bomJson.signature && !args.allowNestedOnly) {
+  console.log(
+    "Pass --allow-nested-only to accept a BOM whose components, services, and annotations are all signed.",
+  );
+}
+for (const notice of report.notices) {
+  console.log(`Note: ${notice}`);
+}
+if (!report.verified) {
   process.exit(1);
 }
 
-if (bomJson.signature) {
-  const rootMatch = rootResult?.match;
-  if (rootMatch) {
-    const identifier = rootMatch.keyId
-      ? `KeyId: '${displayValue(rootMatch.keyId)}'`
-      : `Algorithm: '${rootMatch.algorithm}'`;
-    console.log(`✓ Signature is valid! (Matched ${identifier})`);
-  } else {
-    console.log("BOM signature is invalid!");
-    printReasons(rootResult?.reasons || []);
+if (report.root) {
+  const rootMatch = report.root.match;
+  const identifier = rootMatch.keyId
+    ? `KeyId: '${displayValue(rootMatch.keyId)}'`
+    : `Algorithm: '${rootMatch.algorithm}'`;
+  console.log(`✓ Signature is valid! (Matched ${identifier})`);
+  const unverified = report.root.entries.filter((entry) => !entry.verified);
+  if (unverified.length) {
     console.log(
-      "If this BOM was signed with cdxgen 13.2.0 or earlier, re-sign it with this version of cdx-sign.",
+      `Warning: ${unverified.length} of ${report.root.entries.length} ${report.root.form} entries did not verify with the given key(s). Pass --require-all to fail in that case.`,
     );
-    process.exit(1);
+    for (const entry of unverified) {
+      console.log(
+        `  - ${describeEntry(report.root, entry)}: ${entry.reasons[0] || "not verified"}`,
+      );
+    }
   }
-} else if (checkedNested > 0 && !hasInvalidNested) {
-  console.log(`✓ ${checkedNested} nested signature(s) are valid!`);
 } else {
-  console.log("No valid signatures found to verify!");
-  process.exit(1);
+  console.log(`✓ ${report.nested.length} nested signature(s) are valid!`);
+}
+const MAX_LISTED_ENTRIES = 10;
+const unverifiedNested = report.nested.flatMap((item) =>
+  item.entries
+    .filter((entry) => !entry.verified)
+    .map(
+      (entry) =>
+        `${item.label} ${describeEntry(item, entry)}: ${entry.reasons[0] || "not verified"}`,
+    ),
+);
+if (unverifiedNested.length) {
+  console.log(
+    `Warning: ${unverifiedNested.length} nested signature entries did not verify with the given key(s). Pass --require-all to fail in that case.`,
+  );
+  for (const line of unverifiedNested.slice(0, MAX_LISTED_ENTRIES)) {
+    console.log(`  - ${line}`);
+  }
+  if (unverifiedNested.length > MAX_LISTED_ENTRIES) {
+    console.log(`  - and ${unverifiedNested.length - MAX_LISTED_ENTRIES} more`);
+  }
 }