@quantakrypto/core 0.2.2 → 0.4.0

package/dist/detectors/source.js

@@ -1,28 +1,36 @@
-import { JS_TS_EXTENSIONS, eachMatch, hasExtension, makeFinding, nearSortedCall, } from "../detect-utils.js";
+import { JS_TS_EXTENSIONS, JWT_HOST_EXTENSIONS, eachMatch, findingFromRule, hasExtension, nearSortedCall, } from "../detect-utils.js";
 import { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION, CWE_WEAK_STRENGTH } from "../cwe.js";
 /* -------------------------------------------------------------------------- */
 /* Precompiled regexes (module scope — never recreated per file)              */
 /* -------------------------------------------------------------------------- */
-const RE_GENERATE_KEYPAIR = /generateKeyPair(?:Sync)?\s*\(\s*['"`](rsa|ec|dsa|dh|x25519|x448|ed25519|ed448)['"`]/g;
+// `rsa-pss` is listed before `rsa` so the alternation consumes the full token
+// (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;
 const RE_CREATE_SIGN_VERIFY = /create(?:Sign|Verify)\s*\(/g;
-// One-shot crypto.sign/verify(algorithm, data, key). Anchored so it doesn't
-// fire inside identifiers like `assign(` or `createSign(` (which the dedicated
-// createSign/createVerify rule handles). The first argument is either a quoted
-// digest-algorithm string (RSA/ECDSA) or `null` — Node's EdDSA one-shot form is
-// `crypto.sign(null, data, edKey)`, which must still be detected.
-const RE_ONESHOT_SIGN_VERIFY = /(?:^|[^.\w])(?:crypto\.)?(sign|verify)\s*\(\s*(?:['"`][\w.-]+['"`]|null)\s*,/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) —
+// consuming the preceding char used to push the match onto the previous line,
+// corrupting the reported line/snippet and SARIF/baseline fingerprints. The
+// first argument is either a quoted digest-algorithm string (RSA/ECDSA) or
+// `null` — Node's EdDSA one-shot form is `crypto.sign(null, data, edKey)`.
+const RE_ONESHOT_SIGN_VERIFY = /(?<![.\w])(?:crypto\.)?(sign|verify)\s*\(\s*(?:['"`][\w.-]+['"`]|null)\s*,/g;
 const RE_CREATE_DH = /createDiffieHellman(?:Group)?\s*\(/g;
 const RE_GET_DH = /getDiffieHellman\s*\(\s*['"`](modp\d+)['"`]\s*\)/g;
 const RE_CREATE_ECDH = /createECDH\s*\(/g;
 const RE_RSA_ENCRYPT = /(?:crypto\.)?(?:publicEncrypt|privateDecrypt)\s*\(/g;
 const RE_DH_KEYOBJECT = /(?:crypto\.)?diffieHellman\s*\(\s*\{/g;
-// WebCrypto.
-const RE_WEBCRYPTO_ALGO = /\b(RSA-OAEP|RSA-PSS|RSASSA-PKCS1-v1_5|ECDH|ECDSA)\b/gi;
+// WebCrypto. Includes the newer curve algorithms (Ed25519/Ed448 signatures,
+// X25519/X448 key agreement) shipping in modern SubtleCrypto implementations.
+const RE_WEBCRYPTO_ALGO = /\b(RSA-OAEP|RSA-PSS|RSASSA-PKCS1-v1_5|ECDH|ECDSA|Ed25519|Ed448|X25519|X448)\b/gi;
 const RE_SUBTLE_CALL = /subtle\s*\.\s*(generateKey|importKey|exportKey|deriveKey|deriveBits|sign|verify|encrypt|decrypt|wrapKey|unwrapKey)\s*\(/g;
 // Libraries.
 const RE_FORGE_RSA = /pki\.rsa\.generateKeyPair\s*\(/g;
 const RE_FORGE_ED25519 = /forge\.ed25519\b/g;
-const RE_ELLIPTIC_EC = /new\s+(?:elliptic\.)?ec\s*\(/gi;
+// Require a curve-like first argument so `new EC("request-scope")` (a non-crypto
+// `EC` class) is not flagged; the elliptic library is always constructed with a
+// named curve (`new EC('secp256k1')`, `new EC('p256')`, …).
+const RE_ELLIPTIC_EC = /new\s+(?:elliptic\.)?ec\s*\(\s*['"`](?:sec[pt]|prime|nistp|curve|ed25519|ed448|brainpool|p-?(?:192|224|256|384|521)|x25519|x448)/gi;
 const RE_JSRSASIGN_KEYGEN = /KEYUTIL\.generateKeypair\s*\(/g;
 const RE_JSRSASIGN_SIGN = /KJUR\.crypto\.(?:Signature|ECDSA)\b/g;
 const RE_NODE_RSA = /new\s+NodeRSA\s*\(/g;
@@ -42,21 +50,144 @@ const RE_TLS_WEAK_CIPHER = /ciphers\s*:\s*['"`][^'"`\n]{0,256}?\b(RC4|DES|3DES|M
 /* -------------------------------------------------------------------------- */
 /* Node.js `crypto` module                                                    */
 /* -------------------------------------------------------------------------- */
+/**
+ * Rule catalog for the Node `crypto` detector. `node-crypto-keygen` and
+ * `node-crypto-dh-modp` refine some fields per match; the rest emit findings
+ * straight from these declarations.
+ */
+const RULE_NODE_KEYGEN = {
+    id: "node-crypto-keygen",
+    title: "Classical key generation",
+    description: "crypto.generateKeyPair(Sync)('rsa'|'ec'|'dsa'|'dh'|…)",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "unknown",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Generates a classical asymmetric key pair, which is not quantum-safe.",
+};
+const RULE_NODE_SIGN = {
+    id: "node-crypto-sign",
+    title: "Classical signature (createSign/createVerify)",
+    description: "crypto.createSign / crypto.createVerify",
+    category: "signature",
+    severity: "high",
+    confidence: "medium",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Uses createSign/createVerify, typically RSA, ECDSA or DSA — all forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+};
+const RULE_NODE_SIGN_ONESHOT = {
+    id: "node-crypto-sign-oneshot",
+    title: "Classical one-shot signature (crypto.sign/verify)",
+    description: "one-shot crypto.sign / crypto.verify (Node ≥ 12)",
+    category: "signature",
+    severity: "high",
+    confidence: "medium",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Uses the one-shot crypto.sign/crypto.verify API, typically RSA/ECDSA/EdDSA — forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+};
+const RULE_NODE_DH = {
+    id: "node-crypto-dh",
+    title: "Diffie-Hellman key exchange",
+    description: "crypto.createDiffieHellman(Group)",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "DH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Finite-field Diffie-Hellman is broken by Shor's algorithm (harvest-now-decrypt-later).",
+};
+const RULE_NODE_DH_MODP = {
+    id: "node-crypto-dh-modp",
+    title: "Diffie-Hellman MODP group",
+    description: "crypto.getDiffieHellman('modpN')",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "DH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Named finite-field DH MODP group is broken by Shor's algorithm (harvest-now-decrypt-later).",
+};
+const RULE_NODE_ECDH = {
+    id: "node-crypto-ecdh",
+    title: "ECDH key exchange",
+    description: "crypto.createECDH",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Elliptic-curve Diffie-Hellman is broken by Shor's algorithm (harvest-now-decrypt-later).",
+};
+const RULE_NODE_RSA_ENCRYPT = {
+    id: "node-crypto-rsa-encrypt",
+    title: "RSA public-key encryption",
+    description: "crypto.publicEncrypt / crypto.privateDecrypt",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "RSA public-key encryption is broken by Shor's algorithm and exposed to harvest-now-decrypt-later.",
+};
+const RULE_NODE_DH_KEYOBJECT = {
+    id: "node-crypto-dh-keyobject",
+    title: "Diffie-Hellman (KeyObject) key exchange",
+    description: "crypto.diffieHellman({ privateKey, publicKey })",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "crypto.diffieHellman() performs a classical (EC)DH agreement (harvest-now-decrypt-later).",
+};
 /** Detects classical asymmetric usage from Node's built-in `crypto` module. */
 const nodeCryptoDetector = {
     id: "node-crypto",
     description: "Classical asymmetric crypto via the Node.js `crypto` module",
     scope: "source",
     language: "js",
+    rules: [
+        RULE_NODE_KEYGEN,
+        RULE_NODE_SIGN,
+        RULE_NODE_SIGN_ONESHOT,
+        RULE_NODE_DH,
+        RULE_NODE_DH_MODP,
+        RULE_NODE_ECDH,
+        RULE_NODE_RSA_ENCRYPT,
+        RULE_NODE_DH_KEYOBJECT,
+    ],
     appliesTo: (f) => hasExtension(f, JS_TS_EXTENSIONS),
     detect({ file, content }) {
         const findings = [];
-        const push = (spec, m) => findings.push(makeFinding({ ...spec, file, content, index: m.index, matchLength: m[0].length }));
         // generateKeyPair(Sync)('rsa' | 'ec' | 'dsa' | 'dh' | 'x25519' | 'ed25519', ...)
         eachMatch(RE_GENERATE_KEYPAIR, content, (m) => {
             const type = m[1].toLowerCase();
             const map = {
                 rsa: { algo: "RSA", cat: "kem", sev: "high", hndl: true, label: "RSA" },
+                // RSA-PSS is signature-only, so classify it as a (forgeable) signature
+                // rather than a KEM — no HNDL confidentiality exposure.
+                "rsa-pss": {
+                    algo: "RSA",
+                    cat: "signature",
+                    sev: "high",
+                    hndl: false,
+                    label: "RSA-PSS",
+                    message: "Generates a classical RSA-PSS signing key, which is forgeable by a quantum attacker.",
+                    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+                },
                 // EC keys feed BOTH ECDSA (sign) and ECDH (key agreement). ECDH is
                 // HNDL-exposed, so classify conservatively as key-exchange-capable and
                 // surface both concerns rather than asserting signature-only (P0-4).
@@ -78,119 +209,72 @@ const nodeCryptoDetector = {
                 ed448: { algo: "EdDSA", cat: "signature", sev: "low", hndl: false, label: "Ed448" },
             };
             const info = map[type];
-            push({
-                ruleId: "node-crypto-keygen",
+            findings.push(findingFromRule(RULE_NODE_KEYGEN, { file, content, index: m.index, matchLength: m[0].length }, {
                 title: `${info.label} key generation`,
                 category: info.cat,
                 severity: info.sev,
-                confidence: "high",
                 algorithm: info.algo,
                 hndl: info.hndl,
-                cwe: CWE_BROKEN_CRYPTO,
                 message: info.message ??
                     `Generates a classical ${info.label} key pair, which is not quantum-safe.`,
                 ...(info.remediation ? { remediation: info.remediation } : {}),
-            }, m);
+            }));
         });
         // createSign / createVerify — RSA / ECDSA / DSA signatures.
         eachMatch(RE_CREATE_SIGN_VERIFY, content, (m) => {
-            push({
-                ruleId: "node-crypto-sign",
-                title: "Classical signature (createSign/createVerify)",
-                category: "signature",
-                severity: "high",
-                confidence: "medium",
-                algorithm: "unknown",
-                hndl: false,
-                cwe: CWE_BROKEN_CRYPTO,
-                message: "Uses createSign/createVerify, typically RSA, ECDSA or DSA — all forgeable by a quantum attacker.",
-                remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
-            }, m);
+            findings.push(findingFromRule(RULE_NODE_SIGN, {
+                file,
+                content,
+                index: m.index,
+                matchLength: m[0].length,
+            }));
         });
         // One-shot crypto.sign(algorithm, data, key) / crypto.verify(...) (Node ≥ 12).
         eachMatch(RE_ONESHOT_SIGN_VERIFY, content, (m) => {
-            push({
-                ruleId: "node-crypto-sign-oneshot",
-                title: "Classical one-shot signature (crypto.sign/verify)",
-                category: "signature",
-                severity: "high",
-                confidence: "medium",
-                algorithm: "unknown",
-                hndl: false,
-                cwe: CWE_BROKEN_CRYPTO,
-                message: "Uses the one-shot crypto.sign/crypto.verify API, typically RSA/ECDSA/EdDSA — forgeable by a quantum attacker.",
-                remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
-            }, m);
+            findings.push(findingFromRule(RULE_NODE_SIGN_ONESHOT, {
+                file,
+                content,
+                index: m.index,
+                matchLength: m[0].length,
+            }));
         });
         // createDiffieHellman / createDiffieHellmanGroup — finite-field DH key exchange.
         eachMatch(RE_CREATE_DH, content, (m) => {
-            push({
-                ruleId: "node-crypto-dh",
-                title: "Diffie-Hellman key exchange",
-                category: "key-exchange",
-                severity: "high",
-                confidence: "high",
-                algorithm: "DH",
-                hndl: true,
-                cwe: CWE_BROKEN_CRYPTO,
-                message: "Finite-field Diffie-Hellman is broken by Shor's algorithm (harvest-now-decrypt-later).",
-            }, m);
+            findings.push(findingFromRule(RULE_NODE_DH, { file, content, index: m.index, matchLength: m[0].length }));
         });
         // getDiffieHellman('modpN') — named built-in finite-field MODP groups.
         eachMatch(RE_GET_DH, content, (m) => {
-            push({
-                ruleId: "node-crypto-dh-modp",
+            findings.push(findingFromRule(RULE_NODE_DH_MODP, { file, content, index: m.index, matchLength: m[0].length }, {
                 title: `Diffie-Hellman MODP group (${m[1]})`,
-                category: "key-exchange",
-                severity: "high",
-                confidence: "high",
-                algorithm: "DH",
-                hndl: true,
-                cwe: CWE_BROKEN_CRYPTO,
                 message: `Named finite-field DH MODP group "${m[1]}" is broken by Shor's algorithm (harvest-now-decrypt-later).`,
-            }, m);
+            }));
         });
         // createECDH — elliptic-curve Diffie-Hellman key exchange.
         eachMatch(RE_CREATE_ECDH, content, (m) => {
-            push({
-                ruleId: "node-crypto-ecdh",
-                title: "ECDH key exchange",
-                category: "key-exchange",
-                severity: "high",
-                confidence: "high",
-                algorithm: "ECDH",
-                hndl: true,
-                cwe: CWE_BROKEN_CRYPTO,
-                message: "Elliptic-curve Diffie-Hellman is broken by Shor's algorithm (harvest-now-decrypt-later).",
-            }, m);
+            findings.push(findingFromRule(RULE_NODE_ECDH, {
+                file,
+                content,
+                index: m.index,
+                matchLength: m[0].length,
+            }));
         });
         // publicEncrypt / privateDecrypt — RSA encryption (KEM-like confidentiality).
         eachMatch(RE_RSA_ENCRYPT, content, (m) => {
-            push({
-                ruleId: "node-crypto-rsa-encrypt",
-                title: "RSA public-key encryption",
-                category: "kem",
-                severity: "high",
-                confidence: "high",
-                algorithm: "RSA",
-                hndl: true,
-                cwe: CWE_BROKEN_CRYPTO,
-                message: "RSA public-key encryption is broken by Shor's algorithm and exposed to harvest-now-decrypt-later.",
-            }, m);
+            findings.push(findingFromRule(RULE_NODE_RSA_ENCRYPT, {
+                file,
+                content,
+                index: m.index,
+                matchLength: m[0].length,
+            }));
         });
         // diffieHellman({ privateKey, publicKey }) — KeyObject-based DH/ECDH.
         eachMatch(RE_DH_KEYOBJECT, content, (m) => {
-            push({
-                ruleId: "node-crypto-dh-keyobject",
-                title: "Diffie-Hellman (KeyObject) key exchange",
-                category: "key-exchange",
-                severity: "high",
-                confidence: "high",
-                algorithm: "ECDH",
-                hndl: true,
-                cwe: CWE_BROKEN_CRYPTO,
-                message: "crypto.diffieHellman() performs a classical (EC)DH agreement (harvest-now-decrypt-later).",
-            }, m);
+            findings.push(findingFromRule(RULE_NODE_DH_KEYOBJECT, {
+                file,
+                content,
+                index: m.index,
+                matchLength: m[0].length,
+            }));
         });
         return findings;
     },
@@ -198,6 +282,18 @@ const nodeCryptoDetector = {
 /* -------------------------------------------------------------------------- */
 /* WebCrypto (SubtleCrypto)                                                    */
 /* -------------------------------------------------------------------------- */
+const RULE_WEBCRYPTO = {
+    id: "webcrypto-classical",
+    title: "WebCrypto classical algorithm",
+    description: "classical asymmetric algorithm passed to SubtleCrypto",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "A classical asymmetric WebCrypto algorithm is used, which is not quantum-safe.",
+};
 /**
  * Detects classical algorithms passed to WebCrypto's SubtleCrypto methods. The
  * algorithm name can appear as a bare string ("RSA-OAEP") or as
@@ -208,6 +304,7 @@ const webCryptoDetector = {
     description: "Classical asymmetric algorithms via WebCrypto SubtleCrypto",
     scope: "source",
     language: "js",
+    rules: [RULE_WEBCRYPTO],
     appliesTo: (f) => hasExtension(f, JS_TS_EXTENSIONS),
     detect({ file, content }) {
         const findings = [];
@@ -222,29 +319,47 @@ const webCryptoDetector = {
             if (!nearSortedCall(callIndexes, m.index, 400))
                 return;
             const name = m[1].toUpperCase();
-            const isKem = name === "RSA-OAEP";
-            const isEcdh = name === "ECDH";
-            const algorithm = name.startsWith("RSA")
-                ? "RSA"
-                : isEcdh
-                    ? "ECDH"
-                    : "ECDSA";
-            const category = isEcdh ? "key-exchange" : isKem ? "kem" : "signature";
-            const hndl = isKem || isEcdh;
-            findings.push(makeFinding({
-                ruleId: "webcrypto-classical",
+            // Classify by algorithm: RSA-OAEP is KEM (HNDL); ECDH/X25519/X448 are key
+            // agreement (HNDL); RSA-PSS/RSASSA/ECDSA/Ed25519/Ed448 are signatures.
+            let algorithm;
+            let category;
+            let hndl;
+            let severity;
+            if (name.startsWith("RSA")) {
+                algorithm = "RSA";
+                const isKem = name === "RSA-OAEP";
+                category = isKem ? "kem" : "signature";
+                hndl = isKem;
+            }
+            else if (name === "ECDH") {
+                algorithm = "ECDH";
+                category = "key-exchange";
+                hndl = true;
+            }
+            else if (name === "X25519" || name === "X448") {
+                algorithm = name === "X448" ? "X448" : "X25519";
+                category = "key-exchange";
+                hndl = true;
+                severity = "low"; // modern but classical
+            }
+            else if (name === "ED25519" || name === "ED448") {
+                algorithm = "EdDSA";
+                category = "signature";
+                hndl = false;
+                severity = "low";
+            }
+            else {
+                algorithm = "ECDSA";
+                category = "signature";
+                hndl = false;
+            }
+            findings.push(findingFromRule(RULE_WEBCRYPTO, { file, content, index: m.index, matchLength: m[0].length }, {
                 title: `WebCrypto ${m[1]}`,
                 category,
-                severity: "high",
-                confidence: "high",
                 algorithm,
                 hndl,
-                cwe: CWE_BROKEN_CRYPTO,
+                ...(severity ? { severity } : {}),
                 message: `WebCrypto algorithm "${m[1]}" is classical asymmetric crypto and not quantum-safe.`,
-                file,
-                content,
-                index: m.index,
-                matchLength: m[0].length,
             }));
         });
         return findings;
@@ -253,108 +368,151 @@ const webCryptoDetector = {
 /* -------------------------------------------------------------------------- */
 /* Popular crypto libraries                                                    */
 /* -------------------------------------------------------------------------- */
+const RULE_FORGE_RSA = {
+    id: "forge-rsa-keygen",
+    title: "node-forge RSA key generation",
+    description: "node-forge pki.rsa.generateKeyPair",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "node-forge generates a classical RSA key pair, which is not quantum-safe.",
+};
+const RULE_FORGE_ED25519 = {
+    id: "forge-ed25519",
+    title: "node-forge Ed25519 usage",
+    description: "node-forge forge.ed25519.*",
+    category: "signature",
+    severity: "low",
+    confidence: "high",
+    algorithm: "EdDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "node-forge Ed25519 is a modern but still classical signature scheme.",
+};
+const RULE_ELLIPTIC_EC = {
+    id: "elliptic-ec",
+    title: "elliptic curve instantiation",
+    description: "the `elliptic` library — new EC(...)",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "The `elliptic` library implements classical ECDSA/ECDH, both broken by Shor's algorithm.",
+};
+const RULE_SECP256K1 = {
+    id: "secp256k1-usage",
+    title: "secp256k1 ECDSA/ECDH usage",
+    description: "direct @noble/secp256k1-style API usage",
+    category: "signature",
+    severity: "high",
+    confidence: "medium",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Direct secp256k1 usage (ECDSA signatures / ECDH agreement) is classical and broken by Shor's algorithm.",
+    remediation: "ML-DSA-65 (FIPS 204) for signatures; hybrid X25519MLKEM768 for key agreement.",
+};
+const RULE_JSRSASIGN_KEYGEN = {
+    id: "jsrsasign-keygen",
+    title: "jsrsasign key generation",
+    description: "jsrsasign KEYUTIL.generateKeypair",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "jsrsasign generates classical RSA/EC key pairs, which are not quantum-safe.",
+    remediation: "ML-KEM-768 (FIPS 203) / ML-DSA-65 (FIPS 204)",
+};
+const RULE_JSRSASIGN_SIGN = {
+    id: "jsrsasign-sign",
+    title: "jsrsasign signature",
+    description: "jsrsasign KJUR.crypto.Signature / ECDSA",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "jsrsasign signing uses classical RSA/ECDSA signatures, forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204)",
+};
+const RULE_NODE_RSA_LIB = {
+    id: "node-rsa",
+    title: "node-rsa key/usage",
+    description: "the `node-rsa` library — new NodeRSA(...)",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "node-rsa wraps classical RSA encryption/signing, which is not quantum-safe.",
+};
 /** Detects classical crypto from popular npm libraries used in source. */
 const libraryDetector = {
     id: "crypto-libs",
     description: "Classical asymmetric crypto via node-forge, elliptic, jsrsasign, node-rsa",
     scope: "source",
     language: "js",
+    rules: [
+        RULE_FORGE_RSA,
+        RULE_FORGE_ED25519,
+        RULE_ELLIPTIC_EC,
+        RULE_SECP256K1,
+        RULE_JSRSASIGN_KEYGEN,
+        RULE_JSRSASIGN_SIGN,
+        RULE_NODE_RSA_LIB,
+    ],
     appliesTo: (f) => hasExtension(f, JS_TS_EXTENSIONS),
     detect({ file, content }) {
         const findings = [];
-        const add = (re, spec) => eachMatch(re, content, (m) => findings.push(makeFinding({ ...spec, file, content, index: m.index, matchLength: m[0].length })));
-        // node-forge: pki.rsa.generateKeyPair(...)
-        add(RE_FORGE_RSA, {
-            ruleId: "forge-rsa-keygen",
-            title: "node-forge RSA key generation",
-            category: "kem",
-            severity: "high",
-            confidence: "high",
-            algorithm: "RSA",
-            hndl: true,
-            cwe: CWE_BROKEN_CRYPTO,
-            message: "node-forge generates a classical RSA key pair, which is not quantum-safe.",
-        });
-        // node-forge: forge.ed25519.* (classical EdDSA)
-        add(RE_FORGE_ED25519, {
-            ruleId: "forge-ed25519",
-            title: "node-forge Ed25519 usage",
-            category: "signature",
-            severity: "low",
-            confidence: "high",
-            algorithm: "EdDSA",
-            hndl: false,
-            cwe: CWE_BROKEN_CRYPTO,
-            message: "node-forge Ed25519 is a modern but still classical signature scheme.",
-        });
-        // elliptic: new EC('secp256k1') / new ec(...)
-        add(RE_ELLIPTIC_EC, {
-            ruleId: "elliptic-ec",
-            title: "elliptic curve instantiation",
-            category: "signature",
-            severity: "high",
-            confidence: "high",
-            algorithm: "ECDSA",
-            hndl: false,
-            cwe: CWE_BROKEN_CRYPTO,
-            message: "The `elliptic` library implements classical ECDSA/ECDH, both broken by Shor's algorithm.",
-        });
-        // Direct secp256k1 API usage: secp.sign / getPublicKey / getSharedSecret.
-        add(RE_SECP256K1, {
-            ruleId: "secp256k1-usage",
-            title: "secp256k1 ECDSA/ECDH usage",
-            category: "signature",
-            severity: "high",
-            confidence: "medium",
-            algorithm: "ECDSA",
-            hndl: false,
-            cwe: CWE_BROKEN_CRYPTO,
-            message: "Direct secp256k1 usage (ECDSA signatures / ECDH agreement) is classical and broken by Shor's algorithm.",
-            remediation: "ML-DSA-65 (FIPS 204) for signatures; hybrid X25519MLKEM768 for key agreement.",
-        });
-        // jsrsasign: KEYUTIL.generateKeypair('RSA'|'EC', ...) or KJUR.crypto.*
-        add(RE_JSRSASIGN_KEYGEN, {
-            ruleId: "jsrsasign-keygen",
-            title: "jsrsasign key generation",
-            category: "signature",
-            severity: "high",
-            confidence: "high",
-            algorithm: "unknown",
-            hndl: false,
-            cwe: CWE_BROKEN_CRYPTO,
-            message: "jsrsasign generates classical RSA/EC key pairs, which are not quantum-safe.",
-            remediation: "ML-KEM-768 (FIPS 203) / ML-DSA-65 (FIPS 204)",
-        });
-        add(RE_JSRSASIGN_SIGN, {
-            ruleId: "jsrsasign-sign",
-            title: "jsrsasign signature",
-            category: "signature",
-            severity: "high",
-            confidence: "high",
-            algorithm: "unknown",
-            hndl: false,
-            cwe: CWE_BROKEN_CRYPTO,
-            message: "jsrsasign signing uses classical RSA/ECDSA signatures, forgeable by a quantum attacker.",
-            remediation: "ML-DSA-65 (FIPS 204)",
-        });
-        // node-rsa: new NodeRSA(...)
-        add(RE_NODE_RSA, {
-            ruleId: "node-rsa",
-            title: "node-rsa key/usage",
-            category: "kem",
-            severity: "high",
-            confidence: "high",
-            algorithm: "RSA",
-            hndl: true,
-            cwe: CWE_BROKEN_CRYPTO,
-            message: "node-rsa wraps classical RSA encryption/signing, which is not quantum-safe.",
-        });
+        const add = (re, rule) => eachMatch(re, content, (m) => findings.push(findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length })));
+        add(RE_FORGE_RSA, RULE_FORGE_RSA); // node-forge: pki.rsa.generateKeyPair(...)
+        add(RE_FORGE_ED25519, RULE_FORGE_ED25519); // node-forge: forge.ed25519.*
+        add(RE_ELLIPTIC_EC, RULE_ELLIPTIC_EC); // elliptic: new EC('secp256k1')
+        add(RE_SECP256K1, RULE_SECP256K1); // secp.sign / getPublicKey / getSharedSecret
+        add(RE_JSRSASIGN_KEYGEN, RULE_JSRSASIGN_KEYGEN); // jsrsasign: KEYUTIL.generateKeypair(...)
+        add(RE_JSRSASIGN_SIGN, RULE_JSRSASIGN_SIGN); // jsrsasign: KJUR.crypto.*
+        add(RE_NODE_RSA, RULE_NODE_RSA_LIB); // node-rsa: new NodeRSA(...)
         return findings;
     },
 };
 /* -------------------------------------------------------------------------- */
 /* JWT / JOSE / COSE algorithm strings                                         */
 /* -------------------------------------------------------------------------- */
+const RULE_JWT_ALG = {
+    id: "jwt-classical-alg",
+    title: "Classical JWT/JOSE algorithm",
+    description: "JWS alg tokens (RS/PS/ES/EdDSA)",
+    category: "signature",
+    severity: "high",
+    confidence: "medium",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "A classical JWT/JOSE signature algorithm is used, forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204); track IETF PQC JOSE/COSE algorithms",
+};
+const RULE_JOSE_ECDH = {
+    id: "jose-ecdh-es",
+    title: "JOSE ECDH-ES key agreement",
+    description: "JOSE ECDH-ES / ECDH-ES+A*KW key agreement",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "medium",
+    algorithm: "ECDH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "JOSE ECDH-ES performs classical ECDH key agreement — harvest-now-decrypt-later exposed.",
+    remediation: "Track IETF PQC JOSE/COSE; adopt hybrid X25519MLKEM768 KEM-based encryption.",
+};
 /**
  * Detects classical signature algorithm identifiers used by JWT/JOSE, plus
  * ECDH-ES key-agreement identifiers (HNDL-exposed). These appear as string
@@ -364,8 +522,12 @@ const jwtDetector = {
     id: "jwt-jose",
     description: "Classical JWT/JOSE algorithms (RS/PS/ES/EdDSA) and ECDH-ES key agreement",
     scope: "source",
-    language: "js",
-    appliesTo: (f) => hasExtension(f, JS_TS_EXTENSIONS),
+    // Language-agnostic evidence: a quoted "RS256"/"ES256" alg token is the same
+    // signal in JS/TS or Python (e.g. PyJWT `algorithm="RS256"`), so this detector
+    // is un-gated from JS-only to the JWT host surfaces.
+    language: "any",
+    rules: [RULE_JWT_ALG, RULE_JOSE_ECDH],
+    appliesTo: (f) => hasExtension(f, JWT_HOST_EXTENSIONS),
     detect({ file, content }) {
         const findings = [];
         // Classical JWS signature alg tokens. Anchored to quotes to avoid words.
@@ -378,40 +540,17 @@ const jwtDetector = {
                 algorithm = "EdDSA";
             else
                 algorithm = "ECDSA"; // ES*
-            findings.push(makeFinding({
-                ruleId: "jwt-classical-alg",
+            findings.push(findingFromRule(RULE_JWT_ALG, { file, content, index: m.index, matchLength: m[0].length }, {
                 title: `JWT/JOSE algorithm ${alg}`,
-                category: "signature",
-                severity: "high",
-                confidence: "medium",
                 algorithm,
-                hndl: false,
-                cwe: CWE_BROKEN_CRYPTO,
                 message: `JWT/JOSE algorithm "${alg}" is a classical signature, forgeable by a quantum attacker.`,
-                remediation: "ML-DSA-65 (FIPS 204); track IETF PQC JOSE/COSE algorithms",
-                file,
-                content,
-                index: m.index,
-                matchLength: m[0].length,
             }));
         });
         // JOSE ECDH-ES key agreement (and ECDH-ES+A*KW) — confidentiality, HNDL.
         eachMatch(RE_JOSE_ECDH, content, (m) => {
-            findings.push(makeFinding({
-                ruleId: "jose-ecdh-es",
+            findings.push(findingFromRule(RULE_JOSE_ECDH, { file, content, index: m.index, matchLength: m[0].length }, {
                 title: `JOSE key agreement ${m[1]}`,
-                category: "key-exchange",
-                severity: "high",
-                confidence: "medium",
-                algorithm: "ECDH",
-                hndl: true,
-                cwe: CWE_BROKEN_CRYPTO,
                 message: `JOSE "${m[1]}" performs classical ECDH key agreement — harvest-now-decrypt-later exposed.`,
-                remediation: "Track IETF PQC JOSE/COSE; adopt hybrid X25519MLKEM768 KEM-based encryption.",
-                file,
-                content,
-                index: m.index,
-                matchLength: m[0].length,
             }));
         });
         return findings;
@@ -420,6 +559,42 @@ const jwtDetector = {
 /* -------------------------------------------------------------------------- */
 /* TLS legacy configuration                                                    */
 /* -------------------------------------------------------------------------- */
+const RULE_TLS_LEGACY = {
+    id: "tls-legacy-version",
+    title: "Legacy TLS version pinned",
+    description: "minVersion/maxVersion/secureProtocol pinned to TLS 1.0/1.1",
+    category: "tls",
+    severity: "medium",
+    confidence: "high",
+    hndl: false,
+    cwe: CWE_WEAK_STRENGTH,
+    message: "TLS 1.0/1.1 are deprecated and insecure; require TLS 1.3.",
+    remediation: "Set minVersion: 'TLSv1.3' and prefer PQC-hybrid key exchange.",
+};
+const RULE_TLS_REJECT = {
+    id: "tls-reject-unauthorized",
+    title: "TLS certificate verification disabled",
+    description: "rejectUnauthorized: false",
+    category: "tls",
+    severity: "high",
+    confidence: "high",
+    hndl: false,
+    cwe: CWE_CERT_VALIDATION,
+    message: "rejectUnauthorized:false disables TLS certificate verification (MITM risk).",
+    remediation: "Remove rejectUnauthorized:false; verify certificates properly.",
+};
+const RULE_TLS_WEAK_CIPHER = {
+    id: "tls-weak-cipher",
+    title: "Weak TLS cipher configured",
+    description: "weak/export cipher in a `ciphers` string",
+    category: "tls",
+    severity: "medium",
+    confidence: "medium",
+    hndl: false,
+    cwe: CWE_WEAK_STRENGTH,
+    message: "A weak cipher is configured in the TLS ciphers list.",
+    remediation: "Use a modern AEAD cipher suite (TLS 1.3 defaults).",
+};
 /**
  * Detects legacy / insecure TLS configuration expressed as JS object literals:
  * forced TLS 1.0/1.1, disabled certificate verification, and weak ciphers.
@@ -431,21 +606,13 @@ const tlsDetector = {
     description: "Legacy / insecure TLS configuration in JS objects",
     scope: "config",
     language: "js",
+    rules: [RULE_TLS_LEGACY, RULE_TLS_REJECT, RULE_TLS_WEAK_CIPHER],
     appliesTo: (f) => hasExtension(f, JS_TS_EXTENSIONS),
     detect({ file, content }) {
         const findings = [];
         // minVersion / maxVersion / secureProtocol pinned to TLS 1.0 or 1.1.
         eachMatch(RE_TLS_LEGACY_VERSION, content, (m) => {
-            findings.push(makeFinding({
-                ruleId: "tls-legacy-version",
-                title: "Legacy TLS version pinned",
-                category: "tls",
-                severity: "medium",
-                confidence: "high",
-                hndl: false,
-                cwe: CWE_WEAK_STRENGTH,
-                message: "TLS 1.0/1.1 are deprecated and insecure; require TLS 1.3.",
-                remediation: "Set minVersion: 'TLSv1.3' and prefer PQC-hybrid key exchange.",
+            findings.push(findingFromRule(RULE_TLS_LEGACY, {
                 file,
                 content,
                 index: m.index,
@@ -454,16 +621,7 @@ const tlsDetector = {
         });
         // rejectUnauthorized: false — disables certificate verification.
         eachMatch(RE_TLS_REJECT, content, (m) => {
-            findings.push(makeFinding({
-                ruleId: "tls-reject-unauthorized",
-                title: "TLS certificate verification disabled",
-                category: "tls",
-                severity: "high",
-                confidence: "high",
-                hndl: false,
-                cwe: CWE_CERT_VALIDATION,
-                message: "rejectUnauthorized:false disables TLS certificate verification (MITM risk).",
-                remediation: "Remove rejectUnauthorized:false; verify certificates properly.",
+            findings.push(findingFromRule(RULE_TLS_REJECT, {
                 file,
                 content,
                 index: m.index,
@@ -472,21 +630,7 @@ const tlsDetector = {
         });
         // Weak / export ciphers referenced in a ciphers string (bounded regex).
         eachMatch(RE_TLS_WEAK_CIPHER, content, (m) => {
-            findings.push(makeFinding({
-                ruleId: "tls-weak-cipher",
-                title: "Weak TLS cipher configured",
-                category: "tls",
-                severity: "medium",
-                confidence: "medium",
-                hndl: false,
-                cwe: CWE_WEAK_STRENGTH,
-                message: `Weak cipher (${m[1]}) configured in the TLS ciphers list.`,
-                remediation: "Use a modern AEAD cipher suite (TLS 1.3 defaults).",
-                file,
-                content,
-                index: m.index,
-                matchLength: m[0].length,
-            }));
+            findings.push(findingFromRule(RULE_TLS_WEAK_CIPHER, { file, content, index: m.index, matchLength: m[0].length }, { message: `Weak cipher (${m[1]}) configured in the TLS ciphers list.` }));
         });
         return findings;
     },
@@ -496,6 +640,33 @@ const tlsDetector = {
 /* -------------------------------------------------------------------------- */
 const RE_SSH_PUBKEY = /\b(ssh-rsa|ssh-ed25519|ssh-dss|ecdsa-sha2-nistp(?:256|384|521))\b/g;
 const RE_CERT_SIG_ALG = /\b(sha(?:1|256|384|512)WithRSAEncryption|ecdsa-with-SHA(?:1|256|384|512)|rsassaPss|dsaWithSHA(?:1|256))\b/g;
+const RULE_SSH_PUBKEY = {
+    id: "ssh-public-key",
+    title: "Classical SSH public key",
+    description: "ssh-rsa / ssh-ed25519 / ssh-dss / ecdsa-sha2-* public keys",
+    category: "certificate",
+    severity: "low",
+    confidence: "medium",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    sensitive: true,
+    message: "A classical SSH public key is forgeable by a quantum attacker.",
+    remediation: "Plan migration to PQC-capable SSH (e.g. sntrup761x25519 KEX, PQC host keys).",
+};
+const RULE_CERT_SIG_ALG = {
+    id: "cert-signature-algorithm",
+    title: "Classical certificate signature algorithm",
+    description: "X.509/TLS certificate signature-algorithm identifiers",
+    category: "certificate",
+    severity: "low",
+    confidence: "medium",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "A classical certificate signature algorithm (RSA/ECDSA/DSA) is a quantum forgery surface.",
+    remediation: "Plan re-issuance with PQC-capable CAs as ML-DSA certificate profiles mature.",
+};
 /**
  * Detects classical SSH public keys (`authorized_keys` / `known_hosts` lines)
  * and X.509 certificate signature-algorithm identifiers in any text file. These
@@ -507,6 +678,7 @@ const sshCertDetector = {
     description: "SSH public keys and TLS/X.509 certificate signature algorithms in config",
     scope: "config",
     language: "any",
+    rules: [RULE_SSH_PUBKEY, RULE_CERT_SIG_ALG],
     appliesTo: () => true,
     detect({ file, content }) {
         const findings = [];
@@ -520,22 +692,10 @@ const sshCertDetector = {
                     : tok === "ssh-dss"
                         ? "DSA"
                         : "ECDSA";
-            findings.push(makeFinding({
-                ruleId: "ssh-public-key",
+            findings.push(findingFromRule(RULE_SSH_PUBKEY, { file, content, index: m.index, matchLength: m[0].length }, {
                 title: `Classical SSH public key (${tok})`,
-                category: "certificate",
-                severity: "low",
-                confidence: "medium",
                 algorithm,
-                hndl: false,
-                cwe: CWE_BROKEN_CRYPTO,
-                sensitive: true,
                 message: `SSH public key type "${tok}" is a classical key forgeable by a quantum attacker.`,
-                remediation: "Plan migration to PQC-capable SSH (e.g. sntrup761x25519 KEX, PQC host keys).",
-                file,
-                content,
-                index: m.index,
-                matchLength: m[0].length,
             }));
         });
         // X.509 / TLS certificate signature algorithm identifiers (forgery surface).
@@ -546,21 +706,10 @@ const sshCertDetector = {
                 : tok.startsWith("ecdsa")
                     ? "ECDSA"
                     : "DSA";
-            findings.push(makeFinding({
-                ruleId: "cert-signature-algorithm",
+            findings.push(findingFromRule(RULE_CERT_SIG_ALG, { file, content, index: m.index, matchLength: m[0].length }, {
                 title: `Classical certificate signature algorithm (${tok})`,
-                category: "certificate",
-                severity: "low",
-                confidence: "medium",
                 algorithm,
-                hndl: false,
-                cwe: CWE_BROKEN_CRYPTO,
                 message: `Certificate signature algorithm "${tok}" is classical (RSA/ECDSA/DSA) — a quantum forgery surface.`,
-                remediation: "Plan re-issuance with PQC-capable CAs as ML-DSA certificate profiles mature.",
-                file,
-                content,
-                index: m.index,
-                matchLength: m[0].length,
             }));
         });
         return findings;