@cyclonedx/cdxgen 12.1.1 → 12.1.3

package/lib/helpers/utils.js

@@ -48,6 +48,7 @@ import {
   satisfies,
   valid,
 } from "semver";
+import { v4 as uuidv4 } from "uuid";
 import { xml2js } from "xml-js";
 import { parse as _load } from "yaml";
 
@@ -160,6 +161,20 @@ export function safeSpawnSync(command, args, options) {
   if (!options.timeout) {
     options.timeout = TIMEOUT_MS;
   }
+  // Check for -S for python invocations in secure mode
+  if (command.includes("python") && (!args?.length || args[0] !== "-S")) {
+    if (isSecureMode) {
+      console.warn(
+        "\x1b[1;35mNotice: Running python command without '-S' argument. This is a bug in cdxgen. Please report with an example repo here https://github.com/cdxgen/cdxgen/issues.\x1b[0m",
+      );
+    } else if (process.env?.CDXGEN_IN_CONTAINER === "true") {
+      console.log("Running python command without '-S' argument.");
+    } else {
+      console.warn(
+        "\x1b[1;35mNotice: Running python command without '-S' argument. Only run cdxgen in trusted directories to prevent auto-executing local scripts.\x1b[0m",
+      );
+    }
+  }
   traceLog("spawn", { command, args, ...options });
   commandsExecuted.add(command);
   // Fix for DEP0190 warning
@@ -1033,18 +1048,10 @@ export function getKnownLicense(licenseUrl, pkg) {
             return { id: akLic.license, name: akLic.licenseName };
           }
         }
-        if (
-          akLic.urlIncludes &&
-          licenseUrl &&
-          licenseUrl.includes(akLic.urlIncludes)
-        ) {
+        if (akLic.urlIncludes && licenseUrl?.includes(akLic.urlIncludes)) {
           return { id: akLic.license, name: akLic.licenseName };
         }
-        if (
-          akLic.urlEndswith &&
-          licenseUrl &&
-          licenseUrl.endsWith(akLic.urlEndswith)
-        ) {
+        if (akLic.urlEndswith && licenseUrl?.endsWith(akLic.urlEndswith)) {
           return { id: akLic.license, name: akLic.licenseName };
         }
       }
@@ -1265,7 +1272,7 @@ export async function parsePkgJson(pkgJsonFile, simple = false) {
       // continue regardless of error
     }
   }
-  if (!simple && shouldFetchLicense() && pkgList && pkgList.length) {
+  if (!simple && shouldFetchLicense() && pkgList?.length) {
     if (DEBUG_MODE) {
       console.log(
         `About to fetch license information for ${pkgList.length} packages in parsePkgJson`,
@@ -1786,7 +1793,7 @@ export async function parsePkgLock(pkgLockFile, options = {}) {
     options,
   ));
 
-  if (shouldFetchLicense() && pkgList && pkgList.length) {
+  if (shouldFetchLicense() && pkgList?.length) {
     if (DEBUG_MODE) {
       console.log(
         `About to fetch license information for ${pkgList.length} packages in parsePkgLock`,
@@ -2419,7 +2426,7 @@ export async function parseYarnLock(
     }
   }
 
-  if (shouldFetchLicense() && pkgList && pkgList.length) {
+  if (shouldFetchLicense() && pkgList?.length) {
     if (DEBUG_MODE) {
       console.log(
         `About to fetch license information for ${pkgList.length} packages in parseYarnLock`,
@@ -2496,7 +2503,7 @@ export async function parseNodeShrinkwrap(swFile) {
       }
     }
   }
-  if (shouldFetchLicense() && pkgList && pkgList.length) {
+  if (shouldFetchLicense() && pkgList?.length) {
     if (DEBUG_MODE) {
       console.log(
         `About to fetch license information for ${pkgList.length} packages in parseNodeShrinkwrap`,
@@ -3698,7 +3705,7 @@ export async function parsePnpmLock(
     pkgList = await pnpmMetadata(pkgList, pnpmLock);
   }
 
-  if (shouldFetchLicense() && pkgList && pkgList.length) {
+  if (shouldFetchLicense() && pkgList?.length) {
     if (DEBUG_MODE) {
       console.log(
         `About to fetch license information for ${pkgList.length} packages in parsePnpmLock`,
@@ -3759,7 +3766,7 @@ export async function parseBowerJson(bowerJsonFile) {
       // continue regardless of error
     }
   }
-  if (shouldFetchLicense() && pkgList && pkgList.length) {
+  if (shouldFetchLicense() && pkgList?.length) {
     if (DEBUG_MODE) {
       console.log(
         `About to fetch license information for ${pkgList.length} packages in parseBowerJson`,
@@ -3857,7 +3864,7 @@ export async function parseMinJs(minJsFile) {
       // continue regardless of error
     }
   }
-  if (shouldFetchLicense() && pkgList && pkgList.length) {
+  if (shouldFetchLicense() && pkgList?.length) {
     if (DEBUG_MODE) {
       console.log(
         `About to fetch license information for ${pkgList.length} packages in parseMinJs`,
@@ -6132,6 +6139,9 @@ export async function parsePyLockData(lockData, lockFile, pyProjectFile) {
     ).toString();
     pkg.purl = purlString;
     pkg["bom-ref"] = decodeURIComponent(purlString);
+    if (parentComponent && pkg["bom-ref"] === parentComponent["bom-ref"]) {
+      continue;
+    }
     pkg.evidence = {
       identity: {
         field: "purl",
@@ -6387,6 +6397,9 @@ export async function parseReqFile(reqFile, fetchDepsInfo = false) {
   return await parseReqData(reqFile, null, fetchDepsInfo);
 }
 
+const LICENSE_ID_COMMENTS_PATTERN =
+  /^(Apache-2\.0|MIT|ISC|GPL-|LGPL-|BSD-[23]-Clause)/i;
+
 /**
  * Method to parse requirements.txt file. Must only be used internally.
  *
@@ -6434,6 +6447,12 @@ async function parseReqData(reqFile, reqData = null, fetchDepsInfo = false) {
     if (!l || l.startsWith("#") || l.startsWith("-")) {
       continue;
     }
+    let comment = null;
+    const commentMatch = l.match(/\s+#(.*)$/);
+    if (commentMatch) {
+      comment = commentMatch[1].trim();
+      l = l.substring(0, commentMatch.index).trim();
+    }
     const properties = reqFile
       ? [
           {
@@ -6482,6 +6501,21 @@ async function parseReqData(reqFile, reqData = null, fetchDepsInfo = false) {
         scope: compScope,
         evidence,
       };
+      if (comment) {
+        apkg.licenses = comment
+          .split("/")
+          .map((c) => {
+            const licenseObj = {};
+            const cId = c.trim();
+            if (cId.match(LICENSE_ID_COMMENTS_PATTERN)) {
+              licenseObj.id = cId;
+            } else {
+              return undefined;
+            }
+            return { license: licenseObj };
+          })
+          .filter((l) => l !== undefined);
+      }
       if (extras && extras.length > 0) {
         properties.push({
           name: "cdx:pypi:extras",
@@ -6533,6 +6567,21 @@ async function parseReqData(reqFile, reqData = null, fetchDepsInfo = false) {
         scope: compScope,
         evidence,
       };
+      if (comment) {
+        apkg.licenses = comment
+          .split("/")
+          .map((c) => {
+            const licenseObj = {};
+            const cId = c.trim();
+            if (cId.match(LICENSE_ID_COMMENTS_PATTERN)) {
+              licenseObj.id = cId;
+            } else {
+              return undefined;
+            }
+            return { license: licenseObj };
+          })
+          .filter((l) => l !== undefined);
+      }
       if (versionSpecifiers && !versionSpecifiers.startsWith("==")) {
         properties.push({
           name: "cdx:pypi:versionSpecifiers",
@@ -7257,18 +7306,20 @@ export async function parseGoModData(goModData, gosumMap) {
       isTool = false;
       continue;
     }
-    if (l.includes("tool ")) {
+    if (l.includes("tool ") || isTool) {
       continue;
     }
-    if (isTool) {
+    if (l.startsWith("toolchain ")) {
+      const toolchainVer = l.split(" ").pop().trim();
+      parentComponent.properties = [
+        { name: "cdx:go:toolchain", value: toolchainVer },
+      ];
       continue;
     }
-
     // Skip go.mod file headers, whitespace, and/or comments
     if (
       l.startsWith("go ") ||
       //TODO: should toolchain be considered as a dependency
-      l.startsWith("toolchain ") ||
       l.includes(")") ||
       l.trim() === "" ||
       l.trim().startsWith("//")
@@ -7378,14 +7429,17 @@ export async function parseGoListDep(rawOutput, gosumMap) {
       .split("\n")
       .filter((p) => p.trim().replace(/["']/g, "").length);
     for (const l of pkgs) {
-      const verArr = l.trim().replace(/["']/g, "").split(" ");
+      const verArr = l.trim().replace(/["']/g, "").split("|");
       if (verArr && verArr.length >= 5) {
         const key = `${verArr[0]}-${verArr[1]}`;
         // Filter duplicates
         if (!keys_cache[key]) {
           keys_cache[key] = key;
           const version = verArr[1];
-          const gosumHash = gosumMap[`${verArr[0]}@${version}`];
+          let gosumHash = gosumMap[`${verArr[0]}@${version}`];
+          if (!gosumHash && verArr.length >= 8 && verArr[8]?.length) {
+            gosumHash = `sha256-${verArr[8].replace("h1:", "")}`;
+          }
           const component = await getGoPkgComponent(
             "",
             verArr[0],
@@ -7412,6 +7466,43 @@ export async function parseGoListDep(rawOutput, gosumMap) {
               value: verArr[2],
             },
           ];
+          if (
+            verArr.length >= 6 &&
+            verArr[6]?.length &&
+            verArr[6] !== "<nil>"
+          ) {
+            component.properties.push({
+              name: "cdx:go:creation_time",
+              value: verArr[6],
+            });
+          }
+          if (verArr.length >= 7 && verArr[7]?.length) {
+            component.properties.push({
+              name: "cdx:go:deprecated",
+              value: verArr[7],
+            });
+          }
+          if (verArr.length >= 9 && verArr[9]?.length) {
+            component.properties.push({
+              name: "cdx:go:local_dir",
+              value: verArr[9],
+            });
+            if (safeExistsSync(join(verArr[9], "LICENSE"))) {
+              const licenseText = readFileSync(join(verArr[9], "LICENSE"), {
+                encoding: "utf-8",
+              });
+              if (licenseText?.length) {
+                component.licenses = [
+                  {
+                    license: {
+                      name: "CUSTOM",
+                      text: { contentType: "text/plain", content: licenseText },
+                    },
+                  },
+                ];
+              }
+            }
+          }
           if (verArr.length > 5 && verArr[5] === "true") {
             parentComponent = component;
           } else {
@@ -9835,82 +9926,250 @@ export function parseGitHubWorkflowData(f) {
     return pkgList;
   }
   const lines = ghwData.split("\n");
+  // workflow-related values
+  const workflowName = yamlObj.name || path.basename(f, path.extname(f));
+  const workflowTriggers = yamlObj.on || yamlObj.true;
+  const workflowPermissions = yamlObj.permissions || {};
+  let hasWritePermissions = analyzePermissions(workflowPermissions);
+  // GitHub of course supports strings such as "write-all" to make it easy to create supply-chain attacks.
+  if (
+    (typeof workflowPermissions === "string" ||
+      workflowPermissions instanceof String) &&
+    workflowPermissions.includes("write")
+  ) {
+    hasWritePermissions = true;
+  }
+  const workflowConcurrency = yamlObj.concurrency || {};
+  const _workflowEnv = yamlObj.env || {};
+  const hasIdTokenWrite = workflowPermissions?.["id-token"] === "write";
   for (const jobName of Object.keys(yamlObj.jobs)) {
-    if (yamlObj.jobs[jobName].steps) {
-      for (const step of yamlObj.jobs[jobName].steps) {
-        if (step.uses) {
-          const tmpA = step.uses.split("@");
-          if (tmpA.length !== 2) {
-            continue;
+    const job = yamlObj.jobs[jobName];
+    if (!job.steps) {
+      continue;
+    }
+    // job-related values
+    const jobRunner = job["runs-on"] || "unknown";
+    const jobEnvironment = job.environment?.name || job.environment || "";
+    const jobTimeout = job["timeout-minutes"] || null;
+    const jobPermissions = job.permissions || {};
+    const jobServices = job.services ? Object.keys(job.services) : [];
+    let jobNeeds = job.needs || [];
+    if (!Array.isArray(jobNeeds)) {
+      jobNeeds = [jobNeeds];
+    }
+    const _jobIf = job.if || "";
+    const _jobStrategy = job.strategy ? JSON.stringify(job.strategy) : "";
+    const jobHasWritePermissions = analyzePermissions(jobPermissions);
+    for (const step of job.steps) {
+      if (step.uses) {
+        const tmpA = step.uses.split("@");
+        if (tmpA.length !== 2) {
+          continue;
+        }
+        const groupName = tmpA[0];
+        let name = groupName;
+        let group = "";
+        const tagOrCommit = tmpA[1];
+        let version = tagOrCommit;
+        const tmpB = groupName.split("/");
+        if (tmpB.length >= 2) {
+          name = tmpB.pop();
+          group = tmpB.join("/");
+        } else if (tmpB.length === 1) {
+          name = tmpB[0];
+          group = "";
+        }
+        const versionPinningType = getVersionPinningType(tagOrCommit);
+        const isShaPinned = versionPinningType === "sha";
+        const _isTagPinned = versionPinningType === "tag";
+        const _isBranchRef = versionPinningType === "branch";
+        let lineNum = -1;
+        const stepLineMatch = ghwData.indexOf(step.uses);
+        if (stepLineMatch >= 0) {
+          lineNum = ghwData.substring(0, stepLineMatch).split("\n").length - 1;
+        }
+        if (lineNum >= 0 && lines[lineNum]) {
+          const line = lines[lineNum];
+          const commentMatch = line.match(/#\s*v?([0-9]+(?:\.[0-9]+)*)/);
+          if (commentMatch?.[1]) {
+            version = commentMatch[1];
           }
-          const groupName = tmpA[0];
-          let name = groupName;
-          let group = "";
-          const tagOrCommit = tmpA[1];
-          let version = tagOrCommit;
-          const tmpB = groupName.split("/");
-          if (tmpB.length >= 2) {
-            name = tmpB.pop();
-            group = tmpB.join("/");
-          } else if (tmpB.length === 1) {
-            name = tmpB[0];
-            group = "";
+        }
+        const key = `${group}-${name}-${version}`;
+        let confidence = 0.6;
+        if (!keys_cache[key] && name && version) {
+          keys_cache[key] = key;
+          let fullName = name;
+          if (group.length) {
+            fullName = `${group}/${name}`;
           }
-          let lineNum = -1;
-          const stepLineMatch = ghwData.indexOf(step.uses);
-          if (stepLineMatch >= 0) {
-            lineNum =
-              ghwData.substring(0, stepLineMatch).split("\n").length - 1;
+          let purl = `pkg:github/${fullName}@${version}`;
+          if (tagOrCommit && version !== tagOrCommit) {
+            const qualifierDesc = tagOrCommit.startsWith("v")
+              ? "tag"
+              : "commit";
+            purl = `${purl}?${qualifierDesc}=${tagOrCommit}`;
+            confidence = 0.7;
           }
-          if (lineNum >= 0 && lines[lineNum]) {
-            const line = lines[lineNum];
-            const commentMatch = line.match(/#\s*v?([0-9]+(?:\.[0-9]+)*)/);
-            if (commentMatch?.[1]) {
-              version = commentMatch[1];
-            }
+          const properties = [
+            { name: "SrcFile", value: f },
+            { name: "cdx:github:workflow:name", value: workflowName },
+            { name: "cdx:github:job:name", value: jobName },
+            {
+              name: "cdx:github:job:runner",
+              value: Array.isArray(jobRunner) ? jobRunner.join(",") : jobRunner,
+            },
+            { name: "cdx:github:action:uses", value: step.uses },
+            {
+              name: "cdx:github:action:versionPinningType",
+              value: versionPinningType,
+            },
+            {
+              name: "cdx:github:action:isShaPinned",
+              value: isShaPinned.toString(),
+            },
+          ];
+          if (step.name) {
+            properties.push({ name: "cdx:github:step:name", value: step.name });
           }
-          const key = `${group}-${name}-${version}`;
-          let confidence = 0.6;
-          if (!keys_cache[key] && name && version) {
-            keys_cache[key] = key;
-            let fullName = name;
-            if (group.length) {
-              fullName = `${group}/${name}`;
-            }
-            let purl = `pkg:github/${fullName}@${version}`;
-            if (tagOrCommit && version !== tagOrCommit) {
-              const qualifierDesc = tagOrCommit.startsWith("v")
-                ? "tag"
-                : "commit";
-              purl = `${purl}?${qualifierDesc}=${tagOrCommit}`;
-              confidence = 0.7;
-            }
-            const properties = [
-              {
-                name: "SrcFile",
-                value: f,
+          if (step.if) {
+            properties.push({
+              name: "cdx:github:step:condition",
+              value: step.if,
+            });
+          }
+          if (step["continue-on-error"]) {
+            properties.push({
+              name: "cdx:github:step:continueOnError",
+              value: "true",
+            });
+          }
+          if (step.timeout) {
+            properties.push({
+              name: "cdx:github:step:timeout",
+              value: step.timeout.toString(),
+            });
+          }
+          if (jobEnvironment) {
+            properties.push({
+              name: "cdx:github:job:environment",
+              value: jobEnvironment,
+            });
+          }
+          if (jobTimeout) {
+            properties.push({
+              name: "cdx:github:job:timeoutMinutes",
+              value: jobTimeout.toString(),
+            });
+          }
+          if (jobHasWritePermissions) {
+            properties.push({
+              name: "cdx:github:job:hasWritePermissions",
+              value: "true",
+            });
+          }
+          if (jobServices.length > 0) {
+            properties.push({
+              name: "cdx:github:job:services",
+              value: jobServices.join(","),
+            });
+          }
+          if (jobNeeds.length > 0) {
+            properties.push({
+              name: "cdx:github:job:needs",
+              value: jobNeeds.join(","),
+            });
+          }
+          if (hasWritePermissions) {
+            properties.push({
+              name: "cdx:github:workflow:hasWritePermissions",
+              value: "true",
+            });
+          }
+          if (hasIdTokenWrite) {
+            properties.push({
+              name: "cdx:github:workflow:hasIdTokenWrite",
+              value: "true",
+            });
+          }
+          if (workflowConcurrency?.group) {
+            properties.push({
+              name: "cdx:github:workflow:concurrencyGroup",
+              value: workflowConcurrency.group,
+            });
+          }
+          if (group?.startsWith("github/") || group === "actions") {
+            properties.push({ name: "cdx:actions:isOfficial", value: "true" });
+          }
+          if (group?.startsWith("github/")) {
+            properties.push({ name: "cdx:actions:isVerified", value: "true" });
+          }
+          if (workflowTriggers) {
+            const triggers =
+              typeof workflowTriggers === "string"
+                ? workflowTriggers
+                : Object.keys(workflowTriggers).join(",");
+            properties.push({
+              name: "cdx:github:workflow:triggers",
+              value: triggers,
+            });
+          }
+          pkgList.push({
+            group,
+            name,
+            version,
+            purl,
+            properties,
+            evidence: {
+              identity: {
+                field: "purl",
+                confidence,
+                methods: [
+                  {
+                    technique: "source-code-analysis",
+                    confidence,
+                    value: f,
+                  },
+                ],
               },
-            ];
-            if (group?.startsWith("github/") || group === "actions") {
-              properties.push({
-                name: "cdx:actions:isOfficial",
-                value: "true",
-              });
-            }
+            },
+          });
+        }
+      }
+      if (step.run) {
+        const runLineNum = ghwData.indexOf(step.run);
+        const runLine =
+          runLineNum >= 0
+            ? ghwData.substring(0, runLineNum).split("\n").length
+            : -1;
+        const pkgCommands = extractPackageManagerCommands(step.run);
+        for (const pkgCmd of pkgCommands) {
+          const key = `run-${pkgCmd.name}-${pkgCmd.version || "latest"}`;
+          if (!keys_cache[key]) {
+            keys_cache[key] = key;
             pkgList.push({
-              group,
-              name,
-              version,
-              purl,
-              properties,
+              group: "",
+              name: pkgCmd.name,
+              version: pkgCmd.version || undefined,
+              scope: "excluded",
+              "bom-ref": uuidv4(),
+              description: key,
+              properties: [
+                { name: "SrcFile", value: f },
+                { name: "cdx:github:workflow:name", value: workflowName },
+                { name: "cdx:github:job:name", value: jobName },
+                { name: "cdx:github:step:type", value: "run" },
+                { name: "cdx:github:step:command", value: pkgCmd.command },
+                { name: "cdx:github:run:line", value: runLine.toString() },
+              ],
               evidence: {
                 identity: {
                   field: "purl",
-                  confidence,
+                  confidence: 0.5,
                   methods: [
                     {
                       technique: "source-code-analysis",
-                      confidence,
+                      confidence: 0.5,
                       value: f,
                     },
                   ],
@@ -9925,6 +10184,103 @@ export function parseGitHubWorkflowData(f) {
   return pkgList;
 }
 
+/**
+ * Analyze permissions for write access.
+ *
+ * Refer to https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#permissions
+ */
+function analyzePermissions(permissions) {
+  if (!permissions || typeof permissions !== "object") {
+    return false;
+  }
+  const writePermissions = [
+    "actions",
+    "artifact-metadata",
+    "attestations",
+    "checks",
+    "contents",
+    "deployments",
+    "id-token",
+    "models",
+    "discussions",
+    "packages",
+    "pages",
+    "actions",
+    "deployments",
+    "issues",
+    "pull-requests",
+    "security-events",
+    "statuses",
+  ];
+  for (const perm of writePermissions) {
+    if (permissions[perm] === "write") {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Determine version pinning type for security assessment
+ */
+function getVersionPinningType(versionRef) {
+  if (!versionRef) {
+    return "unknown";
+  }
+  if (/^[a-f0-9]{40}$/.test(versionRef)) {
+    return "sha";
+  }
+  if (/^[a-f0-9]{7,}$/.test(versionRef)) {
+    return "sha";
+  }
+  if (
+    versionRef === "main" ||
+    versionRef === "master" ||
+    versionRef.includes("/")
+  ) {
+    return "branch";
+  }
+  return "tag";
+}
+
+/**
+ * Extract package manager commands from run steps
+ */
+function extractPackageManagerCommands(runScript) {
+  const commands = [];
+  if (!runScript) {
+    return commands;
+  }
+  const patterns = [
+    { regex: /npm\s+(install|i|ci)\s+([^&\n|;]+)/g, name: "npm", type: "npm" },
+    {
+      regex: /yarn\s+(add|install)\s+([^&\n|;]+)/g,
+      name: "yarn",
+      type: "yarn",
+    },
+    { regex: /pip\s+(install)\s+([^&\n|;]+)/g, name: "pip", type: "pip" },
+    { regex: /pip3\s+(install)\s+([^&\n|;]+)/g, name: "pip3", type: "pip" },
+    { regex: /gem\s+(install)\s+([^&\n|;]+)/g, name: "gem", type: "gem" },
+    { regex: /go\s+(get|install)\s+([^&\n|;]+)/g, name: "go", type: "go" },
+    {
+      regex: /cargo\s+(install|add)\s+([^&\n|;]+)/g,
+      name: "cargo",
+      type: "cargo",
+    },
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.regex.exec(runScript)) !== null) {
+      commands.push({
+        name: pattern.name,
+        command: match[0],
+        version: null,
+      });
+    }
+  }
+  return commands;
+}
+
 export function parseCloudBuildData(cbwData) {
   const pkgList = [];
   const keys_cache = {};
@@ -10791,6 +11147,9 @@ export function parseCsPkgData(pkgData, pkgFile) {
 export function getPropertyGroupTextNodes(propsFiles) {
   const matches = {};
   for (const f of propsFiles) {
+    if (!f) {
+      continue;
+    }
     let projects;
     try {
       const data = readFileSync(f, { encoding: "utf-8" });
@@ -11581,9 +11940,7 @@ export function parseCsPkgLockData(csLockData, pkgLockFile) {
               assetData.dependencies[aversion][adep].resolved;
           } else if (
             aversion.includes("/") &&
-            assetData.dependencies[aversionNoRuntime] &&
-            assetData.dependencies[aversionNoRuntime][adep] &&
-            assetData.dependencies[aversionNoRuntime][adep].resolved
+            assetData.dependencies[aversionNoRuntime]?.[adep]?.resolved
           ) {
             adepResolvedVersion =
               assetData.dependencies[aversionNoRuntime][adep].resolved;
@@ -12653,7 +13010,7 @@ export async function collectMvnDependencies(
   }
 
   // Clean up
-  if (cleanup && tempDir && tempDir.startsWith(tmpdir()) && rmSync) {
+  if (cleanup && tempDir?.startsWith(tmpdir()) && rmSync) {
     rmSync(tempDir, { recursive: true, force: true });
   }
   return jarNSMapping;
@@ -15014,7 +15371,11 @@ export async function getPipFrozenTree(
     thoughtLog(
       "Let me create a new virtual environment for installing the packages with pip.",
     );
-    result = safeSpawnSync(PYTHON_CMD, ["-m", "venv", tempVenvDir], {
+    const venvCreationArgs = ["-m", "venv", tempVenvDir];
+    if (isSecureMode) {
+      venvCreationArgs.unshift("-S");
+    }
+    result = safeSpawnSync(PYTHON_CMD, venvCreationArgs, {
       shell: isWin,
     });
     if (result.status !== 0 || result.error) {
@@ -15065,12 +15426,18 @@ export async function getPipFrozenTree(
         "true",
         "--local",
       ];
+      if (isSecureMode) {
+        poetryConfigArgs.unshift("-S");
+      }
       result = safeSpawnSync(PYTHON_CMD, poetryConfigArgs, {
         cwd: basePath,
         shell: isWin,
       });
       thoughtLog("Performing poetry install");
       let poetryInstallArgs = ["-m", "poetry", "install", "-n", "--no-root"];
+      if (isSecureMode) {
+        poetryInstallArgs.unshift("-S");
+      }
       // Attempt to perform poetry install
       result = safeSpawnSync(PYTHON_CMD, poetryInstallArgs, {
         cwd: basePath,
@@ -15147,6 +15514,9 @@ export async function getPipFrozenTree(
         "install",
         "--disable-pip-version-check",
       ];
+      if (isSecureMode) {
+        pipInstallArgs.unshift("-S");
+      }
       // Requirements.txt could be called with any name so best to check for not setup.py and not pyproject.toml
       if (
         !reqOrSetupFile.endsWith("setup.py") &&
@@ -15467,7 +15837,11 @@ export function getPipTreeForPackages(
   };
   if (!process.env.VIRTUAL_ENV && !process.env.CONDA_PREFIX) {
     // Create a virtual environment
-    result = safeSpawnSync(PYTHON_CMD, ["-m", "venv", tempVenvDir], {
+    const venvCreationArgs = ["-m", "venv", tempVenvDir];
+    if (isSecureMode) {
+      venvCreationArgs.unshift("-S");
+    }
+    result = safeSpawnSync(PYTHON_CMD, venvCreationArgs, {
       shell: isWin,
     });
     if (result.status !== 0 || result.error) {
@@ -15490,6 +15864,9 @@ export function getPipTreeForPackages(
   }
   const python_cmd_for_tree = get_python_command_from_env(env);
   let pipInstallArgs = ["-m", "pip", "install", "--disable-pip-version-check"];
+  if (isSecureMode) {
+    pipInstallArgs.unshift("-S");
+  }
   // Support for passing additional arguments to pip
   // Eg: --python-version 3.10 --ignore-requires-python --no-warn-conflicts
   if (process?.env?.PIP_INSTALL_ARGS) {
@@ -16059,29 +16436,24 @@ export function parseCmakeLikeFile(cmakeListFile, pkgType, options = {}) {
         }
       }
     } else if (l.includes("dependency(")) {
-      let tmpA = l.split("dependency(");
-      if (tmpA?.length) {
-        if (!l.includes("_dependency") && !l.includes(".dependency")) {
-          tmpA = tmpA[tmpA.length - 1]
-            .split(", ")
-            .map((v) => v.replace(/['" )]/g, ""));
-          if (tmpA.length) {
-            name_list.push(tmpA[0]);
-            if (tmpA.length > 2 && tmpA[1].startsWith("version")) {
-              const tmpB = tmpA[1].split("version:");
-              if (tmpB && tmpB.length === 2) {
-                if (tmpB[1].includes(">") || tmpB[1].includes("<")) {
-                  // We have a version specifier
-                  versionSpecifiersMap[tmpA[0]] = tmpB[1];
-                } else if (
-                  /^\d+/.test(tmpB[1]) &&
-                  !tmpB[1].includes("${") &&
-                  !tmpB[1].startsWith("@")
-                ) {
-                  // We have a valid version
-                  versionsMap[tmpA[0]] = tmpB[1];
-                }
-              }
+      if (!l.includes("_dependency") && !l.includes(".dependency")) {
+        const depMatch = l.match(/dependency\(\s*['"]?([^'",)\s]+)['"]?/);
+        const depName = depMatch?.[1]?.trim();
+        if (depName) {
+          name_list.push(depName);
+          const versionMatch = l.match(/version\s*:\s*['"]?([^'",)\s]+)['"]?/);
+          const depVersion = versionMatch?.[1]?.trim();
+          if (depVersion) {
+            if (depVersion.includes(">") || depVersion.includes("<")) {
+              // We have a version specifier
+              versionSpecifiersMap[depName] = depVersion;
+            } else if (
+              /^\d+/.test(depVersion) &&
+              !depVersion.includes("${") &&
+              !depVersion.startsWith("@")
+            ) {
+              // We have a valid version
+              versionsMap[depName] = depVersion;
             }
           }
         }