@quantakrypto/core 0.5.0 → 0.6.0

package/src/dependencies.ts

@@ -401,6 +401,14 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     algorithms: ["X25519", "EdDSA"],
     severity: "low",
   },
+  {
+    name: "tink",
+    ecosystem: "pypi",
+    reason:
+      "Google Tink (Python) — classical RSA/ECDSA/Ed25519 signatures and ECIES hybrid encryption.",
+    algorithms: ["RSA", "ECDSA", "EdDSA", "ECIES"],
+    severity: "high",
+  },
 
   // --- crates.io (Rust) ---
   {
@@ -513,6 +521,21 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     algorithms: ["ECDSA", "ECDH"],
     severity: "medium",
   },
+  {
+    name: "github.com/tink-crypto/tink-go/v2",
+    ecosystem: "go",
+    reason:
+      "Google Tink (Go) — classical RSA/ECDSA/Ed25519 signatures and ECIES hybrid encryption.",
+    algorithms: ["RSA", "ECDSA", "EdDSA", "ECIES"],
+    severity: "high",
+  },
+  {
+    name: "github.com/google/tink/go",
+    ecosystem: "go",
+    reason: "Google Tink (legacy Go module) — classical RSA/ECDSA/Ed25519 and ECIES hybrid.",
+    algorithms: ["RSA", "ECDSA", "EdDSA", "ECIES"],
+    severity: "high",
+  },
 
   // --- Maven (Java) ---
   {
@@ -559,6 +582,14 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     severity: "medium",
     hndl: false,
   },
+  {
+    name: "tink",
+    ecosystem: "maven",
+    reason:
+      "Google Tink (com.google.crypto.tink) — classical RSA/ECDSA/Ed25519 signatures and ECIES hybrid encryption.",
+    algorithms: ["RSA", "ECDSA", "EdDSA", "ECIES"],
+    severity: "high",
+  },
 
   // --- RubyGems ---
   {
@@ -623,14 +654,83 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     severity: "medium",
     hndl: false,
   },
+
+  // --- Composer (PHP) ---
+  {
+    name: "phpseclib/phpseclib",
+    ecosystem: "composer",
+    reason: "Pure-PHP RSA / DSA / ECDSA / Diffie-Hellman public-key crypto and X.509.",
+    algorithms: ["RSA", "DSA", "ECDSA", "DH"],
+    severity: "high",
+  },
+  {
+    name: "paragonie/sodium_compat",
+    ecosystem: "composer",
+    reason: "Pure-PHP libsodium polyfill: X25519 key agreement and Ed25519 signatures.",
+    algorithms: ["X25519", "EdDSA"],
+    severity: "low",
+  },
+  {
+    name: "paragonie/halite",
+    ecosystem: "composer",
+    reason: "libsodium wrapper: X25519 key agreement and Ed25519 signatures.",
+    algorithms: ["X25519", "EdDSA"],
+    severity: "low",
+  },
+  {
+    name: "paragonie/paseto",
+    ecosystem: "composer",
+    reason: "PASETO public tokens signed with classical Ed25519 (v2/v4) or RSA.",
+    algorithms: ["EdDSA", "RSA"],
+    severity: "medium",
+    hndl: false,
+  },
+  {
+    name: "firebase/php-jwt",
+    ecosystem: "composer",
+    reason: "PHP JWT signing/verification with classical RS*/ES* algorithms.",
+    algorithms: ["RSA", "ECDSA"],
+    severity: "medium",
+    hndl: false,
+  },
+  {
+    name: "lcobucci/jwt",
+    ecosystem: "composer",
+    reason: "PHP JWT with classical RSA/ECDSA signature algorithms.",
+    algorithms: ["RSA", "ECDSA"],
+    severity: "medium",
+    hndl: false,
+  },
+  {
+    name: "web-token/jwt-framework",
+    ecosystem: "composer",
+    reason: "JOSE (JWS/JWE) framework: classical RSA/ECDSA signatures and ECDH-ES key agreement.",
+    algorithms: ["RSA", "ECDSA", "ECDH"],
+    severity: "medium",
+  },
+  {
+    name: "mdanter/ecc",
+    ecosystem: "composer",
+    reason: "Pure-PHP elliptic-curve ECDSA signatures and ECDH key agreement.",
+    algorithms: ["ECDSA", "ECDH"],
+    severity: "high",
+  },
+  {
+    name: "simplito/elliptic-php",
+    ecosystem: "composer",
+    reason: "secp256k1 / NIST-curve ECDSA and ECDH in pure PHP (blockchain keys).",
+    algorithms: ["ECDSA", "ECDH"],
+    severity: "high",
+  },
 ];
 
 /**
  * Normalise a package name for matching within its ecosystem. PyPI is
  * case-insensitive and folds runs of `-_.` to a single `-` (PEP 503); cargo /
- * maven / rubygems / nuget are effectively lower-case (NuGet ids are matched
- * case-insensitively); npm and go module paths are matched verbatim (npm scopes
- * and go paths are case-sensitive).
+ * maven / rubygems / nuget / composer are effectively lower-case (NuGet ids are
+ * matched case-insensitively; Composer `vendor/package` names are lower-cased by
+ * Packagist); npm and go module paths are matched verbatim (npm scopes and go
+ * paths are case-sensitive).
  */
 function normalizeName(ecosystem: DependencyEcosystem, name: string): string {
   const n = name.trim();
@@ -718,6 +818,7 @@ export function manifestEcosystem(file: string): DependencyEcosystem | null {
   if (base === "gemfile" || base.endsWith(".gemspec")) return "rubygems";
   if (base === "packages.config" || base === "directory.packages.props" || base.endsWith(".csproj"))
     return "nuget";
+  if (base === "composer.json" || base === "composer.lock") return "composer";
   return null;
 }
 
@@ -797,6 +898,20 @@ function candidateNames(ecosystem: DependencyEcosystem, content: string): string
       }
       break;
     }
+    case "composer": {
+      // composer.json `require`/`require-dev` maps are keyed by "vendor/package";
+      // composer.lock lists `{"name": "vendor/package", …}`. Both are JSON, so
+      // grab every quoted `vendor/package` token (a lower-case vendor + package
+      // separated by a single `/`). PHP platform requirements ("php", "ext-*")
+      // carry no slash and so are naturally excluded; the curated DB filters the
+      // rest, so over-capture is safe.
+      for (const m of content.matchAll(
+        /["']([a-z0-9](?:[a-z0-9._-]*[a-z0-9])?\/[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?)["']/gi,
+      )) {
+        names.push(m[1]);
+      }
+      break;
+    }
     case "npm":
       break; // npm uses the JSON path, not this extractor.
   }
@@ -893,10 +1008,33 @@ export function scanManifest(file: string, content: string): Finding[] {
   return sortByTitle(findings);
 }
 
+/**
+ * Resolve an npm `npm:` alias spec to the real package it installs, or null when
+ * the spec is not an alias. An aliased dependency records the alias as the map
+ * KEY and `npm:<real-name>@<range>` as the VALUE (in package.json and in a
+ * lockfile entry's `version`), so the vulnerable package hides behind a benign
+ * alias name. Keeps a leading scope `@` (only a version `@` past index 0 is a
+ * separator): `npm:node-forge@^1` → `node-forge`, `npm:@scope/pkg@1` → `@scope/pkg`.
+ */
+function npmAliasTarget(spec: string): string | null {
+  if (!spec.startsWith("npm:")) return null;
+  const rest = spec.slice(4);
+  const at = rest.lastIndexOf("@");
+  const name = at > 0 ? rest.slice(0, at) : rest;
+  return name || null;
+}
+
+/** Guard against a pathological / hostile lockfile nesting the walk unbounded. */
+const NPM_TREE_MAX_DEPTH = 64;
+
 /**
  * npm manifest scan.
- * - `package.json`: dependencies / devDependencies / peerDependencies / optionalDependencies.
- * - `package-lock.json` (v2/v3): the `packages` map keys (node_modules/<name>).
+ * - `package.json`: dependencies / devDependencies / peerDependencies / optionalDependencies,
+ *   including `npm:`-aliased entries (the alias key hides the real package name).
+ * - `package-lock.json` v1: the NESTED `dependencies` tree, where each entry may carry
+ *   its own `dependencies` (transitive deps) and an `npm:` alias in `version`.
+ * - `package-lock.json` v2/v3: the flat `packages` map keys (node_modules/<name>),
+ *   plus each entry's own `name` field (set for aliased installs).
  */
 function scanNpmManifest(
   content: string,
@@ -914,26 +1052,54 @@ function scanNpmManifest(
   const found = new Set<string>();
   const obj = json as Record<string, unknown>;
 
-  const collectFromRecord = (rec: unknown): void => {
-    if (rec === null || typeof rec !== "object") return;
-    for (const key of Object.keys(rec as Record<string, unknown>)) {
-      if (db.has(key)) found.add(key);
+  const add = (name: string): void => {
+    if (db.has(name)) found.add(name);
+  };
+
+  /**
+   * Walk a dependency map that may be either a flat package.json map
+   * (name → version-range string) or a legacy package-lock v1 tree (name →
+   * `{ version, requires, dependencies }`, arbitrarily nested). Matches keys,
+   * resolves `npm:` aliases from string values and entry `version` fields, and
+   * recurses into a nested `dependencies` sub-tree.
+   */
+  const walkDepTree = (deps: unknown, depth: number): void => {
+    if (depth > NPM_TREE_MAX_DEPTH || deps === null || typeof deps !== "object") return;
+    for (const [name, node] of Object.entries(deps as Record<string, unknown>)) {
+      add(name);
+      if (typeof node === "string") {
+        // package.json form: the value is a range, possibly `npm:<real>@<range>`.
+        const aliased = npmAliasTarget(node);
+        if (aliased) add(aliased);
+      } else if (node !== null && typeof node === "object") {
+        const rec = node as Record<string, unknown>;
+        if (typeof rec.version === "string") {
+          const aliased = npmAliasTarget(rec.version);
+          if (aliased) add(aliased);
+        }
+        walkDepTree(rec.dependencies, depth + 1); // v1 nests transitive deps here
+      }
     }
   };
 
-  collectFromRecord(obj.dependencies);
-  collectFromRecord(obj.devDependencies);
-  collectFromRecord(obj.peerDependencies);
-  collectFromRecord(obj.optionalDependencies);
+  walkDepTree(obj.dependencies, 0);
+  walkDepTree(obj.devDependencies, 0);
+  walkDepTree(obj.peerDependencies, 0);
+  walkDepTree(obj.optionalDependencies, 0);
 
   const packages = obj.packages;
   if (packages !== null && typeof packages === "object") {
-    for (const key of Object.keys(packages as Record<string, unknown>)) {
+    for (const [key, entry] of Object.entries(packages as Record<string, unknown>)) {
       if (!key) continue; // root package entry
       const marker = "node_modules/";
       const idx = key.lastIndexOf(marker);
-      const name = idx >= 0 ? key.slice(idx + marker.length) : key;
-      if (db.has(name)) found.add(name);
+      add(idx >= 0 ? key.slice(idx + marker.length) : key);
+      // Aliased install: the entry's own `name` field is the real package, which
+      // differs from the alias embedded in the node_modules/<alias> key.
+      if (entry !== null && typeof entry === "object") {
+        const realName = (entry as Record<string, unknown>).name;
+        if (typeof realName === "string") add(realName);
+      }
     }
   }
 

package/src/detectors/source.ts

@@ -47,6 +47,15 @@ import { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION, CWE_WEAK_STRENGTH } from "../cw
 // (ordered alternation would otherwise match `rsa` and reject the `-pss` tail).
 const RE_GENERATE_KEYPAIR =
   /generateKeyPair(?:Sync)?\s*\(\s*['"`](rsa-pss|rsa|ec|dsa|dh|x25519|x448|ed25519|ed448)['"`]/g;
+// Variable-typed key generation: `generateKeyPair(kind, …)` where the algorithm
+// argument is an IDENTIFIER (a variable), not a quoted literal, so the concrete
+// family is unknown at scan time but a classical key is still being generated.
+// The lookbehind anchors the call to a word boundary so it does not fire inside
+// a longer identifier (e.g. `myGenerateKeyPair(`); the first argument must be a
+// bare identifier immediately followed by `,` or `)` so a quoted-literal call
+// (handled by RE_GENERATE_KEYPAIR) never matches here.
+const RE_GENERATE_KEYPAIR_VAR =
+  /(?<![\w$])generateKeyPair(?:Sync)?\s*\(\s*([A-Za-z_$][\w$]*)\s*[,)]/g;
 
 /** Per-key-type classification for `generateKeyPair(Sync)('<type>', …)`. Hoisted
  * to module scope so the direct matcher AND the import-alias pass (below) share
@@ -177,6 +186,20 @@ function escapeRe(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 const RE_CREATE_SIGN_VERIFY = /create(?:Sign|Verify)\s*\(/g;
+// Computed-member (bracket) access to a Node `crypto` method:
+// `crypto['createSign'](…)`, `c["createECDH"](…)`. Bracket access defeats the
+// dotted-call regexes above (which require `name(`), so match a quoted method
+// name inside a `[ '…' ]( ` computed call and route it to the right rule. The
+// method names here take no key-type argument, so no argument parsing is needed;
+// `generateKeyPair(Sync)` bracket access is handled separately (it carries the
+// key-type literal). None of these overlap the dotted regexes (those require the
+// name immediately before `(`, whereas here it is followed by a closing quote).
+const RE_BRACKET_CRYPTO_METHOD =
+  /\[\s*['"`](createSign|createVerify|createECDH|createDiffieHellman|createDiffieHellmanGroup|publicEncrypt|privateDecrypt)['"`]\s*\]\s*\(/g;
+// `crypto['generateKeyPairSync']('rsa', …)`: bracket access carrying the quoted
+// key-type literal, classified exactly like the dotted `generateKeyPair` call.
+const RE_BRACKET_KEYGEN =
+  /\[\s*['"`]generateKeyPair(?:Sync)?['"`]\s*\]\s*\(\s*['"`](rsa-pss|rsa|ec|dsa|dh|x25519|x448|ed25519|ed448)['"`]/g;
 // One-shot crypto.sign/verify(algorithm, data, key). A LOOKBEHIND (not a
 // consumed char) anchors it so it doesn't fire inside identifiers like `assign(`
 // or `createSign(` (handled by the dedicated createSign/createVerify rule) —
@@ -375,6 +398,28 @@ const nodeCryptoDetector: Detector = {
       pushKeygenFinding(findings, m[1], file, content, m.index, m[0].length);
     });
 
+    // generateKeyPair(Sync)(<variable>, …): key type passed as a variable, so the
+    // family is unknown; emit the generic keygen rule (unknown / key-exchange /
+    // HNDL-conservative) rather than missing the classical key generation.
+    eachMatch(RE_GENERATE_KEYPAIR_VAR, content, (m) => {
+      findings.push(
+        findingFromRule(
+          RULE_NODE_KEYGEN,
+          { file, content, index: m.index, matchLength: m[0].length },
+          {
+            title: "Classical key generation (variable key type)",
+            message:
+              "Generates a classical asymmetric key pair (key type passed as a variable), which is not quantum-safe.",
+          },
+        ),
+      );
+    });
+
+    // Bracket (computed-member) key generation: crypto['generateKeyPairSync']('rsa').
+    eachMatch(RE_BRACKET_KEYGEN, content, (m) => {
+      pushKeygenFinding(findings, m[1], file, content, m.index, m[0].length);
+    });
+
     // Import-alias resolution: follow `import { generateKeyPairSync as gk }` (and
     // the CommonJS destructure-rename) so an aliased call still detects. Only the
     // keygen / ECDH / DH constructors are resolved — their classification is
@@ -432,6 +477,23 @@ const nodeCryptoDetector: Detector = {
       );
     });
 
+    // Bracket (computed-member) access to argument-free crypto methods:
+    // crypto['createSign'](…), c["createECDH"](…). Route each to its rule.
+    eachMatch(RE_BRACKET_CRYPTO_METHOD, content, (m) => {
+      const loc = { file, content, index: m.index, matchLength: m[0].length };
+      const method = m[1];
+      if (method === "createSign" || method === "createVerify") {
+        findings.push(findingFromRule(RULE_NODE_SIGN, loc));
+      } else if (method === "createECDH") {
+        findings.push(findingFromRule(RULE_NODE_ECDH, loc));
+      } else if (method === "publicEncrypt" || method === "privateDecrypt") {
+        findings.push(findingFromRule(RULE_NODE_RSA_ENCRYPT, loc));
+      } else {
+        // createDiffieHellman / createDiffieHellmanGroup: finite-field DH.
+        findings.push(findingFromRule(RULE_NODE_DH, loc));
+      }
+    });
+
     // One-shot crypto.sign(algorithm, data, key) / crypto.verify(...) (Node ≥ 12).
     eachMatch(RE_ONESHOT_SIGN_VERIFY, content, (m) => {
       findings.push(