@cyclonedx/cdxgen 11.0.4 → 11.0.6

package/lib/cli/index.js

@@ -883,7 +883,14 @@ function addComponent(
       purl: purlString,
       externalReferences: addExternalReferences(pkg),
     };
-
+    if (options.specVersion >= 1.5) {
+      component.pedigree = pkg.pedigree || undefined;
+    }
+    if (options.specVersion >= 1.6) {
+      component.releaseNotes = pkg.releaseNotes || undefined;
+      component.modelCard = pkg.modelCard || undefined;
+      component.data = pkg.data || undefined;
+    }
     component["type"] = determinePackageType(pkg);
     component["bom-ref"] = decodeURIComponent(purlString);
     if (
@@ -911,8 +918,22 @@ function addComponent(
         pkg.evidence.identity &&
         !Array.isArray(pkg.evidence.identity)
       ) {
+        // Automatically add concludedValue
+        if (pkg.evidence.identity?.methods?.length === 1) {
+          pkg.evidence.identity.concludedValue =
+            pkg.evidence.identity.methods[0].value;
+        }
         component.evidence.identity = [pkg.evidence.identity];
       }
+      // Convert evidence.identity section to an object for 1.5
+      if (
+        options.specVersion === 1.5 &&
+        pkg.evidence &&
+        pkg.evidence.identity &&
+        Array.isArray(pkg.evidence.identity)
+      ) {
+        component.evidence.identity = pkg.evidence.identity[0];
+      }
     }
     // Upgrade authors section
     if (options.specVersion >= 1.6 && component.author) {
@@ -1264,7 +1285,6 @@ export async function createJavaBom(path, options) {
   // For java, this would correctly include the cyclonedx maven plugin.
   let tools = undefined;
   let possible_misses = false;
-  let mavenDepsTreeInfoShown = false;
   // war/ear mode
   if (path.endsWith(".war") || path.endsWith(".jar")) {
     // Check if the file exists
@@ -1294,6 +1314,11 @@ export async function createJavaBom(path, options) {
       parentComponent,
     });
   }
+  // -t quarkus is supported
+  let isQuarkus = options?.projectType?.includes("quarkus");
+  let useMavenDepsTree = isQuarkus ? false : PREFER_MAVEN_DEPS_TREE;
+  // Is this a multi-module project
+  let rootModules;
   // maven - pom.xml
   const pomFiles = getAllFiles(
     path,
@@ -1305,37 +1330,72 @@ export async function createJavaBom(path, options) {
     pomFiles?.length &&
     isPackageManagerAllowed("maven", ["bazel", "sbt", "gradle"], options)
   ) {
-    let result = undefined;
-    const cdxMavenPlugin =
-      process.env.CDX_MAVEN_PLUGIN ||
-      "org.cyclonedx:cyclonedx-maven-plugin:2.8.0";
-    const cdxMavenGoal = process.env.CDX_MAVEN_GOAL || "makeAggregateBom";
-    let mvnArgs = [
-      "-fn",
-      `${cdxMavenPlugin}:${cdxMavenGoal}`,
-      "-DoutputName=bom",
-    ];
-    if (includeMavenTestScope) {
-      mvnArgs.push("-DincludeTestScope=true");
-    }
-    // By using quiet mode we can reduce the maxBuffer used and avoid crashes
-    if (!DEBUG_MODE) {
-      mvnArgs.push("-q");
-    }
-    // Support for passing additional settings and profile to maven
-    if (process.env.MVN_ARGS) {
-      const addArgs = process.env.MVN_ARGS.split(" ");
-      mvnArgs = mvnArgs.concat(addArgs);
+    if (!isQuarkus) {
+      // Quarkus projects require special treatment. To detect quarkus, we parse the first 3 maven file to look for a hit
+      for (const pf of pomFiles.slice(0, 3)) {
+        const pomMap = parsePom(pf);
+        if (!rootModules && pomMap?.modules?.length) {
+          rootModules = pomMap.modules;
+        }
+        // In quarkus mode, we cannot use the maven deps tree
+        if (pomMap.isQuarkus) {
+          isQuarkus = true;
+          useMavenDepsTree = false;
+          break;
+        }
+      }
     }
-    // specVersion 1.4 doesn't support externalReferences.type=disribution-intake
-    // so we need to run the plugin with the correct version
-    if (options.specVersion === 1.4) {
-      mvnArgs = mvnArgs.concat("-DschemaVersion=1.4");
+    let result = undefined;
+    let mvnArgs;
+    if (isQuarkus) {
+      // disable analytics. See: https://quarkus.io/usage/
+      mvnArgs = [
+        "-fn",
+        "quarkus:dependency-sbom",
+        "-Dquarkus.analytics.disabled=true",
+      ];
+    } else {
+      const cdxMavenPlugin =
+        process.env.CDX_MAVEN_PLUGIN ||
+        "org.cyclonedx:cyclonedx-maven-plugin:2.9.1";
+      const cdxMavenGoal = process.env.CDX_MAVEN_GOAL || "makeAggregateBom";
+      mvnArgs = [
+        "-fn",
+        `${cdxMavenPlugin}:${cdxMavenGoal}`,
+        "-DoutputName=bom",
+      ];
+      if (includeMavenTestScope) {
+        mvnArgs.push("-DincludeTestScope=true");
+      }
+      // By using quiet mode we can reduce the maxBuffer used and avoid crashes
+      if (!DEBUG_MODE) {
+        mvnArgs.push("-q");
+      }
+      // Support for passing additional settings and profile to maven
+      if (process.env.MVN_ARGS) {
+        const addArgs = process.env.MVN_ARGS.split(" ");
+        mvnArgs = mvnArgs.concat(addArgs);
+      }
+      // specVersion 1.4 doesn't support externalReferences.type=disribution-intake
+      // so we need to run the plugin with the correct version
+      if (options.specVersion === 1.4) {
+        mvnArgs = mvnArgs.concat("-DschemaVersion=1.4");
+      }
     }
     const firstPom = pomFiles.length ? pomFiles[0] : undefined;
     let mavenCmd = getMavenCommand(path, path);
     for (const f of pomFiles) {
       const basePath = dirname(f);
+      if (
+        isQuarkus &&
+        !options.deep &&
+        rootModules?.includes(basename(basePath))
+      ) {
+        if (DEBUG_MODE) {
+          console.log("Skipped sub-module", basePath);
+        }
+        continue;
+      }
       const settingsXml = join(basePath, "settings.xml");
       if (existsSync(settingsXml)) {
         console.log(
@@ -1358,16 +1418,7 @@ export async function createJavaBom(path, options) {
         }
       }
       // Use the cyclonedx maven plugin if there is no preference for maven deps tree
-      if (!PREFER_MAVEN_DEPS_TREE) {
-        if (!mavenDepsTreeInfoShown && DEBUG_MODE) {
-          console.log(
-            "cdxgen now supports generating SBOM with only the maven cli without the need for the cyclonedx-maven plugin. This mode works better in enterprise environments and in multi-module projects.",
-          );
-          console.log(
-            "Set the environment variable PREFER_MAVEN_DEPS_TREE to true to enable this.",
-          );
-          mavenDepsTreeInfoShown = true;
-        }
+      if (!useMavenDepsTree) {
         console.log(
           `Executing '${mavenCmd} ${mvnArgs.join(" ")}' in`,
           basePath,
@@ -1381,19 +1432,23 @@ export async function createJavaBom(path, options) {
         });
         // Check if the cyclonedx plugin created the required bom.json file
         // Sometimes the plugin fails silently for complex maven projects
-        bomJsonFiles = getAllFiles(path, "**/target/*.json", options);
+        bomJsonFiles = getAllFiles(
+          path,
+          "**/target/*{cdx,bom,cyclonedx}*.json",
+          options,
+        );
         // Check if the bom json files got created in a directory other than target
         if (!bomJsonFiles.length) {
           bomJsonFiles = getAllFiles(
             path,
-            "target/**/*{cdx,bom}*.json",
+            "target/**/*{cdx,bom,cyclonedx}*.json",
             options,
           );
         }
       }
       // Also check if the user has a preference for maven deps tree command
       if (
-        PREFER_MAVEN_DEPS_TREE ||
+        useMavenDepsTree ||
         !bomJsonFiles.length ||
         result?.status !== 0 ||
         result?.error
@@ -1539,7 +1594,7 @@ export async function createJavaBom(path, options) {
       }
     } // for
     // Locate and parse all bom.json files from the maven plugin
-    if (!PREFER_MAVEN_DEPS_TREE) {
+    if (!useMavenDepsTree) {
       for (const abjson of bomJsonFiles) {
         let bomJsonObj = undefined;
         try {
@@ -1556,7 +1611,9 @@ export async function createJavaBom(path, options) {
               !tools &&
               bomJsonObj.metadata &&
               bomJsonObj.metadata.tools &&
-              Array.isArray(bomJsonObj.metadata.tools)
+              (Array.isArray(bomJsonObj.metadata.tools) ||
+                bomJsonObj.metadata.tools.components ||
+                bomJsonObj.metadata.tools.services)
             ) {
               tools = bomJsonObj.metadata.tools;
             }
@@ -1621,10 +1678,6 @@ export async function createJavaBom(path, options) {
         console.warn(
           "Multiple errors occurred while building this project with maven. The SBOM is therefore incomplete!",
         );
-      } else if (!PREFER_MAVEN_DEPS_TREE) {
-        console.log(
-          "Try generating an SBOM with the maven dependency tree plugin. Set the environment variable PREFER_MAVEN_DEPS_TREE to true to enable this.",
-        );
       }
     }
   }
@@ -2270,58 +2323,71 @@ export async function createNodejsBom(path, options) {
       }
     }
   }
-  const pkgJsonLockFile = getAllFiles(path, "package-lock.json", options);
-  const pkgJsonFile = getAllFiles(
+  const pkgJsonLockFiles = getAllFiles(
+    path,
+    `${options.multiProject ? "**/" : ""}package-lock.json`,
+    options,
+  );
+  const pkgJsonFiles = getAllFiles(
     path,
     `${options.multiProject ? "**/" : ""}package.json`,
     options,
   );
   const yarnLockFile = getAllFiles(path, "yarn.lock", options);
   const pnpmLockFile = getAllFiles(path, "pnpm-lock.yaml", options);
+  const npmInstallCount = Number.parseInt(process.env.NPM_INSTALL_COUNT) || 2;
+  // Automatic npm install logic.
+  // Only perform npm install for smaller projects (< 2 package.json) without the correct number of lock files
   if (
-    pkgJsonLockFile?.length === 0 &&
+    (pkgJsonLockFiles?.length === 0 ||
+      pkgJsonLockFiles?.length < pkgJsonFiles?.length) &&
     yarnLockFile?.length === 0 &&
     pnpmLockFile?.length === 0 &&
-    pkgJsonFile?.length === 1 &&
+    pkgJsonFiles?.length <= npmInstallCount &&
     options.installDeps
   ) {
-    let pkgMgr = "npm";
-    const supPkgMgrs = ["npm", "yarn", "yarnpkg", "pnpm", "pnpx"];
-    const pkgData = JSON.parse(readFileSync(pkgJsonFile[0], "utf8"));
-    const mgrData = pkgData.packageManager;
-    let mgr = "";
-    let installArgs = ["install"];
-    if (mgrData) {
-      mgr = mgrData.split("@")[0];
-    }
-    if (supPkgMgrs.includes(mgr)) {
-      pkgMgr = mgr;
-    }
-    // Support for passing additional args to the install command
-    if (process.env[`${pkgMgr.toUpperCase()}_INSTALL_ARGS`]) {
-      const addArgs =
-        process.env[`${pkgMgr.toUpperCase()}_INSTALL_ARGS`].split(" ");
-      installArgs = installArgs.concat(addArgs);
-    }
-    const basePath = dirname(pkgJsonFile[0]);
-    console.log(`Executing '${pkgMgr} ${installArgs.join(" ")}' in`, basePath);
-    const result = spawnSync(pkgMgr, installArgs, {
-      cwd: basePath,
-      encoding: "utf-8",
-      timeout: TIMEOUT_MS,
-      maxBuffer: MAX_BUFFER,
-    });
-    if (result.status !== 0 || result.error) {
-      console.error(
-        `${pkgMgr} install has failed. Check if ${pkgMgr} is installed and available in PATH.`,
+    for (const apkgJson of pkgJsonFiles) {
+      let pkgMgr = "npm";
+      const supPkgMgrs = ["npm", "yarn", "yarnpkg", "pnpm", "pnpx"];
+      const pkgData = JSON.parse(readFileSync(apkgJson, "utf8"));
+      const mgrData = pkgData.packageManager;
+      let mgr = "";
+      let installArgs = ["install"];
+      if (mgrData) {
+        mgr = mgrData.split("@")[0];
+      }
+      if (supPkgMgrs.includes(mgr)) {
+        pkgMgr = mgr;
+      }
+      // Support for passing additional args to the install command
+      if (process.env[`${pkgMgr.toUpperCase()}_INSTALL_ARGS`]) {
+        const addArgs =
+          process.env[`${pkgMgr.toUpperCase()}_INSTALL_ARGS`].split(" ");
+        installArgs = installArgs.concat(addArgs);
+      }
+      const basePath = dirname(apkgJson);
+      console.log(
+        `Executing '${pkgMgr} ${installArgs.join(" ")}' in`,
+        basePath,
       );
-      if (DEBUG_MODE && result.stdout) {
-        console.log(result.stdout);
-      }
-      if (result.stderr) {
-        console.log(result.stderr);
+      const result = spawnSync(pkgMgr, installArgs, {
+        cwd: basePath,
+        encoding: "utf-8",
+        timeout: TIMEOUT_MS,
+        maxBuffer: MAX_BUFFER,
+      });
+      if (result.status !== 0 || result.error) {
+        console.error(
+          `${pkgMgr} install has failed. Check if ${pkgMgr} is installed and available in PATH.`,
+        );
+        if (DEBUG_MODE && result.stdout) {
+          console.log(result.stdout);
+        }
+        if (result.stderr) {
+          console.log(result.stderr);
+        }
+        options.failOnError && process.exit(1);
       }
-      options.failOnError && process.exit(1);
     }
     pkgLockFiles = getAllFiles(
       path,
@@ -4878,15 +4944,15 @@ export function createPHPBom(path, options) {
       if (DEBUG_MODE) {
         console.log(`Parsing ${f}`);
       }
-      const rootRequires = [];
+      let rootRequires = [];
       // Is there a composer.json to find the module parent component
       if (existsSync(join(basePath, "composer.json"))) {
         const retMap = parseComposerJson(join(basePath, "composer.json"));
         moduleParent = retMap.moduleParent;
-        const rootRequires = retMap.rootRequires;
+        rootRequires = retMap.rootRequires;
         // Track all the modules in a mono-repo
         if (!Object.keys(parentComponent).length) {
-          parentComponent = moduleParent;
+          parentComponent = { ...moduleParent };
         } else {
           parentComponent.components = parentComponent.components || [];
           parentComponent.components.push(moduleParent);
@@ -4895,25 +4961,21 @@ export function createPHPBom(path, options) {
       const retMap = parseComposerLock(f, rootRequires);
       if (retMap.pkgList?.length) {
         pkgList = pkgList.concat(retMap.pkgList);
-      }
-      if (!moduleParent) {
-        moduleParent = createDefaultParentComponent(
-          basePath,
-          "composer",
-          options,
-        );
+        pkgList = trimComponents(pkgList);
       }
       if (retMap.dependenciesList) {
-        // Complete the dependency tree by making parent component depend on the first level
-        const pdependencies = {
-          ref: moduleParent["bom-ref"],
-          dependsOn: [
-            ...new Set(retMap.rootList.map((p) => p["bom-ref"])),
-          ].sort(),
-        };
+        if (moduleParent?.["bom-ref"]) {
+          // Complete the dependency tree by making parent component depend on the first level
+          dependencies.splice(0, 0, {
+            ref: moduleParent["bom-ref"],
+            dependsOn: [
+              ...new Set(retMap.rootList.map((p) => p["bom-ref"])),
+            ].sort(),
+          });
+        }
         dependencies = mergeDependencies(
           dependencies,
-          [pdependencies, ...retMap.dependenciesList],
+          retMap.dependenciesList,
           parentComponent,
         );
       }
@@ -5551,6 +5613,43 @@ export function trimComponents(components) {
           existingComponent.properties = comp.properties;
         }
       }
+      // Retain all component.evidence.identity
+      if (comp?.evidence?.identity) {
+        if (!existingComponent.evidence) {
+          existingComponent.evidence = { identity: [] };
+        } else if (
+          existingComponent?.evidence?.identity &&
+          !Array.isArray(existingComponent.evidence.identity)
+        ) {
+          existingComponent.evidence.identity = [
+            existingComponent.evidence.identity,
+          ];
+        }
+        // comp.evidence.identity can be an array or object
+        // Merge the evidence.identity based on methods or objects
+        const identities = Array.isArray(comp.evidence.identity)
+          ? comp.evidence.identity
+          : [comp.evidence.identity];
+        for (const aident of identities) {
+          let methodBasedMerge = false;
+          if (aident?.methods?.length) {
+            for (const amethod of aident.methods) {
+              for (const existIdent of existingComponent.evidence.identity) {
+                if (existIdent.field === aident.field) {
+                  if (!existIdent.methods) {
+                    existIdent.methods = [];
+                  }
+                  existIdent.methods.push(amethod);
+                  methodBasedMerge = true;
+                }
+              }
+            }
+          }
+          if (!methodBasedMerge && aident.field && aident.confidence) {
+            existingComponent.evidence.identity.push(aident);
+          }
+        }
+      }
       // If the component is required in any of the child projects, then make it required
       if (
         existingComponent?.scope !== "required" &&
@@ -5792,6 +5891,12 @@ export async function createMultiXBom(pathList, options) {
         ) {
           parentSubComponents.push(bomData.parentComponent);
         }
+        // Retain metadata.component.components
+        if (bomData.parentComponent?.components?.length) {
+          parentSubComponents = parentSubComponents.concat(
+            bomData.parentComponent.components,
+          );
+        }
       }
     }
     if (hasAnyProjectType(["oci", "ruby"], options)) {
@@ -5814,6 +5919,12 @@ export async function createMultiXBom(pathList, options) {
         ) {
           parentSubComponents.push(bomData.parentComponent);
         }
+        // Retain metadata.component.components
+        if (bomData.parentComponent?.components?.length) {
+          parentSubComponents = parentSubComponents.concat(
+            bomData.parentComponent.components,
+          );
+        }
       }
     }
     if (hasAnyProjectType(["oci", "csharp"], options)) {
@@ -5832,6 +5943,12 @@ export async function createMultiXBom(pathList, options) {
         ) {
           parentSubComponents.push(bomData.parentComponent);
         }
+        // Retain metadata.component.components
+        if (bomData.parentComponent?.components?.length) {
+          parentSubComponents = parentSubComponents.concat(
+            bomData.parentComponent.components,
+          );
+        }
       }
     }
     if (hasAnyProjectType(["oci", "dart"], options)) {

package/lib/helpers/display.js

@@ -178,34 +178,44 @@ const locationComparator = (a, b) => {
 };
 
 export function printOccurrences(bomJson) {
-  const data = [["Group", "Name", "Version", "Occurrences"]];
   if (!bomJson || !bomJson.components) {
     return;
   }
-  for (const comp of bomJson.components) {
-    if (!comp.evidence || !comp.evidence.occurrences) {
-      continue;
-    }
-    data.push([
-      comp.group || "",
-      comp.name,
-      comp.version || "",
-      comp.evidence.occurrences
-        .map((l) => l.location)
-        .sort(locationComparator)
-        .join("\n"),
-    ]);
-  }
+  const data = ["Group", "Name", "Version", "Occurrences"];
   const config = {
-    header: {
-      alignment: "center",
-      content: "Component Evidence\nGenerated with \u2665  by cdxgen",
+    columnDefault: {
+      width: 30,
     },
+    columnCount: 4,
+    columns: [
+      { width: 30 },
+      { width: 30 },
+      { width: 25, alignment: "right" },
+      { width: 80 },
+    ],
   };
-  if (data.length > 1) {
-    console.log(table(data, config));
+  const stream = createStream(config); // Create stream with the config
+  const header = "Component Evidence\nGenerated with \u2665  by cdxgen";
+  console.log(header);
+  stream.write(data);
+  // Stream the components
+  for (const comp of bomJson.components) {
+    if (comp.evidence?.occurrences) {
+      const row = [
+        comp.group || "",
+        comp.name,
+        comp.version || "",
+        comp.evidence.occurrences
+          .map((l) => l.location)
+          .sort(locationComparator)
+          .join("\n"),
+      ];
+      stream.write(row);
+    }
   }
+  console.log();
 }
+
 export function printCallStack(bomJson) {
   const data = [["Group", "Name", "Version", "Call Stack"]];
   if (!bomJson || !bomJson.components) {

package/lib/helpers/utils.js

@@ -267,6 +267,7 @@ export const PROJECT_TYPE_ALIASES = {
     "maven",
     "sbt",
     "bazel",
+    "quarkus",
   ],
   android: ["android", "apk", "aab"],
   jar: ["jar", "war", "ear"],
@@ -401,15 +402,12 @@ export function isFeatureEnabled(cliOptions, feature) {
     return true;
   }
   // Retry by replacing hyphens with underscore
-  if (
+  return !!(
     process.env[feature.replaceAll("-", "_").toUpperCase()] &&
     ["true", "1"].includes(
       process.env[feature.replaceAll("-", "_").toUpperCase()],
     )
-  ) {
-    return true;
-  }
-  return false;
+  );
 }
 
 /**
@@ -618,16 +616,10 @@ export function isSpdxLicenseExpression(license) {
   if (!license) {
     return false;
   }
-
   if (/[(\s]+/g.test(license)) {
     return true;
   }
-
-  if (license.endsWith("+")) {
-    return true; // GPL-2.0+ means GPL-2.0 or any later version, at the licensee’s option.
-  }
-
-  return false;
+  return !!license.endsWith("+");
 }
 
 /**
@@ -1064,8 +1056,8 @@ export async function parsePkgLock(pkgLockFile, options = {}) {
     const scope = node.dev === true ? "optional" : undefined;
     const integrity = node.integrity ? node.integrity : undefined;
 
-    let pkg = {};
-    let purlString = "";
+    let pkg;
+    let purlString;
     const author = node.package.author;
     const authorString =
       author instanceof Object
@@ -2515,9 +2507,14 @@ export async function parseMinJs(minJsFile) {
  * Parse pom file
  *
  * @param {string} pomFile pom file to parse
+ * @returns {Object} Object containing pom properties, modules, and array of dependencies
  */
 export function parsePom(pomFile) {
   const deps = [];
+  let modules;
+  let pomPurl;
+  const properties = {};
+  let isQuarkus = false;
   const xmlData = readFileSync(pomFile, "utf-8");
   const project = xml2js(xmlData, {
     compact: true,
@@ -2526,6 +2523,69 @@ export function parsePom(pomFile) {
     attributesKey: "$",
     commentKey: "value",
   }).project;
+  for (const aprop of [
+    "groupId",
+    "artifactId",
+    "version",
+    "name",
+    "description",
+    "url",
+    "packaging",
+  ]) {
+    if (project?.[aprop]?._) {
+      properties[aprop] = project[aprop]._;
+    }
+  }
+  // Take the version from the parent if available
+  if (!properties.version && project.parent) {
+    properties.version = project.parent.version._;
+  }
+  // Take the groupId from the parent if available
+  if (!properties.groupId && project.parent) {
+    properties.groupId = project.parent.groupId._;
+  }
+  if (project?.scm?.url?._) {
+    properties.scm = project.scm.url._;
+  }
+  if (properties.groupId || properties.artifactId) {
+    pomPurl = new PackageURL(
+      "maven",
+      properties.groupId || "",
+      properties.artifactId,
+      properties.version,
+      { type: properties.packaging || "jar" },
+      null,
+    ).toString();
+  }
+  if (project?.modules?.module) {
+    modules = project.modules.module.map((m) => m?._);
+  }
+  if (project?.properties) {
+    for (const aprop of Object.keys(project.properties)) {
+      properties[aprop] = project.properties[aprop]?._;
+      if (!isQuarkus && aprop.startsWith("quarkus.platform")) {
+        isQuarkus = true;
+      }
+    }
+  }
+  // Check the plugins for quarkus
+  if (!isQuarkus && project?.build?.plugins?.plugin) {
+    if (Array.isArray(project.build.plugins.plugin)) {
+      for (const aplugin of project.build.plugins.plugin) {
+        if (aplugin?.groupId?._?.includes("quarkus.platform")) {
+          isQuarkus = true;
+          break;
+        }
+      }
+    } else if (
+      Object.keys(project.build.plugins.plugin).length &&
+      project.build.plugins.plugin?.groupId?._
+    ) {
+      if (project.build.plugins.plugin.groupId._.includes("quarkus.platform")) {
+        isQuarkus = true;
+      }
+    }
+  }
   if (project?.dependencies) {
     let dependencies = project.dependencies.dependency;
     // Convert to an array
@@ -2537,38 +2597,42 @@ export function parsePom(pomFile) {
     for (const adep of dependencies) {
       const version = adep.version;
       let versionStr = undefined;
-      if (version?._ && version._.indexOf("$") === -1) {
+      if (version?._) {
         versionStr = version._;
-        if (includeMavenTestScope || !adep.scope || adep.scope !== "test")
-          deps.push({
-            group: adep.groupId ? adep.groupId._ : "",
-            name: adep.artifactId ? adep.artifactId._ : "",
-            version: versionStr,
-            qualifiers: { type: "jar" },
-            properties: [
-              {
-                name: "SrcFile",
-                value: pomFile,
-              },
-            ],
-            evidence: {
-              identity: {
-                field: "purl",
-                confidence: 1,
-                methods: [
-                  {
-                    technique: "manifest-analysis",
-                    confidence: 1,
-                    value: pomFile,
-                  },
-                ],
-              },
+      }
+      if (versionStr?.includes("$")) {
+        versionStr = properties[versionStr?.replace(/[${}]/g, "")];
+      }
+      if (includeMavenTestScope || !adep.scope || adep.scope !== "test") {
+        deps.push({
+          group: adep.groupId ? adep.groupId._ : "",
+          name: adep.artifactId ? adep.artifactId._ : "",
+          version: versionStr,
+          qualifiers: { type: "jar" },
+          properties: [
+            {
+              name: "SrcFile",
+              value: pomFile,
             },
-          });
+          ],
+          evidence: {
+            identity: {
+              field: "purl",
+              confidence: 1,
+              methods: [
+                {
+                  technique: "manifest-analysis",
+                  confidence: !versionStr ? 0 : 0.6,
+                  value: pomFile,
+                },
+              ],
+            },
+          },
+        });
       }
     }
   }
-  return deps;
+  return { isQuarkus, pomPurl, modules, properties, dependencies: deps };
 }
 
 /**
@@ -3553,10 +3617,7 @@ export async function getMvnMetadata(
  */
 export function composePomXmlUrl({ urlPrefix, group, name, version }) {
   const groupPart = group.replace(/\./g, "/");
-  const fullUrl = `${
-    urlPrefix + groupPart
-  }/${name}/${version}/${name}-${version}.pom`;
-  return fullUrl;
+  return `${urlPrefix + groupPart}/${name}/${version}/${name}-${version}.pom`;
 }
 
 /**
@@ -3593,8 +3654,7 @@ export async function fetchPomXmlAsJson({ urlPrefix, group, name, version }) {
       return undefined;
     }
     const parentJson = xml2js(parentXml, options).project;
-    const result = { ...parentJson, ...pomJson };
-    return result;
+    return { ...parentJson, ...pomJson };
   }
   return pomJson;
 }
@@ -4418,7 +4478,7 @@ export async function parseReqFile(reqData, fetchDepsInfo) {
 export async function getPyModules(src, epkgList, options) {
   const allImports = {};
   const dependenciesList = [];
-  let modList = [];
+  let modList;
   const slicesFile = resolve(
     options.depsSlicesFile || options.usagesSlicesFile,
   );
@@ -4540,10 +4600,10 @@ export function parsePixiLockFile(pixiLockFileName, path) {
   const pixiLockData = _load(pixiFileData);
 
   // this function returns
-  let pkgList = [];
+  let pkgList;
   const formulationList = [];
   const rootList = [];
-  let dependenciesList = [];
+  let dependenciesList;
   // we do not set false because we have assumed that pixi lock is accurate
   const frozen = true;
 
@@ -4791,8 +4851,7 @@ export function getGithubUrlParts(repoUrl) {
     repoUrl = repoUrl.slice(0, -4);
   }
   repoUrl.replace(/\/$/, "");
-  const parts = repoUrl.split("/");
-  return parts;
+  return repoUrl.split("/");
 }
 
 /**
@@ -4940,7 +4999,6 @@ export async function getGoPkgLicense(repoMetadata) {
 }
 
 export async function getGoPkgComponent(group, name, version, hash) {
-  let pkg = {};
   let license = undefined;
   if (shouldFetchLicense()) {
     if (DEBUG_MODE) {
@@ -4957,7 +5015,7 @@ export async function getGoPkgComponent(group, name, version, hash) {
   const purlString = new PackageURL("golang", group, name, version)
     .toString()
     .replace(/%2F/g, "/");
-  pkg = {
+  return {
     group: group,
     name: name,
     version: version,
@@ -4966,7 +5024,6 @@ export async function getGoPkgComponent(group, name, version, hash) {
     purl: purlString,
     "bom-ref": decodeURIComponent(purlString),
   };
-  return pkg;
 }
 
 /**
@@ -7698,7 +7755,7 @@ export function parseNuspecData(nupkgFile, nuspecData) {
     }
     dependenciesMap[pkg["bom-ref"]] = dependsOn;
   } else if (m?.dependencies?.group) {
-    let dependencyGroups = [];
+    let dependencyGroups;
     if (Array.isArray(m.dependencies.group)) {
       dependencyGroups = m.dependencies.group;
     } else {
@@ -8604,16 +8661,15 @@ export function parseComposerJson(composerJsonFile) {
         expression: composerData.license,
       });
     }
-    moduleParent["bom-ref"] = decodeURIComponent(
-      new PackageURL(
-        "composer",
-        moduleParent.group,
-        moduleParent.name,
-        moduleParent.version,
-        null,
-        null,
-      ).toString(),
-    );
+    moduleParent.purl = new PackageURL(
+      "composer",
+      moduleParent.group,
+      moduleParent.name,
+      moduleParent.version,
+      null,
+      null,
+    ).toString();
+    moduleParent["bom-ref"] = decodeURIComponent(moduleParent.purl);
   }
   return { rootRequires, moduleParent };
 }
@@ -9485,8 +9541,7 @@ export async function collectGradleDependencies(
   for (const apom of pomFiles) {
     pomPathMap[basename(apom)] = apom;
   }
-  const jarNSMapping = await collectJarNS(GRADLE_CACHE_DIR, pomPathMap);
-  return jarNSMapping;
+  return await collectJarNS(GRADLE_CACHE_DIR, pomPathMap);
 }
 
 /**
@@ -9516,10 +9571,9 @@ export async function collectJarNS(jarPath, pomPathMap = {}) {
   const jarFiles = getAllFiles(jarPath, "**/*.jar");
   if (jarFiles?.length) {
     for (const jf of jarFiles) {
-      const jarname = jf;
       let pomname =
         pomPathMap[basename(jf).replace(".jar", ".pom")] ||
-        jarname.replace(".jar", ".pom");
+        jf.replace(".jar", ".pom");
       let pomData = undefined;
       let purl = undefined;
       // In some cases, the pom name might be slightly different to the jar name
@@ -9536,6 +9590,7 @@ export async function collectJarNS(jarPath, pomPathMap = {}) {
         }
       }
       if (existsSync(pomname)) {
+        // TODO: Replace with parsePom which contains pomPurl
         pomData = parsePomXml(readFileSync(pomname, { encoding: "utf-8" }));
         if (pomData) {
           const purlObj = new PackageURL(
@@ -9715,6 +9770,13 @@ export function convertJarNSToPackages(jarNSMapping) {
   return pkgList;
 }
 
+/**
+ * Deprecated function to parse pom.xml. Use parsePom instead.
+ *
+ * @deprecated
+ * @param pomXmlData XML contents
+ * @returns {Object} Parent component data
+ */
 export function parsePomXml(pomXmlData) {
   if (!pomXmlData) {
     return undefined;
@@ -10253,7 +10315,7 @@ export async function readZipEntry(
         break;
       }
     }
-    zip.close();
+    await zip.close();
   } catch (e) {
     console.log(e);
   }
@@ -10298,7 +10360,7 @@ export async function getJarClasses(jarFile) {
         );
       }
     }
-    zip.close();
+    await zip.close();
   } catch (e) {
     // node-stream-zip seems to fail on deno with a RangeError.
     // So we fallback to using jar -tf command
@@ -11726,7 +11788,7 @@ export function parseCmakeLikeFile(cmakeListFile, pkgType, options = {}) {
         const tmpB = (tmpA[1] || "")
           .trim()
           .replace(/["']/g, "")
-          .replace(/[ ]/g, ",")
+          .replace(/ /g, ",")
           .split(")")[0]
           .split(",")
           .filter((v) => v.length > 1);
@@ -11797,7 +11859,7 @@ export function parseCmakeLikeFile(cmakeListFile, pkgType, options = {}) {
         // find_package(Boost 1.79 COMPONENTS date_time)
         // find_library(PTHREADPOOL_LIB pthreadpool REQUIRED)
         if (tmpB) {
-          let working_name = undefined;
+          let working_name;
           if (l.startsWith("find_library")) {
             name_list.push(tmpB[1]);
             working_name = tmpB[1];
@@ -11985,7 +12047,7 @@ export function getCppModules(src, options, osPkgsList, epkgList) {
   const pkgType = "generic";
   const pkgList = [];
   const pkgAddedMap = {};
-  let sliceData = {};
+  let sliceData;
   const epkgMap = {};
   let parentComponent = undefined;
   const dependsOn = new Set();
@@ -12730,10 +12792,7 @@ export function isValidIriReference(iri) {
       iriIsValid = false;
     }
   }
-  if (iriIsValid) {
-    return true;
-  }
-  return false;
+  return iriIsValid;
 }
 
 /**

package/lib/helpers/utils.test.js

@@ -2640,14 +2640,25 @@ test("get nget metadata", async () => {
 }, 240000);
 
 test("parsePomFile", () => {
-  const data = parsePom("./test/pom.xml");
-  expect(data.length).toEqual(13);
+  let data = parsePom("./test/data/pom-quarkus.xml");
+  expect(data.dependencies.length).toEqual(46);
+  expect(data.modules).toBeUndefined();
+  expect(data.properties).toBeDefined();
+  expect(data.isQuarkus).toBeTruthy();
+  data = parsePom("./test/data/pom-quarkus-modules.xml");
+  expect(data.dependencies.length).toEqual(0);
+  expect(data.modules.length).toEqual(105);
+  expect(data.properties).toBeDefined();
+  expect(data.isQuarkus).toBeFalsy();
+  data = parsePom("./test/pom.xml");
+  expect(data.dependencies.length).toEqual(13);
+  expect(data.isQuarkus).toBeFalsy();
 });
 
 test("parsePomMetadata", async () => {
   const deps = parsePom("./test/pom.xml");
-  const data = await getMvnMetadata(deps);
-  expect(data.length).toEqual(deps.length);
+  const data = await getMvnMetadata(deps.dependencies);
+  expect(data.length).toEqual(deps.dependencies.length);
 });
 
 // These tests are disabled because they are returning undefined
@@ -2689,7 +2700,6 @@ test("get repo license", async () => {
     url: "https://github.com/ugorji/go/blob/master/LICENSE"
   });
 });
-*/
 
 test("get go pkg license", async () => {
   let license = await getGoPkgLicense({
@@ -2725,6 +2735,7 @@ test("get go pkg license", async () => {
     },
   ]);
 });
+*/
 
 test("get licenses", () => {
   let licenses = getLicenses({ license: "MIT" });

package/lib/managers/binary.js

@@ -253,6 +253,7 @@ const OS_DISTRO_ALIAS = {
   "ubuntu-23.04": "lunar",
   "ubuntu-23.10": "mantic",
   "ubuntu-24.04": "noble",
+  "ubuntu-24.10": "oracular",
   "debian-14": "forky",
   "debian-14.5": "forky",
   "debian-13": "trixie",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyclonedx/cdxgen",
-  "version": "11.0.4",
+  "version": "11.0.6",
   "description": "Creates CycloneDX Software Bill of Materials (SBOM) from source or container image",
   "homepage": "http://github.com/cyclonedx/cdxgen",
   "author": "Prabhu Subramanian <prabhu@appthreat.com>",

package/types/lib/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/cli/index.js"],"names":[],"mappings":"AA4wBA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AAyVD;;;;;;;GAOG;AACH,mCALW,MAAM,qBAiEhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM;;;;EAKhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM;;;;EAkBhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAs5BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA2ehB;AAED;;;;;;;;;;GAUG;AACH,+DAsEC;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA6bhB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BA+YhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAqIhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAiDhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBA+KhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBAsHhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,qBAuBhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,8BAqDhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,8BA4ChB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BA6FhB;AAED;;;;;GAKG;AACH,iDAHW,MAAM,qBAiUhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAqJhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAmFhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA4XhB;AAED;;;;;GAKG;AACH,2CAHW,MAAM;;;;;;;;;;;;;;;;;;;;GAoChB;AAED;;;;;;;;KA+DC;AAED;;;;;;GAMG;AACH,yDAuCC;AAED;;;;;;;;;GASG;AACH,2GA6BC;AAED;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,8BAmclB;AAED;;;;;GAKG;AACH,iCAHW,MAAM,8BAgUhB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,qBAqOhB;AAED;;;;;;GAMG;AACH,wDAFY,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,SAAS,CAAC,CAwHxE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/cli/index.js"],"names":[],"mappings":"AA4wBA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AA8WD;;;;;;;GAOG;AACH,mCALW,MAAM,qBAiEhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM;;;;EAKhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM;;;;EAkBhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAs7BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAwfhB;AAED;;;;;;;;;;GAUG;AACH,+DAsEC;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA6bhB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BA+YhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAqIhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAiDhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBA+KhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBAsHhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,qBAuBhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,8BAqDhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,8BA4ChB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BA6FhB;AAED;;;;;GAKG;AACH,iDAHW,MAAM,qBAiUhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAiJhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAmFhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA4XhB;AAED;;;;;GAKG;AACH,2CAHW,MAAM;;;;;;;;;;;;;;;;;;;;GAoChB;AAED;;;;;;;;KA+DC;AAED;;;;;;GAMG;AACH,yDA4EC;AAED;;;;;;;;;GASG;AACH,2GA6BC;AAED;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,8BAqdlB;AAED;;;;;GAKG;AACH,iCAHW,MAAM,8BAgUhB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,qBAqOhB;AAED;;;;;;GAMG;AACH,wDAFY,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,SAAS,CAAC,CAwHxE"}

package/types/lib/helpers/display.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../../../lib/helpers/display.js"],"names":[],"mappings":"AAoBA,mFAuEC;AAQD,iDAmBC;AACD,kDAsBC;AAED,qDAqBC;AAeD,qDA4BC;AACD,mDA8CC;AACD,wFA0CC;AA4DD,2DA+BC;AAED,iEA0BC;AAED,uDAoBC;AAED,iDA8CC"}
+{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../../../lib/helpers/display.js"],"names":[],"mappings":"AAoBA,mFAuEC;AAQD,iDAmBC;AACD,kDAsBC;AAED,qDAqBC;AAeD,qDAqCC;AAED,mDA8CC;AACD,wFA0CC;AA4DD,2DA+BC;AAED,iEA0BC;AAED,uDAoBC;AAED,iDA8CC"}

package/types/lib/helpers/utils.d.ts

@@ -186,30 +186,9 @@ export function parseMinJs(minJsFile: string): Promise<any[]>;
  * Parse pom file
  *
  * @param {string} pomFile pom file to parse
+ * @returns {Object} Object containing pom properties, modules, and array of dependencies
  */
-export function parsePom(pomFile: string): {
-    group: any;
-    name: any;
-    version: any;
-    qualifiers: {
-        type: string;
-    };
-    properties: {
-        name: string;
-        value: string;
-    }[];
-    evidence: {
-        identity: {
-            field: string;
-            confidence: number;
-            methods: {
-                technique: string;
-                confidence: number;
-                value: string;
-            }[];
-        };
-    };
-}[];
+export function parsePom(pomFile: string): any;
 /**
  * Parse maven tree output
  * @param {string} rawOutput Raw string output
@@ -527,7 +506,15 @@ export function getRepoLicense(repoUrl: string, repoMetadata: any): Promise<stri
  * @param {Object} repoMetadata Repo metadata
  */
 export function getGoPkgLicense(repoMetadata: any): Promise<any>;
-export function getGoPkgComponent(group: any, name: any, version: any, hash: any): Promise<{}>;
+export function getGoPkgComponent(group: any, name: any, version: any, hash: any): Promise<{
+    group: any;
+    name: any;
+    version: any;
+    _integrity: any;
+    license: any;
+    purl: string;
+    "bom-ref": string;
+}>;
 /**
  * Method to parse go.mod files
  *
@@ -546,7 +533,15 @@ export function parseGoModData(goModData: string, gosumMap: any): any;
  */
 export function parseGoListDep(rawOutput: string, gosumMap: any): Promise<{
     parentComponent: {};
-    pkgList: {}[];
+    pkgList: {
+        group: any;
+        name: any;
+        version: any;
+        _integrity: any;
+        license: any;
+        purl: string;
+        "bom-ref": string;
+    }[];
 }>;
 /**
  * Parse go mod graph
@@ -965,14 +960,14 @@ export function convertJarNSToPackages(jarNSMapping: any): {
         value: any;
     }[];
 }[];
-export function parsePomXml(pomXmlData: any): {
-    artifactId: any;
-    groupId: any;
-    version: any;
-    description: any;
-    url: any;
-    scm: any;
-};
+/**
+ * Deprecated function to parse pom.xml. Use parsePom instead.
+ *
+ * @deprecated
+ * @param pomXmlData XML contents
+ * @returns {Object} Parent component data
+ */
+export function parsePomXml(pomXmlData: any): any;
 export function parseJarManifest(jarMetadata: any): {};
 export function parsePomProperties(pomProperties: any): {};
 export function encodeForPurl(s: any): any;

package/types/lib/helpers/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/helpers/utils.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/helpers/utils.js"],"names":[],"mappings":"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"}

package/types/lib/managers/binary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../lib/managers/binary.js"],"names":[],"mappings":"AAgSA,iDA6BC;AAED,wDAkBC;AAED;;;;;GAKG;AACH,kDAFa,SAAS,MAAO,CAqB5B;AAED;;;;;;;EAqXC;AAkCD,gDAoDC;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,cACN,MAAM,WA2BhB;AAED;;;;;;;;GAQG;AACH,kCANW,MAAM,iBACN,MAAM,YACN,OAAO,GAEN,OAAO,CA8BlB"}
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../lib/managers/binary.js"],"names":[],"mappings":"AAiSA,iDA6BC;AAED,wDAkBC;AAED;;;;;GAKG;AACH,kDAFa,SAAS,MAAO,CAqB5B;AAED;;;;;;;EAqXC;AAkCD,gDAoDC;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,cACN,MAAM,WA2BhB;AAED;;;;;;;;GAQG;AACH,kCANW,MAAM,iBACN,MAAM,YACN,OAAO,GAEN,OAAO,CA8BlB"}