@quantakrypto/core 0.4.3 → 0.5.0

package/dist/detectors/elixir.js

@@ -0,0 +1,227 @@
+import { ELIXIR_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+const RE_EX_GEN = /:crypto\.generate_key\s*\(\s*:(\w+)/g;
+// `:crypto.compute_key(:ecdh|:dh, PeerPub, MyKey, :curve)` is the DH/ECDH AGREEMENT
+// operation itself — the harvest-now-decrypt-later step — which generate_key alone
+// misses. Classified by the same type/curve logic as generate_key.
+const RE_EX_COMPUTE = /:crypto\.compute_key\s*\(\s*:(\w+)/g;
+const RE_EX_SIGN = /:crypto\.(?:sign|verify)\s*\(\s*:(\w+)/g;
+const RE_EX_X509_RSA = /\bX509\.PrivateKey\.new_rsa\s*\(/g;
+const RE_EX_X509_EC = /\bX509\.PrivateKey\.new_ec\s*\(/g;
+const RE_EX_JOSE = /\bJOSE\.JWK\.generate_key\s*\(\s*\{\s*:(\w+)/g;
+const SIG_REM = "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)";
+const KEX_REM = "hybrid X25519MLKEM768 (ML-KEM-768)";
+const RULE_EX_KEYGEN = {
+    id: "elixir-crypto-keygen",
+    title: "Elixir :crypto key generation",
+    description: ":crypto.generate_key (rsa/ecdh/dh/eddsa)",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Generates a classical key pair via Erlang :crypto (Elixir) — not quantum-safe.",
+};
+const RULE_EX_SIGN = {
+    id: "elixir-crypto-sign",
+    title: "Elixir :crypto signature",
+    description: ":crypto.sign / :crypto.verify (rsa/ecdsa/eddsa)",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Classical signature via Erlang :crypto (Elixir) is forgeable by a quantum attacker.",
+    remediation: SIG_REM,
+};
+const RULE_EX_X509 = {
+    id: "elixir-x509-keygen",
+    title: "Elixir X509 key generation",
+    description: "X509.PrivateKey.new_rsa / new_ec",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Generates a classical key pair via the X509 library (Elixir) — not quantum-safe.",
+};
+const RULE_EX_JOSE = {
+    id: "elixir-jose-jwk",
+    title: "Elixir JOSE JWK generation",
+    description: "JOSE.JWK.generate_key ({:rsa|:ec|:okp})",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Generates a classical JWK via JOSE (Elixir) — not quantum-safe.",
+};
+const RSA_CLS = { algo: "RSA", cat: "kem", sev: "high", hndl: true, label: "RSA" };
+const DH_CLS = { algo: "DH", cat: "key-exchange", sev: "high", hndl: true, label: "DH" };
+const ECDH_CLS = {
+    algo: "ECDH",
+    cat: "key-exchange",
+    sev: "high",
+    hndl: true,
+    label: "ECDH",
+    remediation: KEX_REM,
+};
+const X25519_CLS = {
+    algo: "X25519",
+    cat: "key-exchange",
+    sev: "medium",
+    hndl: true,
+    label: "X25519",
+    remediation: KEX_REM,
+};
+const X448_CLS = { ...X25519_CLS, algo: "X448", label: "X448" };
+const EDDSA_CLS = {
+    algo: "EdDSA",
+    cat: "signature",
+    sev: "low",
+    hndl: false,
+    label: "EdDSA",
+    remediation: SIG_REM,
+};
+const EC_CLS = {
+    algo: "ECDH",
+    cat: "key-exchange",
+    sev: "high",
+    hndl: true,
+    label: "EC (ECDSA/ECDH)",
+    remediation: KEX_REM,
+};
+/** Classify a `:crypto.generate_key(:<type>, …)` by its type atom (+ the curve
+ * atom in a short window for the ecdh X25519/X448 case). */
+function classifyGen(type, window) {
+    switch (type) {
+        case "rsa":
+            return RSA_CLS;
+        case "dh":
+            return DH_CLS;
+        case "eddsa":
+        case "ed25519":
+            return EDDSA_CLS;
+        case "ecdh":
+            if (/:x25519\b/i.test(window))
+                return X25519_CLS;
+            if (/:x448\b/i.test(window))
+                return X448_CLS;
+            return ECDH_CLS;
+        default:
+            return null; // srp / other non-broken-in-this-model types
+    }
+}
+/** Signature algorithm classification for `:crypto.sign(:<type>, …)`. */
+function classifySign(type) {
+    if (type === "rsa")
+        return "RSA";
+    if (type === "ecdsa")
+        return "ECDSA";
+    if (type === "eddsa" || type === "ed25519")
+        return "EdDSA";
+    if (type === "dss")
+        return "DSA"; // Erlang's algorithm atom for DSA signatures
+    return null;
+}
+/** Detects classical asymmetric crypto in Elixir (:crypto, X509, JOSE). */
+export const elixirDetector = {
+    id: "elixir-crypto",
+    description: "Classical asymmetric crypto in Elixir (:crypto, X509, JOSE)",
+    scope: "source",
+    language: "elixir",
+    rules: [RULE_EX_KEYGEN, RULE_EX_SIGN, RULE_EX_X509, RULE_EX_JOSE],
+    appliesTo: (f) => hasExtension(f, ELIXIR_EXTENSIONS),
+    detect({ file, content }) {
+        const findings = [];
+        const at = (m) => ({
+            file,
+            content,
+            index: m.index,
+            matchLength: m[0].length,
+        });
+        // :crypto.generate_key(:type, …) — classify by the type atom (+ curve window).
+        eachMatch(RE_EX_GEN, content, (m) => {
+            const cls = classifyGen(m[1], content.slice(m.index, m.index + 80));
+            if (!cls)
+                return;
+            findings.push(findingFromRule(RULE_EX_KEYGEN, at(m), {
+                title: `Elixir :crypto ${cls.label} key generation`,
+                category: cls.cat,
+                severity: cls.sev,
+                algorithm: cls.algo,
+                hndl: cls.hndl,
+                message: `Generates a classical ${cls.label} key pair via Erlang :crypto (Elixir) — not quantum-safe.`,
+                ...(cls.remediation ? { remediation: cls.remediation } : {}),
+            }));
+        });
+        // :crypto.compute_key(:type, …) — the (EC)DH agreement operation.
+        eachMatch(RE_EX_COMPUTE, content, (m) => {
+            const cls = classifyGen(m[1], content.slice(m.index, m.index + 120));
+            if (!cls)
+                return;
+            findings.push(findingFromRule(RULE_EX_KEYGEN, at(m), {
+                title: `Elixir :crypto ${cls.label} key agreement`,
+                category: cls.cat,
+                severity: cls.sev,
+                algorithm: cls.algo,
+                hndl: cls.hndl,
+                message: `Performs classical ${cls.label} key agreement via Erlang :crypto (Elixir) — harvest-now-decrypt-later exposed.`,
+                ...(cls.remediation ? { remediation: cls.remediation } : {}),
+            }));
+        });
+        // :crypto.sign / :crypto.verify(:type, …).
+        eachMatch(RE_EX_SIGN, content, (m) => {
+            const algo = classifySign(m[1]);
+            if (!algo)
+                return;
+            findings.push(findingFromRule(RULE_EX_SIGN, at(m), {
+                algorithm: algo,
+                message: `Classical ${algo} signature via Erlang :crypto (Elixir) is forgeable by a quantum attacker.`,
+            }));
+        });
+        // X509.PrivateKey.new_rsa / new_ec.
+        eachMatch(RE_EX_X509_RSA, content, (m) => findings.push(findingFromRule(RULE_EX_X509, at(m), { algorithm: "RSA" })));
+        eachMatch(RE_EX_X509_EC, content, (m) => findings.push(findingFromRule(RULE_EX_X509, at(m), {
+            title: "Elixir X509 EC key generation",
+            category: EC_CLS.cat,
+            algorithm: EC_CLS.algo,
+            hndl: EC_CLS.hndl,
+            message: "Generates a classical EC key pair via the X509 library (Elixir); EC keys feed BOTH ECDSA and ECDH.",
+            remediation: KEX_REM,
+        })));
+        // JOSE.JWK.generate_key({:rsa|:ec|:okp, …}). An OKP key is EdDSA (Ed25519/Ed448,
+        // signature) OR a Montgomery key-agreement key (X25519/X448, HNDL) — inspect the
+        // curve atom in a short window so an X25519 OKP is not mislabeled as an EdDSA
+        // signature.
+        eachMatch(RE_EX_JOSE, content, (m) => {
+            const kind = m[1];
+            let okpCls = EDDSA_CLS;
+            if (kind === "okp") {
+                const window = content.slice(m.index, m.index + 80);
+                if (/:x25519\b/i.test(window))
+                    okpCls = X25519_CLS;
+                else if (/:x448\b/i.test(window))
+                    okpCls = X448_CLS;
+            }
+            const cls = kind === "rsa" ? RSA_CLS : kind === "ec" ? EC_CLS : kind === "okp" ? okpCls : null;
+            if (!cls)
+                return;
+            findings.push(findingFromRule(RULE_EX_JOSE, at(m), {
+                title: `Elixir JOSE ${cls.label} JWK`,
+                category: cls.cat,
+                severity: cls.sev,
+                algorithm: cls.algo,
+                hndl: cls.hndl,
+                message: `Generates a classical ${cls.label} JWK via JOSE (Elixir) — not quantum-safe.`,
+                ...(cls.remediation ? { remediation: cls.remediation } : {}),
+            }));
+        });
+        return findings;
+    },
+};
+//# sourceMappingURL=elixir.js.map

package/dist/detectors/elixir.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elixir.js","sourceRoot":"","sources":["../../src/detectors/elixir.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Source-code detector for classical asymmetric cryptography in Elixir (the BEAM\n * / Phoenix ecosystem), previously uncovered. Handles the three common surfaces:\n *\n *  - **Erlang `:crypto`** — `:crypto.generate_key(:rsa|:ecdh|:dh|:eddsa, …)`\n *    (the curve atom disambiguates X25519/X448 from a generic ECDH curve) and\n *    `:crypto.sign/:crypto.verify(:rsa|:ecdsa|:eddsa, …)`.\n *  - **`X509`** (the `x509` hex package) — `X509.PrivateKey.new_rsa` / `new_ec`.\n *  - **`JOSE`** (erlang-jose) — `JOSE.JWK.generate_key({:rsa|:ec|:okp, …})`.\n *\n * Lexical, like the other packs; the `:crypto.` atom-module syntax and the\n * `X509.` / `JOSE.` module paths are distinctive, so the false-positive rate is low.\n *\n * HNDL: RSA and (EC/X)DH key agreement are harvest-now-decrypt-later exposed\n * (hndl:true); ECDSA / EdDSA signatures are hndl:false but forgeable.\n */\nimport type { AlgorithmFamily, Detector, Finding, RuleMeta } from \"../types.js\";\nimport { ELIXIR_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO } from \"../cwe.js\";\n\nconst RE_EX_GEN = /:crypto\\.generate_key\\s*\\(\\s*:(\\w+)/g;\n// `:crypto.compute_key(:ecdh|:dh, PeerPub, MyKey, :curve)` is the DH/ECDH AGREEMENT\n// operation itself — the harvest-now-decrypt-later step — which generate_key alone\n// misses. Classified by the same type/curve logic as generate_key.\nconst RE_EX_COMPUTE = /:crypto\\.compute_key\\s*\\(\\s*:(\\w+)/g;\nconst RE_EX_SIGN = /:crypto\\.(?:sign|verify)\\s*\\(\\s*:(\\w+)/g;\nconst RE_EX_X509_RSA = /\\bX509\\.PrivateKey\\.new_rsa\\s*\\(/g;\nconst RE_EX_X509_EC = /\\bX509\\.PrivateKey\\.new_ec\\s*\\(/g;\nconst RE_EX_JOSE = /\\bJOSE\\.JWK\\.generate_key\\s*\\(\\s*\\{\\s*:(\\w+)/g;\n\ninterface Cls {\n  algo: AlgorithmFamily;\n  cat: Finding[\"category\"];\n  sev: Finding[\"severity\"];\n  hndl: boolean;\n  label: string;\n  remediation?: string;\n}\nconst SIG_REM = \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\";\nconst KEX_REM = \"hybrid X25519MLKEM768 (ML-KEM-768)\";\n\nconst RULE_EX_KEYGEN: RuleMeta = {\n  id: \"elixir-crypto-keygen\",\n  title: \"Elixir :crypto key generation\",\n  description: \":crypto.generate_key (rsa/ecdh/dh/eddsa)\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Generates a classical key pair via Erlang :crypto (Elixir) — not quantum-safe.\",\n};\nconst RULE_EX_SIGN: RuleMeta = {\n  id: \"elixir-crypto-sign\",\n  title: \"Elixir :crypto signature\",\n  description: \":crypto.sign / :crypto.verify (rsa/ecdsa/eddsa)\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"unknown\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical signature via Erlang :crypto (Elixir) is forgeable by a quantum attacker.\",\n  remediation: SIG_REM,\n};\nconst RULE_EX_X509: RuleMeta = {\n  id: \"elixir-x509-keygen\",\n  title: \"Elixir X509 key generation\",\n  description: \"X509.PrivateKey.new_rsa / new_ec\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Generates a classical key pair via the X509 library (Elixir) — not quantum-safe.\",\n};\nconst RULE_EX_JOSE: RuleMeta = {\n  id: \"elixir-jose-jwk\",\n  title: \"Elixir JOSE JWK generation\",\n  description: \"JOSE.JWK.generate_key ({:rsa|:ec|:okp})\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Generates a classical JWK via JOSE (Elixir) — not quantum-safe.\",\n};\n\nconst RSA_CLS: Cls = { algo: \"RSA\", cat: \"kem\", sev: \"high\", hndl: true, label: \"RSA\" };\nconst DH_CLS: Cls = { algo: \"DH\", cat: \"key-exchange\", sev: \"high\", hndl: true, label: \"DH\" };\nconst ECDH_CLS: Cls = {\n  algo: \"ECDH\",\n  cat: \"key-exchange\",\n  sev: \"high\",\n  hndl: true,\n  label: \"ECDH\",\n  remediation: KEX_REM,\n};\nconst X25519_CLS: Cls = {\n  algo: \"X25519\",\n  cat: \"key-exchange\",\n  sev: \"medium\",\n  hndl: true,\n  label: \"X25519\",\n  remediation: KEX_REM,\n};\nconst X448_CLS: Cls = { ...X25519_CLS, algo: \"X448\", label: \"X448\" };\nconst EDDSA_CLS: Cls = {\n  algo: \"EdDSA\",\n  cat: \"signature\",\n  sev: \"low\",\n  hndl: false,\n  label: \"EdDSA\",\n  remediation: SIG_REM,\n};\nconst EC_CLS: Cls = {\n  algo: \"ECDH\",\n  cat: \"key-exchange\",\n  sev: \"high\",\n  hndl: true,\n  label: \"EC (ECDSA/ECDH)\",\n  remediation: KEX_REM,\n};\n\n/** Classify a `:crypto.generate_key(:<type>, …)` by its type atom (+ the curve\n * atom in a short window for the ecdh X25519/X448 case). */\nfunction classifyGen(type: string, window: string): Cls | null {\n  switch (type) {\n    case \"rsa\":\n      return RSA_CLS;\n    case \"dh\":\n      return DH_CLS;\n    case \"eddsa\":\n    case \"ed25519\":\n      return EDDSA_CLS;\n    case \"ecdh\":\n      if (/:x25519\\b/i.test(window)) return X25519_CLS;\n      if (/:x448\\b/i.test(window)) return X448_CLS;\n      return ECDH_CLS;\n    default:\n      return null; // srp / other non-broken-in-this-model types\n  }\n}\n\n/** Signature algorithm classification for `:crypto.sign(:<type>, …)`. */\nfunction classifySign(type: string): AlgorithmFamily | null {\n  if (type === \"rsa\") return \"RSA\";\n  if (type === \"ecdsa\") return \"ECDSA\";\n  if (type === \"eddsa\" || type === \"ed25519\") return \"EdDSA\";\n  if (type === \"dss\") return \"DSA\"; // Erlang's algorithm atom for DSA signatures\n  return null;\n}\n\n/** Detects classical asymmetric crypto in Elixir (:crypto, X509, JOSE). */\nexport const elixirDetector: Detector = {\n  id: \"elixir-crypto\",\n  description: \"Classical asymmetric crypto in Elixir (:crypto, X509, JOSE)\",\n  scope: \"source\",\n  language: \"elixir\",\n  rules: [RULE_EX_KEYGEN, RULE_EX_SIGN, RULE_EX_X509, RULE_EX_JOSE],\n  appliesTo: (f) => hasExtension(f, ELIXIR_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const findings: Finding[] = [];\n    const at = (m: RegExpExecArray) => ({\n      file,\n      content,\n      index: m.index,\n      matchLength: m[0].length,\n    });\n\n    // :crypto.generate_key(:type, …) — classify by the type atom (+ curve window).\n    eachMatch(RE_EX_GEN, content, (m) => {\n      const cls = classifyGen(m[1], content.slice(m.index, m.index + 80));\n      if (!cls) return;\n      findings.push(\n        findingFromRule(RULE_EX_KEYGEN, at(m), {\n          title: `Elixir :crypto ${cls.label} key generation`,\n          category: cls.cat,\n          severity: cls.sev,\n          algorithm: cls.algo,\n          hndl: cls.hndl,\n          message: `Generates a classical ${cls.label} key pair via Erlang :crypto (Elixir) — not quantum-safe.`,\n          ...(cls.remediation ? { remediation: cls.remediation } : {}),\n        }),\n      );\n    });\n\n    // :crypto.compute_key(:type, …) — the (EC)DH agreement operation.\n    eachMatch(RE_EX_COMPUTE, content, (m) => {\n      const cls = classifyGen(m[1], content.slice(m.index, m.index + 120));\n      if (!cls) return;\n      findings.push(\n        findingFromRule(RULE_EX_KEYGEN, at(m), {\n          title: `Elixir :crypto ${cls.label} key agreement`,\n          category: cls.cat,\n          severity: cls.sev,\n          algorithm: cls.algo,\n          hndl: cls.hndl,\n          message: `Performs classical ${cls.label} key agreement via Erlang :crypto (Elixir) — harvest-now-decrypt-later exposed.`,\n          ...(cls.remediation ? { remediation: cls.remediation } : {}),\n        }),\n      );\n    });\n\n    // :crypto.sign / :crypto.verify(:type, …).\n    eachMatch(RE_EX_SIGN, content, (m) => {\n      const algo = classifySign(m[1]);\n      if (!algo) return;\n      findings.push(\n        findingFromRule(RULE_EX_SIGN, at(m), {\n          algorithm: algo,\n          message: `Classical ${algo} signature via Erlang :crypto (Elixir) is forgeable by a quantum attacker.`,\n        }),\n      );\n    });\n\n    // X509.PrivateKey.new_rsa / new_ec.\n    eachMatch(RE_EX_X509_RSA, content, (m) =>\n      findings.push(findingFromRule(RULE_EX_X509, at(m), { algorithm: \"RSA\" })),\n    );\n    eachMatch(RE_EX_X509_EC, content, (m) =>\n      findings.push(\n        findingFromRule(RULE_EX_X509, at(m), {\n          title: \"Elixir X509 EC key generation\",\n          category: EC_CLS.cat,\n          algorithm: EC_CLS.algo,\n          hndl: EC_CLS.hndl,\n          message:\n            \"Generates a classical EC key pair via the X509 library (Elixir); EC keys feed BOTH ECDSA and ECDH.\",\n          remediation: KEX_REM,\n        }),\n      ),\n    );\n\n    // JOSE.JWK.generate_key({:rsa|:ec|:okp, …}). An OKP key is EdDSA (Ed25519/Ed448,\n    // signature) OR a Montgomery key-agreement key (X25519/X448, HNDL) — inspect the\n    // curve atom in a short window so an X25519 OKP is not mislabeled as an EdDSA\n    // signature.\n    eachMatch(RE_EX_JOSE, content, (m) => {\n      const kind = m[1];\n      let okpCls: Cls = EDDSA_CLS;\n      if (kind === \"okp\") {\n        const window = content.slice(m.index, m.index + 80);\n        if (/:x25519\\b/i.test(window)) okpCls = X25519_CLS;\n        else if (/:x448\\b/i.test(window)) okpCls = X448_CLS;\n      }\n      const cls =\n        kind === \"rsa\" ? RSA_CLS : kind === \"ec\" ? EC_CLS : kind === \"okp\" ? okpCls : null;\n      if (!cls) return;\n      findings.push(\n        findingFromRule(RULE_EX_JOSE, at(m), {\n          title: `Elixir JOSE ${cls.label} JWK`,\n          category: cls.cat,\n          severity: cls.sev,\n          algorithm: cls.algo,\n          hndl: cls.hndl,\n          message: `Generates a classical ${cls.label} JWK via JOSE (Elixir) — not quantum-safe.`,\n          ...(cls.remediation ? { remediation: cls.remediation } : {}),\n        }),\n      );\n    });\n\n    return findings;\n  },\n};\n"]}

package/dist/detectors/java.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../src/detectors/java.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAkT/D,iFAAiF;AACjF,eAAO,MAAM,YAAY,EAAE,QA4F1B,CAAC"}
+{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../src/detectors/java.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA0U/D,iFAAiF;AACjF,eAAO,MAAM,YAAY,EAAE,QAuG1B,CAAC"}

package/dist/detectors/java.js

@@ -8,7 +8,7 @@ import { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION, CWE_WEAK_STRENGTH } from "../cw
 // are symmetric / hashing only).
 const RE_JAVA_GETINSTANCE = /\b(KeyPairGenerator|Signature|Cipher|KeyAgreement|KeyFactory)\s*\.\s*getInstance\s*\(\s*"([^"]+)"/g;
 // BouncyCastle lightweight-API class instantiations.
-const RE_JAVA_BC = /\bnew\s+(RSAKeyPairGenerator|DSAKeyPairGenerator|ECKeyPairGenerator|ECDSASigner|Ed25519Signer|Ed448Signer|X25519Agreement|X448Agreement|ECDHBasicAgreement|DHBasicAgreement|X25519KeyPairGenerator|Ed25519KeyPairGenerator|RSAEngine|OAEPEncoding)\s*\(/g;
+const RE_JAVA_BC = /\bnew\s+(RSAKeyPairGenerator|DSAKeyPairGenerator|ECKeyPairGenerator|ECDSASigner|Ed25519Signer|Ed448Signer|X25519Agreement|X448Agreement|ECDHBasicAgreement|DHBasicAgreement|X25519KeyPairGenerator|X448KeyPairGenerator|Ed25519KeyPairGenerator|Ed448KeyPairGenerator|X448PrivateKeyParameters|RSAEngine|OAEPEncoding)\s*\(/g;
 // BouncyCastle lightweight-API curve/EdDSA classes as a BARE constructor call —
 // the Kotlin form (`X448KeyPairGenerator()`, no `new` keyword). RE_JAVA_BC above
 // only matches the Java `new <Class>(` form, so Kotlin sources that drive the
@@ -17,13 +17,27 @@ const RE_JAVA_BC = /\bnew\s+(RSAKeyPairGenerator|DSAKeyPairGenerator|ECKeyPairGe
 // while bare `X448Agreement(` routes to the family-specific rules below. Scoped
 // to the exact X448/X25519/Ed448/Ed25519 class names to stay precise.
 const RE_JAVA_BC_CURVE = /(?<!\bnew\s+)\b(X448KeyPairGenerator|X448Agreement|X448PrivateKeyParameters|X25519KeyPairGenerator|X25519Agreement|Ed448KeyPairGenerator|Ed448Signer|Ed25519KeyPairGenerator|Ed25519Signer)\s*\(/g;
+// The non-curve BouncyCastle classes (RSA/EC/DSA/DH keygen, signers, engines) as a
+// BARE constructor call — the Kotlin form, `ECKeyPairGenerator()` with no `new`. Java
+// and Scala instantiate Java classes with `new` (caught by RE_JAVA_BC), so bare calls
+// to these distinctive class names are Kotlin. The `(?<!\bnew\s+)` avoids double-
+// counting the `new` form; routed through the same BC_CLASS_RULES map.
+const RE_JAVA_BC_BARE = /(?<!\bnew\s+)\b(RSAKeyPairGenerator|DSAKeyPairGenerator|ECKeyPairGenerator|ECDSASigner|ECDHBasicAgreement|DHBasicAgreement|RSAEngine|OAEPEncoding)\s*\(/g;
 // Insecure JSSE / TLS configuration expressed in Java source. Mirrors the JS
 // tlsDetector in source.ts (category "tls"): a legacy SSL/TLS protocol version
 // requested from SSLContext, and TLS hostname verification neutered via an
 // all-trusting verifier (Apache HttpClient's NoopHostnameVerifier /
 // ALLOW_ALL_HOSTNAME_VERIFIER).
-const RE_JAVA_TLS_LEGACY = /\bSSLContext\s*\.\s*getInstance\s*\(\s*"(SSL|SSLv3|TLSv1)"/g;
-const RE_JAVA_TLS_NOVERIFY = /\b(NoopHostnameVerifier|ALLOW_ALL_HOSTNAME_VERIFIER)\b/g;
+// `TLSv1(?:\.1)?` catches both TLS 1.0 and the equally-deprecated TLS 1.1 (RFC 8996),
+// mirroring the JS tlsDetector; the closing `"` keeps `"TLSv1.2"`/`"TLSv1.3"`/`"TLS"`
+// from matching. `SSLv2` is included alongside `SSLv3`.
+const RE_JAVA_TLS_LEGACY = /\bSSLContext\s*\.\s*getInstance\s*\(\s*"(SSL|SSLv2|SSLv3|TLSv1(?:\.1)?)"/g;
+// Require a USAGE position, not a bare identifier: `NoopHostnameVerifier` followed by
+// `(` (construction) or `.` (`.INSTANCE`), and `ALLOW_ALL_HOSTNAME_VERIFIER` preceded
+// by `.` (member access). This keeps `new NoopHostnameVerifier()` and
+// `SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER` while dropping the common
+// false positive of a plain `import …NoopHostnameVerifier;` line.
+const RE_JAVA_TLS_NOVERIFY = /\bNoopHostnameVerifier\s*[.(]|\.\s*ALLOW_ALL_HOSTNAME_VERIFIER\b/g;
 // Identifier-form JWT/JOSE signature algorithms (audit F7). The quoted-string
 // alg token ("RS256") is caught by the language-agnostic jwt-jose detector, but
 // the Java JWT libraries pass the alg as an IDENTIFIER, not a string literal:
@@ -233,6 +247,11 @@ function classifyGetInstance(factory, rawAlg) {
     const isSignature = factory === "Signature";
     if (alg.includes("ECDSA"))
         return RULE_JAVA_ECDSA_SIGN;
+    // ECIES (EC Integrated Encryption Scheme, incl. `ECIESwithAES-CBC`) is classical EC
+    // public-key ENCRYPTION — harvest-now-decrypt-later exposed. Checked before the EC
+    // branches below (which would otherwise miss it) and the RSA/DSA checks.
+    if (alg.includes("ECIES"))
+        return RULE_JAVA_ECDH;
     if (alg.includes("ECDH"))
         return RULE_JAVA_ECDH;
     if (alg === "EC")
@@ -268,7 +287,10 @@ const BC_CLASS_RULES = {
     ECDHBasicAgreement: RULE_JAVA_ECDH,
     DHBasicAgreement: RULE_JAVA_DH,
     X25519KeyPairGenerator: RULE_JAVA_XDH,
+    X448KeyPairGenerator: RULE_JAVA_XDH,
+    X448PrivateKeyParameters: RULE_JAVA_XDH,
     Ed25519KeyPairGenerator: RULE_JAVA_EDDSA,
+    Ed448KeyPairGenerator: RULE_JAVA_EDDSA,
     RSAEngine: RULE_JAVA_RSA,
     OAEPEncoding: RULE_JAVA_RSA,
 };
@@ -287,7 +309,7 @@ const BC_CURVE_CLASS_RULES = {
 /** Detects classical asymmetric crypto in Java / Kotlin (JCA + BouncyCastle). */
 export const javaDetector = {
     id: "java-crypto",
-    description: "Classical asymmetric crypto in Java/Kotlin (JCA getInstance + BouncyCastle)",
+    description: "Classical asymmetric crypto on the JVM — Java/Kotlin/Scala (JCA getInstance + BouncyCastle)",
     scope: "source",
     language: "java",
     rules: [
@@ -332,6 +354,14 @@ export const javaDetector = {
                 return;
             findings.push(findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }));
         });
+        // Bare (Kotlin-form) constructor calls to the non-curve BC classes — same rules
+        // as the `new` form, routed via BC_CLASS_RULES.
+        eachMatch(RE_JAVA_BC_BARE, content, (m) => {
+            const rule = BC_CLASS_RULES[m[1]];
+            if (!rule)
+                return;
+            findings.push(findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }));
+        });
         // Legacy SSL/TLS protocol version requested from SSLContext.
         eachMatch(RE_JAVA_TLS_LEGACY, content, (m) => {
             findings.push(findingFromRule(RULE_JAVA_TLS_LEGACY, {

package/dist/detectors/java.js.map

@@ -1 +1 @@
-{"version":3,"file":"java.js","sourceRoot":"","sources":["../../src/detectors/java.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Source-code detector for classical, non-quantum-safe asymmetric cryptography\n * in Java / Kotlin (the JCA — Java Cryptography Architecture). Same lexical\n * strategy as the other language packs.\n *\n * The JCA funnels almost everything through a handful of factory methods keyed\n * by an ALGORITHM STRING: `KeyPairGenerator.getInstance(\"RSA\")`,\n * `Signature.getInstance(\"SHA256withECDSA\")`, `Cipher.getInstance(\"RSA/ECB/…\")`,\n * `KeyAgreement.getInstance(\"ECDH\")`. So detection here is two steps: match the\n * `<Factory>.getInstance(\"<alg>\")` call, then classify the (factory, alg) pair\n * into a rule. Symmetric / hashing algorithms (\"AES\", \"HmacSHA256\", …) classify\n * to nothing and are ignored. A small set of BouncyCastle lightweight-API class\n * names (`new ECDSASigner()`, `new X25519Agreement()`, …) is matched directly.\n *\n * HNDL policy mirrors the other detectors: KEM / key agreement (RSA encryption,\n * (EC)DH, X25519/X448) is harvest-now-decrypt-later exposed (hndl:true);\n * signatures (RSA/ECDSA/DSA/EdDSA) are hndl:false but forgeable by a quantum\n * attacker. `KeyPairGenerator.getInstance(\"EC\")` is ambiguous (an EC key feeds\n * both ECDSA and ECDH), so it is classified conservatively as\n * key-exchange-capable (hndl:true), exactly as the Node/Python EC keygen rules.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport { JAVA_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION, CWE_WEAK_STRENGTH } from \"../cwe.js\";\n\n/* -------------------------------------------------------------------------- */\n/* Regexes                                                                    */\n/* -------------------------------------------------------------------------- */\n\n// <Factory>.getInstance(\"<alg>\") — the JCA entry points that carry asymmetric\n// algorithms. KeyGenerator/MessageDigest/Mac are intentionally excluded (they\n// are symmetric / hashing only).\nconst RE_JAVA_GETINSTANCE =\n  /\\b(KeyPairGenerator|Signature|Cipher|KeyAgreement|KeyFactory)\\s*\\.\\s*getInstance\\s*\\(\\s*\"([^\"]+)\"/g;\n\n// BouncyCastle lightweight-API class instantiations.\nconst RE_JAVA_BC =\n  /\\bnew\\s+(RSAKeyPairGenerator|DSAKeyPairGenerator|ECKeyPairGenerator|ECDSASigner|Ed25519Signer|Ed448Signer|X25519Agreement|X448Agreement|ECDHBasicAgreement|DHBasicAgreement|X25519KeyPairGenerator|Ed25519KeyPairGenerator|RSAEngine|OAEPEncoding)\\s*\\(/g;\n\n// BouncyCastle lightweight-API curve/EdDSA classes as a BARE constructor call —\n// the Kotlin form (`X448KeyPairGenerator()`, no `new` keyword). RE_JAVA_BC above\n// only matches the Java `new <Class>(` form, so Kotlin sources that drive the\n// lightweight API directly are missed. The negative lookbehind `(?<!\\bnew\\s+)`\n// keeps this additive: `new X448Agreement(` stays with RE_JAVA_BC (java-xdh),\n// while bare `X448Agreement(` routes to the family-specific rules below. Scoped\n// to the exact X448/X25519/Ed448/Ed25519 class names to stay precise.\nconst RE_JAVA_BC_CURVE =\n  /(?<!\\bnew\\s+)\\b(X448KeyPairGenerator|X448Agreement|X448PrivateKeyParameters|X25519KeyPairGenerator|X25519Agreement|Ed448KeyPairGenerator|Ed448Signer|Ed25519KeyPairGenerator|Ed25519Signer)\\s*\\(/g;\n\n// Insecure JSSE / TLS configuration expressed in Java source. Mirrors the JS\n// tlsDetector in source.ts (category \"tls\"): a legacy SSL/TLS protocol version\n// requested from SSLContext, and TLS hostname verification neutered via an\n// all-trusting verifier (Apache HttpClient's NoopHostnameVerifier /\n// ALLOW_ALL_HOSTNAME_VERIFIER).\nconst RE_JAVA_TLS_LEGACY = /\\bSSLContext\\s*\\.\\s*getInstance\\s*\\(\\s*\"(SSL|SSLv3|TLSv1)\"/g;\nconst RE_JAVA_TLS_NOVERIFY = /\\b(NoopHostnameVerifier|ALLOW_ALL_HOSTNAME_VERIFIER)\\b/g;\n\n// Identifier-form JWT/JOSE signature algorithms (audit F7). The quoted-string\n// alg token (\"RS256\") is caught by the language-agnostic jwt-jose detector, but\n// the Java JWT libraries pass the alg as an IDENTIFIER, not a string literal:\n// jjwt's `SignatureAlgorithm.RS256` and auth0 java-jwt's `Algorithm.RSA256` /\n// `Algorithm.ECDSA256`. (\"SignatureAlgorithm\" has no word boundary before its\n// \"Algorithm\", so the auth0 branch cannot re-match the jjwt form.)\nconst RE_JAVA_JWT_ALG =\n  /\\bSignatureAlgorithm\\.(?:RS|PS|ES)(?:256|384|512)\\b|\\bAlgorithm\\.(?:RSA|ECDSA)(?:256|384|512)\\b/g;\n\n/* -------------------------------------------------------------------------- */\n/* Rule catalog                                                               */\n/* -------------------------------------------------------------------------- */\n\nconst RULE_JAVA_RSA: RuleMeta = {\n  id: \"java-rsa\",\n  title: \"Java RSA key/encryption\",\n  description: \"JCA RSA KeyPairGenerator / Cipher / KeyFactory\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical RSA (Java/JCA) is not quantum-safe and RSA encryption is HNDL-exposed.\",\n};\nconst RULE_JAVA_RSA_SIGN: RuleMeta = {\n  id: \"java-rsa-sign\",\n  title: \"Java RSA signature\",\n  description: 'JCA Signature.getInstance(\"…withRSA\")',\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical RSA signing (Java/JCA) is forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\",\n};\nconst RULE_JAVA_EC_KEYGEN: RuleMeta = {\n  id: \"java-ec-keygen\",\n  title: \"Java EC key generation\",\n  description: 'JCA KeyPairGenerator.getInstance(\"EC\")',\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Generates a classical EC key pair (Java/JCA). EC keys feed BOTH ECDSA signatures and ECDH key agreement; the ECDH path is harvest-now-decrypt-later exposed.\",\n  remediation:\n    \"For key agreement: hybrid X25519MLKEM768 (ML-KEM-768). For signatures: ML-DSA-65 (FIPS 204).\",\n};\nconst RULE_JAVA_ECDSA_SIGN: RuleMeta = {\n  id: \"java-ecdsa-sign\",\n  title: \"Java ECDSA signature\",\n  description: 'JCA Signature.getInstance(\"…withECDSA\")',\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical ECDSA signing (Java/JCA) is forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\",\n};\nconst RULE_JAVA_ECDH: RuleMeta = {\n  id: \"java-ecdh\",\n  title: \"Java ECDH key agreement\",\n  description: 'JCA KeyAgreement.getInstance(\"ECDH\")',\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Elliptic-curve Diffie-Hellman (Java/JCA) is broken by Shor's algorithm (harvest-now-decrypt-later).\",\n};\nconst RULE_JAVA_DSA: RuleMeta = {\n  id: \"java-dsa\",\n  title: \"Java DSA key/signature\",\n  description: \"JCA DSA KeyPairGenerator / Signature\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"DSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical DSA (Java/JCA) is deprecated and forgeable by a quantum attacker.\",\n  remediation: \"Rotate off DSA and migrate to ML-DSA-65 (FIPS 204).\",\n};\nconst RULE_JAVA_DH: RuleMeta = {\n  id: \"java-dh\",\n  title: \"Java Diffie-Hellman key exchange\",\n  description: \"JCA DiffieHellman KeyPairGenerator / KeyAgreement\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"DH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Finite-field Diffie-Hellman (Java/JCA) is broken by Shor's algorithm (harvest-now-decrypt-later).\",\n};\nconst RULE_JAVA_XDH: RuleMeta = {\n  id: \"java-xdh\",\n  title: \"Java X25519/X448 key agreement\",\n  description: \"JCA XDH / X25519 / X448 (KeyPairGenerator / KeyAgreement)\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X25519\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"X25519/X448 (Java/JCA) is modern but still classical key agreement — harvest-now-decrypt-later.\",\n};\nconst RULE_JAVA_EDDSA: RuleMeta = {\n  id: \"java-eddsa\",\n  title: \"Java Ed25519/Ed448 signature\",\n  description: \"JCA EdDSA / Ed25519 / Ed448\",\n  category: \"signature\",\n  severity: \"low\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Ed25519/Ed448 (Java/JCA) is a modern but still classical signature scheme.\",\n};\n// BouncyCastle lightweight-API rules for bare (Kotlin-form) constructor calls.\n// Split by family so X448 and X25519 report their own algorithm string (java-xdh\n// lumps both under \"X25519\"). Severity/CWE copied from the JCA siblings above.\nconst RULE_JAVA_BC_X448: RuleMeta = {\n  id: \"java-bc-x448\",\n  title: \"Java/Kotlin X448 key agreement (BouncyCastle lightweight API)\",\n  description: \"BouncyCastle X448KeyPairGenerator / X448Agreement / X448PrivateKeyParameters\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X448\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"X448 (Java/Kotlin, BouncyCastle lightweight API) is modern but still classical key agreement — harvest-now-decrypt-later.\",\n};\nconst RULE_JAVA_BC_X25519: RuleMeta = {\n  id: \"java-bc-x25519\",\n  title: \"Java/Kotlin X25519 key agreement (BouncyCastle lightweight API)\",\n  description: \"BouncyCastle X25519KeyPairGenerator / X25519Agreement\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X25519\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"X25519 (Java/Kotlin, BouncyCastle lightweight API) is modern but still classical key agreement — harvest-now-decrypt-later.\",\n};\nconst RULE_JAVA_BC_EDDSA: RuleMeta = {\n  id: \"java-bc-eddsa\",\n  title: \"Java/Kotlin Ed25519/Ed448 signature (BouncyCastle lightweight API)\",\n  description:\n    \"BouncyCastle Ed448KeyPairGenerator / Ed448Signer / Ed25519KeyPairGenerator / Ed25519Signer\",\n  category: \"signature\",\n  severity: \"low\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Ed25519/Ed448 (Java/Kotlin, BouncyCastle lightweight API) is a modern but still classical signature scheme.\",\n};\nconst RULE_JAVA_TLS_LEGACY: RuleMeta = {\n  id: \"java-tls-legacy-version\",\n  title: \"Legacy SSL/TLS version requested\",\n  description: 'SSLContext.getInstance(\"SSL\" | \"SSLv3\" | \"TLSv1\")',\n  category: \"tls\",\n  severity: \"medium\",\n  confidence: \"high\",\n  hndl: false,\n  cwe: CWE_WEAK_STRENGTH,\n  message: \"SSL/SSLv3/TLS 1.0 are deprecated and insecure (Java/JSSE); require TLS 1.3.\",\n  remediation: 'Use SSLContext.getInstance(\"TLSv1.3\") and prefer PQC-hybrid key exchange.',\n};\nconst RULE_JAVA_TLS_NOVERIFY: RuleMeta = {\n  id: \"java-tls-hostname-verification-disabled\",\n  title: \"TLS hostname verification disabled\",\n  description: \"NoopHostnameVerifier / ALLOW_ALL_HOSTNAME_VERIFIER\",\n  category: \"tls\",\n  severity: \"high\",\n  confidence: \"high\",\n  hndl: false,\n  cwe: CWE_CERT_VALIDATION,\n  message: \"An all-trusting hostname verifier (Java) disables TLS hostname checking (MITM risk).\",\n  remediation: \"Remove the all-trusting verifier; rely on the default hostname verifier.\",\n};\nconst RULE_JAVA_JWT_ALG: RuleMeta = {\n  id: \"java-jwt-alg\",\n  title: \"Java identifier-form JWT/JOSE algorithm\",\n  description: \"jjwt SignatureAlgorithm.RS/PS/ES* / auth0 Algorithm.RSA*/ECDSA*\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"unknown\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"A classical JWT/JOSE signature algorithm (Java, identifier form) is used, forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204); track IETF PQC JOSE/COSE algorithms\",\n};\n\n/**\n * Classify a `<factory>.getInstance(\"<alg>\")` pair into a rule, or null when the\n * algorithm is not classical asymmetric crypto (AES, HMAC, PBKDF2, hashes, …).\n * `alg` is normalised to upper-case with any Cipher transformation suffix\n * (`RSA/ECB/OAEPPadding` → `RSA`) stripped.\n */\nfunction classifyGetInstance(factory: string, rawAlg: string): RuleMeta | null {\n  const alg = rawAlg.split(\"/\")[0].trim().toUpperCase();\n  const isSignature = factory === \"Signature\";\n\n  if (alg.includes(\"ECDSA\")) return RULE_JAVA_ECDSA_SIGN;\n  if (alg.includes(\"ECDH\")) return RULE_JAVA_ECDH;\n  if (alg === \"EC\") return isSignature ? RULE_JAVA_ECDSA_SIGN : RULE_JAVA_EC_KEYGEN;\n  if (alg.includes(\"ED25519\") || alg.includes(\"ED448\") || alg.includes(\"EDDSA\"))\n    return RULE_JAVA_EDDSA;\n  if (alg.includes(\"X25519\") || alg.includes(\"X448\") || alg === \"XDH\") return RULE_JAVA_XDH;\n  // RSASSA-PSS is an RSA *signature* scheme, not encryption/KEM. The string\n  // contains \"RSA\", so it must be caught here — BEFORE the generic RSA branch\n  // below, which would otherwise (mis)classify it as HNDL-exposed RSA\n  // encryption (java-rsa / hndl:true). Signatures are hndl:false. (Fixes F8.)\n  if (alg.includes(\"PSS\")) return RULE_JAVA_RSA_SIGN;\n  if (alg.includes(\"RSA\")) return isSignature ? RULE_JAVA_RSA_SIGN : RULE_JAVA_RSA;\n  if (alg.includes(\"DSA\")) return RULE_JAVA_DSA; // ECDSA already handled above\n  if (alg.includes(\"DH\") || alg.includes(\"DIFFIEHELLMAN\")) return RULE_JAVA_DH;\n  return null;\n}\n\n/** BouncyCastle lightweight-API class name → rule. */\nconst BC_CLASS_RULES: Record<string, RuleMeta> = {\n  RSAKeyPairGenerator: RULE_JAVA_RSA,\n  DSAKeyPairGenerator: RULE_JAVA_DSA,\n  ECKeyPairGenerator: RULE_JAVA_EC_KEYGEN,\n  ECDSASigner: RULE_JAVA_ECDSA_SIGN,\n  Ed25519Signer: RULE_JAVA_EDDSA,\n  Ed448Signer: RULE_JAVA_EDDSA,\n  X25519Agreement: RULE_JAVA_XDH,\n  X448Agreement: RULE_JAVA_XDH,\n  ECDHBasicAgreement: RULE_JAVA_ECDH,\n  DHBasicAgreement: RULE_JAVA_DH,\n  X25519KeyPairGenerator: RULE_JAVA_XDH,\n  Ed25519KeyPairGenerator: RULE_JAVA_EDDSA,\n  RSAEngine: RULE_JAVA_RSA,\n  OAEPEncoding: RULE_JAVA_RSA,\n};\n\n/** BouncyCastle lightweight-API bare-constructor class name → family rule. */\nconst BC_CURVE_CLASS_RULES: Record<string, RuleMeta> = {\n  X448KeyPairGenerator: RULE_JAVA_BC_X448,\n  X448Agreement: RULE_JAVA_BC_X448,\n  X448PrivateKeyParameters: RULE_JAVA_BC_X448,\n  X25519KeyPairGenerator: RULE_JAVA_BC_X25519,\n  X25519Agreement: RULE_JAVA_BC_X25519,\n  Ed448KeyPairGenerator: RULE_JAVA_BC_EDDSA,\n  Ed448Signer: RULE_JAVA_BC_EDDSA,\n  Ed25519KeyPairGenerator: RULE_JAVA_BC_EDDSA,\n  Ed25519Signer: RULE_JAVA_BC_EDDSA,\n};\n\n/** Detects classical asymmetric crypto in Java / Kotlin (JCA + BouncyCastle). */\nexport const javaDetector: Detector = {\n  id: \"java-crypto\",\n  description: \"Classical asymmetric crypto in Java/Kotlin (JCA getInstance + BouncyCastle)\",\n  scope: \"source\",\n  language: \"java\",\n  rules: [\n    RULE_JAVA_RSA,\n    RULE_JAVA_RSA_SIGN,\n    RULE_JAVA_EC_KEYGEN,\n    RULE_JAVA_ECDSA_SIGN,\n    RULE_JAVA_ECDH,\n    RULE_JAVA_DSA,\n    RULE_JAVA_DH,\n    RULE_JAVA_XDH,\n    RULE_JAVA_EDDSA,\n    RULE_JAVA_BC_X448,\n    RULE_JAVA_BC_X25519,\n    RULE_JAVA_BC_EDDSA,\n    RULE_JAVA_TLS_LEGACY,\n    RULE_JAVA_TLS_NOVERIFY,\n    RULE_JAVA_JWT_ALG,\n  ],\n  appliesTo: (f) => hasExtension(f, JAVA_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const findings: Finding[] = [];\n\n    eachMatch(RE_JAVA_GETINSTANCE, content, (m) => {\n      const rule = classifyGetInstance(m[1], m[2]);\n      if (!rule) return; // symmetric / hashing algorithm — not our concern.\n      findings.push(\n        findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n      );\n    });\n\n    eachMatch(RE_JAVA_BC, content, (m) => {\n      const rule = BC_CLASS_RULES[m[1]];\n      if (!rule) return;\n      findings.push(\n        findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n      );\n    });\n\n    // BouncyCastle lightweight-API classes as a bare constructor call (Kotlin\n    // form, no `new`). RE_JAVA_BC_CURVE's negative lookbehind excludes the\n    // `new <Class>(` form already handled above, so this only adds the missed\n    // 448/25519 Kotlin-style matches — no double-counting.\n    eachMatch(RE_JAVA_BC_CURVE, content, (m) => {\n      const rule = BC_CURVE_CLASS_RULES[m[1]];\n      if (!rule) return;\n      findings.push(\n        findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n      );\n    });\n\n    // Legacy SSL/TLS protocol version requested from SSLContext.\n    eachMatch(RE_JAVA_TLS_LEGACY, content, (m) => {\n      findings.push(\n        findingFromRule(RULE_JAVA_TLS_LEGACY, {\n          file,\n          content,\n          index: m.index,\n          matchLength: m[0].length,\n        }),\n      );\n    });\n\n    // All-trusting hostname verifier — disables TLS hostname verification.\n    eachMatch(RE_JAVA_TLS_NOVERIFY, content, (m) => {\n      findings.push(\n        findingFromRule(RULE_JAVA_TLS_NOVERIFY, {\n          file,\n          content,\n          index: m.index,\n          matchLength: m[0].length,\n        }),\n      );\n    });\n\n    // Identifier-form JWT/JOSE signature algorithms (jjwt / auth0).\n    eachMatch(RE_JAVA_JWT_ALG, content, (m) => {\n      findings.push(\n        findingFromRule(RULE_JAVA_JWT_ALG, {\n          file,\n          content,\n          index: m.index,\n          matchLength: m[0].length,\n        }),\n      );\n    });\n\n    return findings;\n  },\n};\n"]}
+{"version":3,"file":"java.js","sourceRoot":"","sources":["../../src/detectors/java.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Source-code detector for classical, non-quantum-safe asymmetric cryptography\n * in Java / Kotlin (the JCA — Java Cryptography Architecture). Same lexical\n * strategy as the other language packs.\n *\n * The JCA funnels almost everything through a handful of factory methods keyed\n * by an ALGORITHM STRING: `KeyPairGenerator.getInstance(\"RSA\")`,\n * `Signature.getInstance(\"SHA256withECDSA\")`, `Cipher.getInstance(\"RSA/ECB/…\")`,\n * `KeyAgreement.getInstance(\"ECDH\")`. So detection here is two steps: match the\n * `<Factory>.getInstance(\"<alg>\")` call, then classify the (factory, alg) pair\n * into a rule. Symmetric / hashing algorithms (\"AES\", \"HmacSHA256\", …) classify\n * to nothing and are ignored. A small set of BouncyCastle lightweight-API class\n * names (`new ECDSASigner()`, `new X25519Agreement()`, …) is matched directly.\n *\n * HNDL policy mirrors the other detectors: KEM / key agreement (RSA encryption,\n * (EC)DH, X25519/X448) is harvest-now-decrypt-later exposed (hndl:true);\n * signatures (RSA/ECDSA/DSA/EdDSA) are hndl:false but forgeable by a quantum\n * attacker. `KeyPairGenerator.getInstance(\"EC\")` is ambiguous (an EC key feeds\n * both ECDSA and ECDH), so it is classified conservatively as\n * key-exchange-capable (hndl:true), exactly as the Node/Python EC keygen rules.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport { JAVA_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION, CWE_WEAK_STRENGTH } from \"../cwe.js\";\n\n/* -------------------------------------------------------------------------- */\n/* Regexes                                                                    */\n/* -------------------------------------------------------------------------- */\n\n// <Factory>.getInstance(\"<alg>\") — the JCA entry points that carry asymmetric\n// algorithms. KeyGenerator/MessageDigest/Mac are intentionally excluded (they\n// are symmetric / hashing only).\nconst RE_JAVA_GETINSTANCE =\n  /\\b(KeyPairGenerator|Signature|Cipher|KeyAgreement|KeyFactory)\\s*\\.\\s*getInstance\\s*\\(\\s*\"([^\"]+)\"/g;\n\n// BouncyCastle lightweight-API class instantiations.\nconst RE_JAVA_BC =\n  /\\bnew\\s+(RSAKeyPairGenerator|DSAKeyPairGenerator|ECKeyPairGenerator|ECDSASigner|Ed25519Signer|Ed448Signer|X25519Agreement|X448Agreement|ECDHBasicAgreement|DHBasicAgreement|X25519KeyPairGenerator|X448KeyPairGenerator|Ed25519KeyPairGenerator|Ed448KeyPairGenerator|X448PrivateKeyParameters|RSAEngine|OAEPEncoding)\\s*\\(/g;\n\n// BouncyCastle lightweight-API curve/EdDSA classes as a BARE constructor call —\n// the Kotlin form (`X448KeyPairGenerator()`, no `new` keyword). RE_JAVA_BC above\n// only matches the Java `new <Class>(` form, so Kotlin sources that drive the\n// lightweight API directly are missed. The negative lookbehind `(?<!\\bnew\\s+)`\n// keeps this additive: `new X448Agreement(` stays with RE_JAVA_BC (java-xdh),\n// while bare `X448Agreement(` routes to the family-specific rules below. Scoped\n// to the exact X448/X25519/Ed448/Ed25519 class names to stay precise.\nconst RE_JAVA_BC_CURVE =\n  /(?<!\\bnew\\s+)\\b(X448KeyPairGenerator|X448Agreement|X448PrivateKeyParameters|X25519KeyPairGenerator|X25519Agreement|Ed448KeyPairGenerator|Ed448Signer|Ed25519KeyPairGenerator|Ed25519Signer)\\s*\\(/g;\n\n// The non-curve BouncyCastle classes (RSA/EC/DSA/DH keygen, signers, engines) as a\n// BARE constructor call — the Kotlin form, `ECKeyPairGenerator()` with no `new`. Java\n// and Scala instantiate Java classes with `new` (caught by RE_JAVA_BC), so bare calls\n// to these distinctive class names are Kotlin. The `(?<!\\bnew\\s+)` avoids double-\n// counting the `new` form; routed through the same BC_CLASS_RULES map.\nconst RE_JAVA_BC_BARE =\n  /(?<!\\bnew\\s+)\\b(RSAKeyPairGenerator|DSAKeyPairGenerator|ECKeyPairGenerator|ECDSASigner|ECDHBasicAgreement|DHBasicAgreement|RSAEngine|OAEPEncoding)\\s*\\(/g;\n\n// Insecure JSSE / TLS configuration expressed in Java source. Mirrors the JS\n// tlsDetector in source.ts (category \"tls\"): a legacy SSL/TLS protocol version\n// requested from SSLContext, and TLS hostname verification neutered via an\n// all-trusting verifier (Apache HttpClient's NoopHostnameVerifier /\n// ALLOW_ALL_HOSTNAME_VERIFIER).\n// `TLSv1(?:\\.1)?` catches both TLS 1.0 and the equally-deprecated TLS 1.1 (RFC 8996),\n// mirroring the JS tlsDetector; the closing `\"` keeps `\"TLSv1.2\"`/`\"TLSv1.3\"`/`\"TLS\"`\n// from matching. `SSLv2` is included alongside `SSLv3`.\nconst RE_JAVA_TLS_LEGACY =\n  /\\bSSLContext\\s*\\.\\s*getInstance\\s*\\(\\s*\"(SSL|SSLv2|SSLv3|TLSv1(?:\\.1)?)\"/g;\n// Require a USAGE position, not a bare identifier: `NoopHostnameVerifier` followed by\n// `(` (construction) or `.` (`.INSTANCE`), and `ALLOW_ALL_HOSTNAME_VERIFIER` preceded\n// by `.` (member access). This keeps `new NoopHostnameVerifier()` and\n// `SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER` while dropping the common\n// false positive of a plain `import …NoopHostnameVerifier;` line.\nconst RE_JAVA_TLS_NOVERIFY = /\\bNoopHostnameVerifier\\s*[.(]|\\.\\s*ALLOW_ALL_HOSTNAME_VERIFIER\\b/g;\n\n// Identifier-form JWT/JOSE signature algorithms (audit F7). The quoted-string\n// alg token (\"RS256\") is caught by the language-agnostic jwt-jose detector, but\n// the Java JWT libraries pass the alg as an IDENTIFIER, not a string literal:\n// jjwt's `SignatureAlgorithm.RS256` and auth0 java-jwt's `Algorithm.RSA256` /\n// `Algorithm.ECDSA256`. (\"SignatureAlgorithm\" has no word boundary before its\n// \"Algorithm\", so the auth0 branch cannot re-match the jjwt form.)\nconst RE_JAVA_JWT_ALG =\n  /\\bSignatureAlgorithm\\.(?:RS|PS|ES)(?:256|384|512)\\b|\\bAlgorithm\\.(?:RSA|ECDSA)(?:256|384|512)\\b/g;\n\n/* -------------------------------------------------------------------------- */\n/* Rule catalog                                                               */\n/* -------------------------------------------------------------------------- */\n\nconst RULE_JAVA_RSA: RuleMeta = {\n  id: \"java-rsa\",\n  title: \"Java RSA key/encryption\",\n  description: \"JCA RSA KeyPairGenerator / Cipher / KeyFactory\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical RSA (Java/JCA) is not quantum-safe and RSA encryption is HNDL-exposed.\",\n};\nconst RULE_JAVA_RSA_SIGN: RuleMeta = {\n  id: \"java-rsa-sign\",\n  title: \"Java RSA signature\",\n  description: 'JCA Signature.getInstance(\"…withRSA\")',\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical RSA signing (Java/JCA) is forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\",\n};\nconst RULE_JAVA_EC_KEYGEN: RuleMeta = {\n  id: \"java-ec-keygen\",\n  title: \"Java EC key generation\",\n  description: 'JCA KeyPairGenerator.getInstance(\"EC\")',\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Generates a classical EC key pair (Java/JCA). EC keys feed BOTH ECDSA signatures and ECDH key agreement; the ECDH path is harvest-now-decrypt-later exposed.\",\n  remediation:\n    \"For key agreement: hybrid X25519MLKEM768 (ML-KEM-768). For signatures: ML-DSA-65 (FIPS 204).\",\n};\nconst RULE_JAVA_ECDSA_SIGN: RuleMeta = {\n  id: \"java-ecdsa-sign\",\n  title: \"Java ECDSA signature\",\n  description: 'JCA Signature.getInstance(\"…withECDSA\")',\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical ECDSA signing (Java/JCA) is forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\",\n};\nconst RULE_JAVA_ECDH: RuleMeta = {\n  id: \"java-ecdh\",\n  title: \"Java ECDH key agreement\",\n  description: 'JCA KeyAgreement.getInstance(\"ECDH\")',\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Elliptic-curve Diffie-Hellman (Java/JCA) is broken by Shor's algorithm (harvest-now-decrypt-later).\",\n};\nconst RULE_JAVA_DSA: RuleMeta = {\n  id: \"java-dsa\",\n  title: \"Java DSA key/signature\",\n  description: \"JCA DSA KeyPairGenerator / Signature\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"DSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical DSA (Java/JCA) is deprecated and forgeable by a quantum attacker.\",\n  remediation: \"Rotate off DSA and migrate to ML-DSA-65 (FIPS 204).\",\n};\nconst RULE_JAVA_DH: RuleMeta = {\n  id: \"java-dh\",\n  title: \"Java Diffie-Hellman key exchange\",\n  description: \"JCA DiffieHellman KeyPairGenerator / KeyAgreement\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"DH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Finite-field Diffie-Hellman (Java/JCA) is broken by Shor's algorithm (harvest-now-decrypt-later).\",\n};\nconst RULE_JAVA_XDH: RuleMeta = {\n  id: \"java-xdh\",\n  title: \"Java X25519/X448 key agreement\",\n  description: \"JCA XDH / X25519 / X448 (KeyPairGenerator / KeyAgreement)\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X25519\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"X25519/X448 (Java/JCA) is modern but still classical key agreement — harvest-now-decrypt-later.\",\n};\nconst RULE_JAVA_EDDSA: RuleMeta = {\n  id: \"java-eddsa\",\n  title: \"Java Ed25519/Ed448 signature\",\n  description: \"JCA EdDSA / Ed25519 / Ed448\",\n  category: \"signature\",\n  severity: \"low\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Ed25519/Ed448 (Java/JCA) is a modern but still classical signature scheme.\",\n};\n// BouncyCastle lightweight-API rules for bare (Kotlin-form) constructor calls.\n// Split by family so X448 and X25519 report their own algorithm string (java-xdh\n// lumps both under \"X25519\"). Severity/CWE copied from the JCA siblings above.\nconst RULE_JAVA_BC_X448: RuleMeta = {\n  id: \"java-bc-x448\",\n  title: \"Java/Kotlin X448 key agreement (BouncyCastle lightweight API)\",\n  description: \"BouncyCastle X448KeyPairGenerator / X448Agreement / X448PrivateKeyParameters\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X448\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"X448 (Java/Kotlin, BouncyCastle lightweight API) is modern but still classical key agreement — harvest-now-decrypt-later.\",\n};\nconst RULE_JAVA_BC_X25519: RuleMeta = {\n  id: \"java-bc-x25519\",\n  title: \"Java/Kotlin X25519 key agreement (BouncyCastle lightweight API)\",\n  description: \"BouncyCastle X25519KeyPairGenerator / X25519Agreement\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X25519\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"X25519 (Java/Kotlin, BouncyCastle lightweight API) is modern but still classical key agreement — harvest-now-decrypt-later.\",\n};\nconst RULE_JAVA_BC_EDDSA: RuleMeta = {\n  id: \"java-bc-eddsa\",\n  title: \"Java/Kotlin Ed25519/Ed448 signature (BouncyCastle lightweight API)\",\n  description:\n    \"BouncyCastle Ed448KeyPairGenerator / Ed448Signer / Ed25519KeyPairGenerator / Ed25519Signer\",\n  category: \"signature\",\n  severity: \"low\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Ed25519/Ed448 (Java/Kotlin, BouncyCastle lightweight API) is a modern but still classical signature scheme.\",\n};\nconst RULE_JAVA_TLS_LEGACY: RuleMeta = {\n  id: \"java-tls-legacy-version\",\n  title: \"Legacy SSL/TLS version requested\",\n  description: 'SSLContext.getInstance(\"SSL\" | \"SSLv3\" | \"TLSv1\")',\n  category: \"tls\",\n  severity: \"medium\",\n  confidence: \"high\",\n  hndl: false,\n  cwe: CWE_WEAK_STRENGTH,\n  message: \"SSL/SSLv3/TLS 1.0 are deprecated and insecure (Java/JSSE); require TLS 1.3.\",\n  remediation: 'Use SSLContext.getInstance(\"TLSv1.3\") and prefer PQC-hybrid key exchange.',\n};\nconst RULE_JAVA_TLS_NOVERIFY: RuleMeta = {\n  id: \"java-tls-hostname-verification-disabled\",\n  title: \"TLS hostname verification disabled\",\n  description: \"NoopHostnameVerifier / ALLOW_ALL_HOSTNAME_VERIFIER\",\n  category: \"tls\",\n  severity: \"high\",\n  confidence: \"high\",\n  hndl: false,\n  cwe: CWE_CERT_VALIDATION,\n  message: \"An all-trusting hostname verifier (Java) disables TLS hostname checking (MITM risk).\",\n  remediation: \"Remove the all-trusting verifier; rely on the default hostname verifier.\",\n};\nconst RULE_JAVA_JWT_ALG: RuleMeta = {\n  id: \"java-jwt-alg\",\n  title: \"Java identifier-form JWT/JOSE algorithm\",\n  description: \"jjwt SignatureAlgorithm.RS/PS/ES* / auth0 Algorithm.RSA*/ECDSA*\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"unknown\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"A classical JWT/JOSE signature algorithm (Java, identifier form) is used, forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204); track IETF PQC JOSE/COSE algorithms\",\n};\n\n/**\n * Classify a `<factory>.getInstance(\"<alg>\")` pair into a rule, or null when the\n * algorithm is not classical asymmetric crypto (AES, HMAC, PBKDF2, hashes, …).\n * `alg` is normalised to upper-case with any Cipher transformation suffix\n * (`RSA/ECB/OAEPPadding` → `RSA`) stripped.\n */\nfunction classifyGetInstance(factory: string, rawAlg: string): RuleMeta | null {\n  const alg = rawAlg.split(\"/\")[0].trim().toUpperCase();\n  const isSignature = factory === \"Signature\";\n\n  if (alg.includes(\"ECDSA\")) return RULE_JAVA_ECDSA_SIGN;\n  // ECIES (EC Integrated Encryption Scheme, incl. `ECIESwithAES-CBC`) is classical EC\n  // public-key ENCRYPTION — harvest-now-decrypt-later exposed. Checked before the EC\n  // branches below (which would otherwise miss it) and the RSA/DSA checks.\n  if (alg.includes(\"ECIES\")) return RULE_JAVA_ECDH;\n  if (alg.includes(\"ECDH\")) return RULE_JAVA_ECDH;\n  if (alg === \"EC\") return isSignature ? RULE_JAVA_ECDSA_SIGN : RULE_JAVA_EC_KEYGEN;\n  if (alg.includes(\"ED25519\") || alg.includes(\"ED448\") || alg.includes(\"EDDSA\"))\n    return RULE_JAVA_EDDSA;\n  if (alg.includes(\"X25519\") || alg.includes(\"X448\") || alg === \"XDH\") return RULE_JAVA_XDH;\n  // RSASSA-PSS is an RSA *signature* scheme, not encryption/KEM. The string\n  // contains \"RSA\", so it must be caught here — BEFORE the generic RSA branch\n  // below, which would otherwise (mis)classify it as HNDL-exposed RSA\n  // encryption (java-rsa / hndl:true). Signatures are hndl:false. (Fixes F8.)\n  if (alg.includes(\"PSS\")) return RULE_JAVA_RSA_SIGN;\n  if (alg.includes(\"RSA\")) return isSignature ? RULE_JAVA_RSA_SIGN : RULE_JAVA_RSA;\n  if (alg.includes(\"DSA\")) return RULE_JAVA_DSA; // ECDSA already handled above\n  if (alg.includes(\"DH\") || alg.includes(\"DIFFIEHELLMAN\")) return RULE_JAVA_DH;\n  return null;\n}\n\n/** BouncyCastle lightweight-API class name → rule. */\nconst BC_CLASS_RULES: Record<string, RuleMeta> = {\n  RSAKeyPairGenerator: RULE_JAVA_RSA,\n  DSAKeyPairGenerator: RULE_JAVA_DSA,\n  ECKeyPairGenerator: RULE_JAVA_EC_KEYGEN,\n  ECDSASigner: RULE_JAVA_ECDSA_SIGN,\n  Ed25519Signer: RULE_JAVA_EDDSA,\n  Ed448Signer: RULE_JAVA_EDDSA,\n  X25519Agreement: RULE_JAVA_XDH,\n  X448Agreement: RULE_JAVA_XDH,\n  ECDHBasicAgreement: RULE_JAVA_ECDH,\n  DHBasicAgreement: RULE_JAVA_DH,\n  X25519KeyPairGenerator: RULE_JAVA_XDH,\n  X448KeyPairGenerator: RULE_JAVA_XDH,\n  X448PrivateKeyParameters: RULE_JAVA_XDH,\n  Ed25519KeyPairGenerator: RULE_JAVA_EDDSA,\n  Ed448KeyPairGenerator: RULE_JAVA_EDDSA,\n  RSAEngine: RULE_JAVA_RSA,\n  OAEPEncoding: RULE_JAVA_RSA,\n};\n\n/** BouncyCastle lightweight-API bare-constructor class name → family rule. */\nconst BC_CURVE_CLASS_RULES: Record<string, RuleMeta> = {\n  X448KeyPairGenerator: RULE_JAVA_BC_X448,\n  X448Agreement: RULE_JAVA_BC_X448,\n  X448PrivateKeyParameters: RULE_JAVA_BC_X448,\n  X25519KeyPairGenerator: RULE_JAVA_BC_X25519,\n  X25519Agreement: RULE_JAVA_BC_X25519,\n  Ed448KeyPairGenerator: RULE_JAVA_BC_EDDSA,\n  Ed448Signer: RULE_JAVA_BC_EDDSA,\n  Ed25519KeyPairGenerator: RULE_JAVA_BC_EDDSA,\n  Ed25519Signer: RULE_JAVA_BC_EDDSA,\n};\n\n/** Detects classical asymmetric crypto in Java / Kotlin (JCA + BouncyCastle). */\nexport const javaDetector: Detector = {\n  id: \"java-crypto\",\n  description:\n    \"Classical asymmetric crypto on the JVM — Java/Kotlin/Scala (JCA getInstance + BouncyCastle)\",\n  scope: \"source\",\n  language: \"java\",\n  rules: [\n    RULE_JAVA_RSA,\n    RULE_JAVA_RSA_SIGN,\n    RULE_JAVA_EC_KEYGEN,\n    RULE_JAVA_ECDSA_SIGN,\n    RULE_JAVA_ECDH,\n    RULE_JAVA_DSA,\n    RULE_JAVA_DH,\n    RULE_JAVA_XDH,\n    RULE_JAVA_EDDSA,\n    RULE_JAVA_BC_X448,\n    RULE_JAVA_BC_X25519,\n    RULE_JAVA_BC_EDDSA,\n    RULE_JAVA_TLS_LEGACY,\n    RULE_JAVA_TLS_NOVERIFY,\n    RULE_JAVA_JWT_ALG,\n  ],\n  appliesTo: (f) => hasExtension(f, JAVA_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const findings: Finding[] = [];\n\n    eachMatch(RE_JAVA_GETINSTANCE, content, (m) => {\n      const rule = classifyGetInstance(m[1], m[2]);\n      if (!rule) return; // symmetric / hashing algorithm — not our concern.\n      findings.push(\n        findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n      );\n    });\n\n    eachMatch(RE_JAVA_BC, content, (m) => {\n      const rule = BC_CLASS_RULES[m[1]];\n      if (!rule) return;\n      findings.push(\n        findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n      );\n    });\n\n    // BouncyCastle lightweight-API classes as a bare constructor call (Kotlin\n    // form, no `new`). RE_JAVA_BC_CURVE's negative lookbehind excludes the\n    // `new <Class>(` form already handled above, so this only adds the missed\n    // 448/25519 Kotlin-style matches — no double-counting.\n    eachMatch(RE_JAVA_BC_CURVE, content, (m) => {\n      const rule = BC_CURVE_CLASS_RULES[m[1]];\n      if (!rule) return;\n      findings.push(\n        findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n      );\n    });\n\n    // Bare (Kotlin-form) constructor calls to the non-curve BC classes — same rules\n    // as the `new` form, routed via BC_CLASS_RULES.\n    eachMatch(RE_JAVA_BC_BARE, content, (m) => {\n      const rule = BC_CLASS_RULES[m[1]];\n      if (!rule) return;\n      findings.push(\n        findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n      );\n    });\n\n    // Legacy SSL/TLS protocol version requested from SSLContext.\n    eachMatch(RE_JAVA_TLS_LEGACY, content, (m) => {\n      findings.push(\n        findingFromRule(RULE_JAVA_TLS_LEGACY, {\n          file,\n          content,\n          index: m.index,\n          matchLength: m[0].length,\n        }),\n      );\n    });\n\n    // All-trusting hostname verifier — disables TLS hostname verification.\n    eachMatch(RE_JAVA_TLS_NOVERIFY, content, (m) => {\n      findings.push(\n        findingFromRule(RULE_JAVA_TLS_NOVERIFY, {\n          file,\n          content,\n          index: m.index,\n          matchLength: m[0].length,\n        }),\n      );\n    });\n\n    // Identifier-form JWT/JOSE signature algorithms (jjwt / auth0).\n    eachMatch(RE_JAVA_JWT_ALG, content, (m) => {\n      findings.push(\n        findingFromRule(RULE_JAVA_JWT_ALG, {\n          file,\n          content,\n          index: m.index,\n          matchLength: m[0].length,\n        }),\n      );\n    });\n\n    return findings;\n  },\n};\n"]}

package/dist/detectors/jose.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Config detector: classical KEY-MANAGEMENT (JWE) algorithms in JOSE. This is
+ * distinct from the JWS signature side (RS256/ES256, handled elsewhere) and from
+ * the JWK key-material detector: here we flag the `alg` values that wrap a
+ * content-encryption key with classical asymmetric crypto, because the encrypted
+ * payload is CONFIDENTIALITY — harvest-now-decrypt-later exposed. A JWE token
+ * captured today (from a log, an audit trail, a stored assertion) is decryptable
+ * once the wrapping key falls to a CRQC.
+ *
+ * Covered `alg` (RFC 7518 §4) values:
+ *  - `RSA-OAEP`, `RSA-OAEP-256`, `RSA1_5`  → RSA key encryption.
+ *  - `ECDH-ES`, `ECDH-ES+A128KW`, …        → classical EC Diffie-Hellman key agreement.
+ *
+ * These exact strings are JOSE identifiers, so a content-level match is precise;
+ * the detector applies to any file (config, JSON, source) after a fast reject.
+ */
+import type { Detector } from "../types.js";
+/** Detects classical JWE key-management (`alg`) values in JOSE tokens/config. */
+export declare const joseDetector: Detector;
+//# sourceMappingURL=jose.d.ts.map

package/dist/detectors/jose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jose.d.ts","sourceRoot":"","sources":["../../src/detectors/jose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAuD/D,iFAAiF;AACjF,eAAO,MAAM,YAAY,EAAE,QAqC1B,CAAC"}

package/dist/detectors/jose.js

@@ -0,0 +1,72 @@
+import { JWT_HOST_EXTENSIONS, DOC_EXTENSIONS, eachMatch, enclosingObject, findingFromRule, hasExtension, } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+const JOSE_RULES = [
+    {
+        re: /"alg"\s*:\s*"RSA(?:-OAEP(?:-256)?|1_5)"/g,
+        meta: {
+            id: "jose-jwe-rsa",
+            title: "JWE RSA key wrapping",
+            description: 'JWE "alg" of RSA-OAEP / RSA-OAEP-256 / RSA1_5 (RFC 7518)',
+            category: "kem",
+            severity: "high",
+            confidence: "high",
+            algorithm: "RSA",
+            hndl: true,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: "JWE wraps the content-encryption key with classical RSA (RSA-OAEP/RSA1_5); the encrypted payload is harvest-now-decrypt-later exposed.",
+            remediation: "Plan migration to a post-quantum KEM (ML-KEM-768) for key wrapping as JOSE/COSE PQ algorithms are standardised.",
+        },
+    },
+    {
+        re: /"alg"\s*:\s*"ECDH-ES(?:\+A\d{3}KW)?"/g,
+        meta: {
+            id: "jose-jwe-ecdh",
+            title: "JWE ECDH-ES key agreement",
+            description: 'JWE "alg" of ECDH-ES / ECDH-ES+A*KW (RFC 7518)',
+            category: "key-exchange",
+            severity: "high",
+            confidence: "high",
+            algorithm: "ECDH",
+            hndl: true,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: "JWE derives the content-encryption key via classical ECDH-ES; the encrypted payload is harvest-now-decrypt-later exposed.",
+            remediation: "Plan migration to hybrid post-quantum key agreement (X25519MLKEM768) as JOSE PQ algorithms are standardised.",
+        },
+    },
+];
+/** Detects classical JWE key-management (`alg`) values in JOSE tokens/config. */
+export const joseDetector = {
+    id: "jose-jwe-keymgmt",
+    description: "Classical JWE key-management algorithms (RSA-OAEP, ECDH-ES) — confidentiality, HNDL",
+    scope: "config",
+    language: "any",
+    rules: JOSE_RULES.map((r) => r.meta),
+    // Prose examples (a README showing `"alg":"RSA-OAEP"`) are not JOSE config. In the
+    // JS/TS/Python/Go/Ruby source files that source.ts's `jose-rsa-oaep`/`jose-ecdh-es`
+    // token rules actually cover (JWT_HOST_EXTENSIONS), defer to them to avoid a
+    // double-count — but STILL run on other source languages (Java/C#/Rust/PHP/Elixir/
+    // C/C++), which source.ts does not cover for these tokens.
+    appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS) && !hasExtension(f, JWT_HOST_EXTENSIONS),
+    detect({ file, content }) {
+        // Fast reject: no JOSE key-management alg token present.
+        if (!content.includes("RSA-OAEP") &&
+            !content.includes("RSA1_5") &&
+            !content.includes("ECDH-ES")) {
+            return [];
+        }
+        const findings = [];
+        for (const rule of JOSE_RULES) {
+            eachMatch(rule.re, content, (m) => {
+                // If this `alg` belongs to a JWK (a `"kty"` sits in the SAME object), the jwk
+                // detector already reports the key — defer so it isn't counted twice. Scoped
+                // to the enclosing object so an unrelated nearby JWK doesn't suppress a real
+                // standalone JWE header.
+                if (enclosingObject(content, m.index).includes('"kty"'))
+                    return;
+                findings.push(findingFromRule(rule.meta, { file, content, index: m.index, matchLength: m[0].length }));
+            });
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=jose.js.map

package/dist/detectors/jose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jose.js","sourceRoot":"","sources":["../../src/detectors/jose.ts"],"names":[],"mappings":"AAiBA,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,SAAS,EACT,eAAe,EACf,eAAe,EACf,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAO9C,MAAM,UAAU,GAAe;IAC7B;QACE,EAAE,EAAE,0CAA0C;QAC9C,IAAI,EAAE;YACJ,EAAE,EAAE,cAAc;YAClB,KAAK,EAAE,sBAAsB;YAC7B,WAAW,EAAE,0DAA0D;YACvE,QAAQ,EAAE,KAAK;YACf,QAAQ,EAAE,MAAM;YAChB,UAAU,EAAE,MAAM;YAClB,SAAS,EAAE,KAAK;YAChB,IAAI,EAAE,IAAI;YACV,GAAG,EAAE,iBAAiB;YACtB,OAAO,EACL,wIAAwI;YAC1I,WAAW,EACT,iHAAiH;SACpH;KACF;IACD;QACE,EAAE,EAAE,uCAAuC;QAC3C,IAAI,EAAE;YACJ,EAAE,EAAE,eAAe;YACnB,KAAK,EAAE,2BAA2B;YAClC,WAAW,EAAE,gDAAgD;YAC7D,QAAQ,EAAE,cAAc;YACxB,QAAQ,EAAE,MAAM;YAChB,UAAU,EAAE,MAAM;YAClB,SAAS,EAAE,MAAM;YACjB,IAAI,EAAE,IAAI;YACV,GAAG,EAAE,iBAAiB;YACtB,OAAO,EACL,2HAA2H;YAC7H,WAAW,EACT,8GAA8G;SACjH;KACF;CACF,CAAC;AAEF,iFAAiF;AACjF,MAAM,CAAC,MAAM,YAAY,GAAa;IACpC,EAAE,EAAE,kBAAkB;IACtB,WAAW,EACT,qFAAqF;IACvF,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE,KAAK;IACf,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACpC,mFAAmF;IACnF,oFAAoF;IACpF,6EAA6E;IAC7E,mFAAmF;IACnF,2DAA2D;IAC3D,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,mBAAmB,CAAC;IAC3F,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;QACtB,yDAAyD;QACzD,IACE,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;YAC7B,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC3B,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAC5B,CAAC;YACD,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,MAAM,QAAQ,GAAc,EAAE,CAAC;QAC/B,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;YAC9B,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE;gBAChC,8EAA8E;gBAC9E,6EAA6E;gBAC7E,6EAA6E;gBAC7E,yBAAyB;gBACzB,IAAI,eAAe,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;oBAAE,OAAO;gBAChE,QAAQ,CAAC,IAAI,CACX,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CACxF,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC","sourcesContent":["/**\n * Config detector: classical KEY-MANAGEMENT (JWE) algorithms in JOSE. This is\n * distinct from the JWS signature side (RS256/ES256, handled elsewhere) and from\n * the JWK key-material detector: here we flag the `alg` values that wrap a\n * content-encryption key with classical asymmetric crypto, because the encrypted\n * payload is CONFIDENTIALITY — harvest-now-decrypt-later exposed. A JWE token\n * captured today (from a log, an audit trail, a stored assertion) is decryptable\n * once the wrapping key falls to a CRQC.\n *\n * Covered `alg` (RFC 7518 §4) values:\n *  - `RSA-OAEP`, `RSA-OAEP-256`, `RSA1_5`  → RSA key encryption.\n *  - `ECDH-ES`, `ECDH-ES+A128KW`, …        → classical EC Diffie-Hellman key agreement.\n *\n * These exact strings are JOSE identifiers, so a content-level match is precise;\n * the detector applies to any file (config, JSON, source) after a fast reject.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport {\n  JWT_HOST_EXTENSIONS,\n  DOC_EXTENSIONS,\n  eachMatch,\n  enclosingObject,\n  findingFromRule,\n  hasExtension,\n} from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO } from \"../cwe.js\";\n\ninterface JoseRule {\n  re: RegExp;\n  meta: RuleMeta;\n}\n\nconst JOSE_RULES: JoseRule[] = [\n  {\n    re: /\"alg\"\\s*:\\s*\"RSA(?:-OAEP(?:-256)?|1_5)\"/g,\n    meta: {\n      id: \"jose-jwe-rsa\",\n      title: \"JWE RSA key wrapping\",\n      description: 'JWE \"alg\" of RSA-OAEP / RSA-OAEP-256 / RSA1_5 (RFC 7518)',\n      category: \"kem\",\n      severity: \"high\",\n      confidence: \"high\",\n      algorithm: \"RSA\",\n      hndl: true,\n      cwe: CWE_BROKEN_CRYPTO,\n      message:\n        \"JWE wraps the content-encryption key with classical RSA (RSA-OAEP/RSA1_5); the encrypted payload is harvest-now-decrypt-later exposed.\",\n      remediation:\n        \"Plan migration to a post-quantum KEM (ML-KEM-768) for key wrapping as JOSE/COSE PQ algorithms are standardised.\",\n    },\n  },\n  {\n    re: /\"alg\"\\s*:\\s*\"ECDH-ES(?:\\+A\\d{3}KW)?\"/g,\n    meta: {\n      id: \"jose-jwe-ecdh\",\n      title: \"JWE ECDH-ES key agreement\",\n      description: 'JWE \"alg\" of ECDH-ES / ECDH-ES+A*KW (RFC 7518)',\n      category: \"key-exchange\",\n      severity: \"high\",\n      confidence: \"high\",\n      algorithm: \"ECDH\",\n      hndl: true,\n      cwe: CWE_BROKEN_CRYPTO,\n      message:\n        \"JWE derives the content-encryption key via classical ECDH-ES; the encrypted payload is harvest-now-decrypt-later exposed.\",\n      remediation:\n        \"Plan migration to hybrid post-quantum key agreement (X25519MLKEM768) as JOSE PQ algorithms are standardised.\",\n    },\n  },\n];\n\n/** Detects classical JWE key-management (`alg`) values in JOSE tokens/config. */\nexport const joseDetector: Detector = {\n  id: \"jose-jwe-keymgmt\",\n  description:\n    \"Classical JWE key-management algorithms (RSA-OAEP, ECDH-ES) — confidentiality, HNDL\",\n  scope: \"config\",\n  language: \"any\",\n  rules: JOSE_RULES.map((r) => r.meta),\n  // Prose examples (a README showing `\"alg\":\"RSA-OAEP\"`) are not JOSE config. In the\n  // JS/TS/Python/Go/Ruby source files that source.ts's `jose-rsa-oaep`/`jose-ecdh-es`\n  // token rules actually cover (JWT_HOST_EXTENSIONS), defer to them to avoid a\n  // double-count — but STILL run on other source languages (Java/C#/Rust/PHP/Elixir/\n  // C/C++), which source.ts does not cover for these tokens.\n  appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS) && !hasExtension(f, JWT_HOST_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    // Fast reject: no JOSE key-management alg token present.\n    if (\n      !content.includes(\"RSA-OAEP\") &&\n      !content.includes(\"RSA1_5\") &&\n      !content.includes(\"ECDH-ES\")\n    ) {\n      return [];\n    }\n    const findings: Finding[] = [];\n    for (const rule of JOSE_RULES) {\n      eachMatch(rule.re, content, (m) => {\n        // If this `alg` belongs to a JWK (a `\"kty\"` sits in the SAME object), the jwk\n        // detector already reports the key — defer so it isn't counted twice. Scoped\n        // to the enclosing object so an unrelated nearby JWK doesn't suppress a real\n        // standalone JWE header.\n        if (enclosingObject(content, m.index).includes('\"kty\"')) return;\n        findings.push(\n          findingFromRule(rule.meta, { file, content, index: m.index, matchLength: m[0].length }),\n        );\n      });\n    }\n    return findings;\n  },\n};\n"]}