@quantakrypto/core 0.4.2 → 0.4.4

package/dist/detectors/database.js

@@ -0,0 +1,60 @@
+import { DOC_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION } from "../cwe.js";
+const RE_PGCRYPTO = /\bpgp_pub_(?:encrypt|decrypt)\b/g;
+const RE_WEAK_SSLMODE = /\bsslmode\s*=\s*["']?(?:disable|allow|prefer|require)\b/gi;
+const RULE_PGCRYPTO = {
+    id: "db-pgcrypto-pubkey",
+    title: "pgcrypto public-key encryption",
+    description: "Postgres pgcrypto pgp_pub_encrypt / pgp_pub_decrypt (RSA/ElGamal) on stored data",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Column data is encrypted with pgcrypto public-key crypto (classical RSA/ElGamal); stored ciphertext is harvest-now-decrypt-later exposed.",
+    remediation: "Plan migration to a post-quantum KEM (ML-KEM-768) envelope for at-rest data; re-encrypt long-lived rows.",
+};
+const RULE_WEAK_SSLMODE = {
+    id: "db-weak-sslmode",
+    title: "Database sslmode without verification",
+    description: "libpq sslmode is disable/allow/prefer/require (no certificate verification)",
+    category: "tls",
+    severity: "medium",
+    confidence: "high",
+    hndl: false,
+    cwe: CWE_CERT_VALIDATION,
+    message: "Database sslmode does not verify the server certificate; the classical TLS session is MITM-able and its key exchange is harvestable.",
+    remediation: "Use sslmode=verify-full and TLS 1.3; track PQC-hybrid KEX (X25519MLKEM768) for database transport.",
+};
+/** Detects classical database at-rest / transport crypto. */
+export const databaseDetector = {
+    id: "database-crypto",
+    description: "Classical crypto in database usage (pgcrypto public-key, weak client sslmode)",
+    scope: "config",
+    language: "any",
+    rules: [RULE_PGCRYPTO, RULE_WEAK_SSLMODE],
+    // Skip prose/docs: a README showing `sslmode=require` is not a live connection string.
+    appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS),
+    detect({ file, content }) {
+        const findings = [];
+        if (file.toLowerCase().endsWith(".sql") && content.includes("pgp_pub_")) {
+            eachMatch(RE_PGCRYPTO, content, (m) => findings.push(findingFromRule(RULE_PGCRYPTO, {
+                file,
+                content,
+                index: m.index,
+                matchLength: m[0].length,
+            })));
+        }
+        if (content.includes("sslmode")) {
+            eachMatch(RE_WEAK_SSLMODE, content, (m) => findings.push(findingFromRule(RULE_WEAK_SSLMODE, {
+                file,
+                content,
+                index: m.index,
+                matchLength: m[0].length,
+            })));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=database.js.map

package/dist/detectors/database.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.js","sourceRoot":"","sources":["../../src/detectors/database.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC9F,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEnE,MAAM,WAAW,GAAG,kCAAkC,CAAC;AACvD,MAAM,eAAe,GAAG,2DAA2D,CAAC;AAEpF,MAAM,aAAa,GAAa;IAC9B,EAAE,EAAE,oBAAoB;IACxB,KAAK,EAAE,gCAAgC;IACvC,WAAW,EAAE,kFAAkF;IAC/F,QAAQ,EAAE,KAAK;IACf,QAAQ,EAAE,MAAM;IAChB,UAAU,EAAE,MAAM;IAClB,SAAS,EAAE,KAAK;IAChB,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,iBAAiB;IACtB,OAAO,EACL,2IAA2I;IAC7I,WAAW,EACT,0GAA0G;CAC7G,CAAC;AACF,MAAM,iBAAiB,GAAa;IAClC,EAAE,EAAE,iBAAiB;IACrB,KAAK,EAAE,uCAAuC;IAC9C,WAAW,EAAE,6EAA6E;IAC1F,QAAQ,EAAE,KAAK;IACf,QAAQ,EAAE,QAAQ;IAClB,UAAU,EAAE,MAAM;IAClB,IAAI,EAAE,KAAK;IACX,GAAG,EAAE,mBAAmB;IACxB,OAAO,EACL,sIAAsI;IACxI,WAAW,EACT,oGAAoG;CACvG,CAAC;AAEF,6DAA6D;AAC7D,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,iBAAiB;IACrB,WAAW,EAAE,+EAA+E;IAC5F,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE,KAAK;IACf,KAAK,EAAE,CAAC,aAAa,EAAE,iBAAiB,CAAC;IACzC,uFAAuF;IACvF,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc,CAAC;IAClD,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;QACtB,MAAM,QAAQ,GAAc,EAAE,CAAC;QAC/B,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YACxE,SAAS,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,CACpC,QAAQ,CAAC,IAAI,CACX,eAAe,CAAC,aAAa,EAAE;gBAC7B,IAAI;gBACJ,OAAO;gBACP,KAAK,EAAE,CAAC,CAAC,KAAK;gBACd,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM;aACzB,CAAC,CACH,CACF,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;YAChC,SAAS,CAAC,eAAe,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,CACxC,QAAQ,CAAC,IAAI,CACX,eAAe,CAAC,iBAAiB,EAAE;gBACjC,IAAI;gBACJ,OAAO;gBACP,KAAK,EAAE,CAAC,CAAC,KAAK;gBACd,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM;aACzB,CAAC,CACH,CACF,CAAC;QACJ,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC","sourcesContent":["/**\n * Config detector: classical crypto in database usage — public-key encryption of\n * stored data (pgcrypto) and weak client TLS posture. Data-at-rest is the sharpest\n * harvest-now-decrypt-later target: a column encrypted to an RSA key today is a\n * time capsule an adversary can hold until key recovery is cheap.\n *\n * Covered:\n *  - pgcrypto `pgp_pub_encrypt` / `pgp_pub_decrypt` in `.sql` (RSA/ElGamal public-key\n *    encryption of column data) → `hndl:true`.\n *  - libpq `sslmode = disable | allow | prefer | require` in any config/connection\n *    file — a mode that does NOT verify the server certificate, so the classical\n *    TLS session it does (or doesn't) negotiate is both MITM-able and harvestable.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport { DOC_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION } from \"../cwe.js\";\n\nconst RE_PGCRYPTO = /\\bpgp_pub_(?:encrypt|decrypt)\\b/g;\nconst RE_WEAK_SSLMODE = /\\bsslmode\\s*=\\s*[\"']?(?:disable|allow|prefer|require)\\b/gi;\n\nconst RULE_PGCRYPTO: RuleMeta = {\n  id: \"db-pgcrypto-pubkey\",\n  title: \"pgcrypto public-key encryption\",\n  description: \"Postgres pgcrypto pgp_pub_encrypt / pgp_pub_decrypt (RSA/ElGamal) on stored data\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Column data is encrypted with pgcrypto public-key crypto (classical RSA/ElGamal); stored ciphertext is harvest-now-decrypt-later exposed.\",\n  remediation:\n    \"Plan migration to a post-quantum KEM (ML-KEM-768) envelope for at-rest data; re-encrypt long-lived rows.\",\n};\nconst RULE_WEAK_SSLMODE: RuleMeta = {\n  id: \"db-weak-sslmode\",\n  title: \"Database sslmode without verification\",\n  description: \"libpq sslmode is disable/allow/prefer/require (no certificate verification)\",\n  category: \"tls\",\n  severity: \"medium\",\n  confidence: \"high\",\n  hndl: false,\n  cwe: CWE_CERT_VALIDATION,\n  message:\n    \"Database sslmode does not verify the server certificate; the classical TLS session is MITM-able and its key exchange is harvestable.\",\n  remediation:\n    \"Use sslmode=verify-full and TLS 1.3; track PQC-hybrid KEX (X25519MLKEM768) for database transport.\",\n};\n\n/** Detects classical database at-rest / transport crypto. */\nexport const databaseDetector: Detector = {\n  id: \"database-crypto\",\n  description: \"Classical crypto in database usage (pgcrypto public-key, weak client sslmode)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: [RULE_PGCRYPTO, RULE_WEAK_SSLMODE],\n  // Skip prose/docs: a README showing `sslmode=require` is not a live connection string.\n  appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const findings: Finding[] = [];\n    if (file.toLowerCase().endsWith(\".sql\") && content.includes(\"pgp_pub_\")) {\n      eachMatch(RE_PGCRYPTO, content, (m) =>\n        findings.push(\n          findingFromRule(RULE_PGCRYPTO, {\n            file,\n            content,\n            index: m.index,\n            matchLength: m[0].length,\n          }),\n        ),\n      );\n    }\n    if (content.includes(\"sslmode\")) {\n      eachMatch(RE_WEAK_SSLMODE, content, (m) =>\n        findings.push(\n          findingFromRule(RULE_WEAK_SSLMODE, {\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/dnssec.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Config detector: classical DNSSEC signing algorithms in zone files and
+ * signer/resolver config (BIND, Knot DNS, PowerDNS, `ldns-signzone` /
+ * `dnssec-signzone` invocations recorded in ops config).
+ *
+ * DNSSEC is "communication between things" infrastructure: resolvers verify
+ * DNSKEY/RRSIG chains to authenticate zone data. Unlike a KEM or key-exchange
+ * finding, a DNSSEC signing key is not harvest-now-decrypt-later exposed —
+ * there is no confidentiality to harvest — but every classical signature it
+ * produces becomes FORGEABLE the moment a cryptographically-relevant quantum
+ * computer (CRQC) exists. A forged DNSKEY/RRSIG chain lets an attacker spoof
+ * DNSSEC-validated records (cache poisoning that a validating resolver would
+ * otherwise reject). So these findings are `category: "signature"`,
+ * `hndl: false`.
+ *
+ * RFC 8624 / IANA "DNSSEC Algorithm Numbers" families covered, mapped to
+ * {@link AlgorithmFamily}:
+ *  - RSASHA1 (5), RSASHA1-NSEC3-SHA1 (7), RSASHA256 (8), RSASHA512 (10) → RSA
+ *  - ECDSAP256SHA256 (13), ECDSAP384SHA384 (14)                        → ECDSA
+ *  - ED25519 (15), ED448 (16)                                          → EdDSA
+ *  - DSA (3), DSA-NSEC3-SHA1 (6)                                      → DSA
+ *
+ * Two independent match shapes per family, both gated to `.zone` / `.db` /
+ * `.conf` files AND to a file-level DNSSEC marker (see `hasDnssecMarker`
+ * below) so the algorithm tokens can't fire on unrelated config:
+ *
+ *  1. NAMED form — the algorithm's mnemonic name, as written in signer/policy
+ *     config (Knot `algorithm RSASHA256;`, a `dnssec-policy` block, BIND
+ *     `algorithm: ecdsap256sha256;`) or on an `ldns-signzone -a ECDSAP256SHA256`
+ *     / `dnssec-signzone -a ECDSAP256SHA256` command line. These mnemonics
+ *     (`RSASHA256`, `ECDSAP384SHA384`, `ED25519`, …) are distinctive enough to
+ *     match bare, EXCEPT plain `DSA`, which is too generic a token on its own
+ *     (used well outside DNSSEC); that one is only matched immediately after
+ *     an `algorithm` keyword.
+ *  2. STRUCTURAL form — the DNSKEY presentation-format RDATA, e.g.
+ *     `example.com. IN DNSKEY 257 3 8 AwEAAd...`, where the fields after the
+ *     `DNSKEY` keyword are `flags protocol algorithm public-key` (RFC 4034
+ *     §2). Anchoring on the literal `DNSKEY` keyword AND the literal
+ *     protocol value `3` (always 3 for DNSSEC) before a restricted algorithm
+ *     number keeps this precise despite being numeric. Bare algorithm
+ *     numbers with no such anchor are deliberately NOT matched anywhere —
+ *     `algorithm 8;` alone is far too ambiguous to key off of.
+ *
+ * Fast reject: `detect()` bails unless the file contains `DNSKEY`, `RRSIG`,
+ * a case-insensitive `dnssec` substring (present in `dnssec-policy`,
+ * `dnssec-signing: on`, etc. in any real signer config), or an
+ * `ldns-signzone` / `dnssec-signzone` invocation. This stops the DSA/EdDSA
+ * named-form tokens — which are individually generic outside DNSSEC — from
+ * firing on, say, an unrelated SSH or TLS `.conf` file that happens to
+ * mention `ED25519` or `DSA` for its own reasons.
+ */
+import type { Detector } from "../types.js";
+/** Detects classical DNSSEC signing algorithms in zone files and signer config. */
+export declare const dnssecDetector: Detector;
+//# sourceMappingURL=dnssec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dnssec.d.ts","sourceRoot":"","sources":["../../src/detectors/dnssec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA+G/D,mFAAmF;AACnF,eAAO,MAAM,cAAc,EAAE,QAsB5B,CAAC"}

package/dist/detectors/dnssec.js

@@ -0,0 +1,107 @@
+import { eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+const DNSSEC_EXTENSIONS = [".zone", ".db", ".conf"];
+// IANA DNSSEC algorithm numbers, grouped by family.
+const NUM_RSA = "5|7|8|10"; // RSASHA1, RSASHA1-NSEC3-SHA1, RSASHA256, RSASHA512
+const NUM_ECDSA = "13|14"; // ECDSAP256SHA256, ECDSAP384SHA384
+const NUM_EDDSA = "15|16"; // ED25519, ED448
+const NUM_DSA = "3|6"; // DSA, DSA-NSEC3-SHA1
+// --- NAMED form: mnemonic algorithm names in signer/policy config or CLI args. ---
+const RE_NAMED_RSA = /\bRSASHA(?:256|512|1(?:-NSEC3-SHA1)?)\b/g;
+const RE_NAMED_ECDSA = /\bECDSAP(?:256SHA256|384SHA384)\b/g;
+const RE_NAMED_EDDSA = /\bED(?:25519|448)\b/g;
+// Bare "DSA" is too generic to key off alone; require it right after an
+// `algorithm` keyword (Knot/BIND config / dnssec-policy style), optionally
+// quoted or separated by `:`/`=`.
+const RE_NAMED_DSA = /\balgorithm\s*[:=]?\s*"?DSA(?:-NSEC3-SHA1)?"?\b/gi;
+// --- STRUCTURAL form: `DNSKEY <flags> 3 <algorithm>` presentation RDATA (RFC 4034 §2). ---
+const RE_DNSKEY_RSA = new RegExp(`\\bDNSKEY\\s+\\d+\\s+3\\s+(?:${NUM_RSA})\\b`, "g");
+const RE_DNSKEY_ECDSA = new RegExp(`\\bDNSKEY\\s+\\d+\\s+3\\s+(?:${NUM_ECDSA})\\b`, "g");
+const RE_DNSKEY_EDDSA = new RegExp(`\\bDNSKEY\\s+\\d+\\s+3\\s+(?:${NUM_EDDSA})\\b`, "g");
+const RE_DNSKEY_DSA = new RegExp(`\\bDNSKEY\\s+\\d+\\s+3\\s+(?:${NUM_DSA})\\b`, "g");
+const RULE_DNSSEC_RSA = {
+    id: "dnssec-rsa-sig",
+    title: "DNSSEC RSA signing algorithm",
+    description: "DNSSEC zone signed with a classical RSA algorithm (RSASHA1/256/512)",
+    category: "signature",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "DNSSEC zone is signed with a classical RSA algorithm (RSASHA1/RSASHA1-NSEC3-SHA1/RSASHA256/RSASHA512); DNSKEY/RRSIG signatures become forgeable once a CRQC exists.",
+    remediation: "Track IETF dnsop post-quantum DNSSEC signing work (ML-DSA); plan re-signing with a PQC algorithm once assigned an IANA DNSSEC algorithm number.",
+};
+const RULE_DNSSEC_ECDSA = {
+    id: "dnssec-ecdsa-sig",
+    title: "DNSSEC ECDSA signing algorithm",
+    description: "DNSSEC zone signed with a classical ECDSA algorithm (ECDSAP256SHA256/384SHA384)",
+    category: "signature",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "DNSSEC zone is signed with a classical ECDSA algorithm (ECDSAP256SHA256/ECDSAP384SHA384); DNSKEY/RRSIG signatures become forgeable once a CRQC exists.",
+    remediation: "Track IETF dnsop post-quantum DNSSEC signing work (ML-DSA); plan re-signing with a PQC algorithm once assigned an IANA DNSSEC algorithm number.",
+};
+const RULE_DNSSEC_EDDSA = {
+    id: "dnssec-eddsa-sig",
+    title: "DNSSEC EdDSA signing algorithm",
+    description: "DNSSEC zone signed with a classical EdDSA algorithm (ED25519/ED448)",
+    category: "signature",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "EdDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "DNSSEC zone is signed with a classical EdDSA algorithm (ED25519/ED448); modern but still classical — DNSKEY/RRSIG signatures become forgeable once a CRQC exists.",
+    remediation: "Track IETF dnsop post-quantum DNSSEC signing work (ML-DSA); plan re-signing with a PQC algorithm once assigned an IANA DNSSEC algorithm number.",
+};
+const RULE_DNSSEC_DSA = {
+    id: "dnssec-dsa-sig",
+    title: "DNSSEC DSA signing algorithm (deprecated)",
+    description: "DNSSEC zone signed with the deprecated classical DSA algorithm (DSA/DSA-NSEC3-SHA1)",
+    category: "signature",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "DSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "DNSSEC zone is signed with DSA/DSA-NSEC3-SHA1 — deprecated by RFC 8624 (MUST NOT sign) and, independent of that, forgeable once a CRQC exists.",
+    remediation: "Re-sign with a non-deprecated algorithm today (RFC 8624); track IETF dnsop post-quantum DNSSEC signing work (ML-DSA) for the eventual PQC migration.",
+};
+/** True when `content` carries some DNSSEC-specific marker (not just a bare algorithm token). */
+function hasDnssecMarker(content) {
+    return (content.includes("DNSKEY") ||
+        content.includes("RRSIG") ||
+        /dnssec/i.test(content) ||
+        /ldns-signzone|dnssec-signzone/.test(content));
+}
+const DNSSEC_RULES = [
+    { meta: RULE_DNSSEC_RSA, res: [RE_NAMED_RSA, RE_DNSKEY_RSA] },
+    { meta: RULE_DNSSEC_ECDSA, res: [RE_NAMED_ECDSA, RE_DNSKEY_ECDSA] },
+    { meta: RULE_DNSSEC_EDDSA, res: [RE_NAMED_EDDSA, RE_DNSKEY_EDDSA] },
+    { meta: RULE_DNSSEC_DSA, res: [RE_NAMED_DSA, RE_DNSKEY_DSA] },
+];
+/** Detects classical DNSSEC signing algorithms in zone files and signer config. */
+export const dnssecDetector = {
+    id: "dnssec-crypto",
+    description: "Classical DNSSEC signing algorithms in zone files / signer config",
+    scope: "config",
+    language: "any",
+    rules: DNSSEC_RULES.map((r) => r.meta),
+    appliesTo: (f) => hasExtension(f, DNSSEC_EXTENSIONS),
+    detect({ file, content }) {
+        if (!hasDnssecMarker(content))
+            return [];
+        const findings = [];
+        for (const { meta, res } of DNSSEC_RULES) {
+            for (const re of res) {
+                eachMatch(re, content, (m) => findings.push(findingFromRule(meta, { file, content, index: m.index, matchLength: m[0].length })));
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=dnssec.js.map

package/dist/detectors/dnssec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dnssec.js","sourceRoot":"","sources":["../../src/detectors/dnssec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Config detector: classical DNSSEC signing algorithms in zone files and\n * signer/resolver config (BIND, Knot DNS, PowerDNS, `ldns-signzone` /\n * `dnssec-signzone` invocations recorded in ops config).\n *\n * DNSSEC is \"communication between things\" infrastructure: resolvers verify\n * DNSKEY/RRSIG chains to authenticate zone data. Unlike a KEM or key-exchange\n * finding, a DNSSEC signing key is not harvest-now-decrypt-later exposed —\n * there is no confidentiality to harvest — but every classical signature it\n * produces becomes FORGEABLE the moment a cryptographically-relevant quantum\n * computer (CRQC) exists. A forged DNSKEY/RRSIG chain lets an attacker spoof\n * DNSSEC-validated records (cache poisoning that a validating resolver would\n * otherwise reject). So these findings are `category: \"signature\"`,\n * `hndl: false`.\n *\n * RFC 8624 / IANA \"DNSSEC Algorithm Numbers\" families covered, mapped to\n * {@link AlgorithmFamily}:\n *  - RSASHA1 (5), RSASHA1-NSEC3-SHA1 (7), RSASHA256 (8), RSASHA512 (10) → RSA\n *  - ECDSAP256SHA256 (13), ECDSAP384SHA384 (14)                        → ECDSA\n *  - ED25519 (15), ED448 (16)                                          → EdDSA\n *  - DSA (3), DSA-NSEC3-SHA1 (6)                                      → DSA\n *\n * Two independent match shapes per family, both gated to `.zone` / `.db` /\n * `.conf` files AND to a file-level DNSSEC marker (see `hasDnssecMarker`\n * below) so the algorithm tokens can't fire on unrelated config:\n *\n *  1. NAMED form — the algorithm's mnemonic name, as written in signer/policy\n *     config (Knot `algorithm RSASHA256;`, a `dnssec-policy` block, BIND\n *     `algorithm: ecdsap256sha256;`) or on an `ldns-signzone -a ECDSAP256SHA256`\n *     / `dnssec-signzone -a ECDSAP256SHA256` command line. These mnemonics\n *     (`RSASHA256`, `ECDSAP384SHA384`, `ED25519`, …) are distinctive enough to\n *     match bare, EXCEPT plain `DSA`, which is too generic a token on its own\n *     (used well outside DNSSEC); that one is only matched immediately after\n *     an `algorithm` keyword.\n *  2. STRUCTURAL form — the DNSKEY presentation-format RDATA, e.g.\n *     `example.com. IN DNSKEY 257 3 8 AwEAAd...`, where the fields after the\n *     `DNSKEY` keyword are `flags protocol algorithm public-key` (RFC 4034\n *     §2). Anchoring on the literal `DNSKEY` keyword AND the literal\n *     protocol value `3` (always 3 for DNSSEC) before a restricted algorithm\n *     number keeps this precise despite being numeric. Bare algorithm\n *     numbers with no such anchor are deliberately NOT matched anywhere —\n *     `algorithm 8;` alone is far too ambiguous to key off of.\n *\n * Fast reject: `detect()` bails unless the file contains `DNSKEY`, `RRSIG`,\n * a case-insensitive `dnssec` substring (present in `dnssec-policy`,\n * `dnssec-signing: on`, etc. in any real signer config), or an\n * `ldns-signzone` / `dnssec-signzone` invocation. This stops the DSA/EdDSA\n * named-form tokens — which are individually generic outside DNSSEC — from\n * firing on, say, an unrelated SSH or TLS `.conf` file that happens to\n * mention `ED25519` or `DSA` for its own reasons.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport { eachMatch, findingFromRule, hasExtension } from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO } from \"../cwe.js\";\n\nconst DNSSEC_EXTENSIONS: readonly string[] = [\".zone\", \".db\", \".conf\"];\n\n// IANA DNSSEC algorithm numbers, grouped by family.\nconst NUM_RSA = \"5|7|8|10\"; // RSASHA1, RSASHA1-NSEC3-SHA1, RSASHA256, RSASHA512\nconst NUM_ECDSA = \"13|14\"; // ECDSAP256SHA256, ECDSAP384SHA384\nconst NUM_EDDSA = \"15|16\"; // ED25519, ED448\nconst NUM_DSA = \"3|6\"; // DSA, DSA-NSEC3-SHA1\n\n// --- NAMED form: mnemonic algorithm names in signer/policy config or CLI args. ---\nconst RE_NAMED_RSA = /\\bRSASHA(?:256|512|1(?:-NSEC3-SHA1)?)\\b/g;\nconst RE_NAMED_ECDSA = /\\bECDSAP(?:256SHA256|384SHA384)\\b/g;\nconst RE_NAMED_EDDSA = /\\bED(?:25519|448)\\b/g;\n// Bare \"DSA\" is too generic to key off alone; require it right after an\n// `algorithm` keyword (Knot/BIND config / dnssec-policy style), optionally\n// quoted or separated by `:`/`=`.\nconst RE_NAMED_DSA = /\\balgorithm\\s*[:=]?\\s*\"?DSA(?:-NSEC3-SHA1)?\"?\\b/gi;\n\n// --- STRUCTURAL form: `DNSKEY <flags> 3 <algorithm>` presentation RDATA (RFC 4034 §2). ---\nconst RE_DNSKEY_RSA = new RegExp(`\\\\bDNSKEY\\\\s+\\\\d+\\\\s+3\\\\s+(?:${NUM_RSA})\\\\b`, \"g\");\nconst RE_DNSKEY_ECDSA = new RegExp(`\\\\bDNSKEY\\\\s+\\\\d+\\\\s+3\\\\s+(?:${NUM_ECDSA})\\\\b`, \"g\");\nconst RE_DNSKEY_EDDSA = new RegExp(`\\\\bDNSKEY\\\\s+\\\\d+\\\\s+3\\\\s+(?:${NUM_EDDSA})\\\\b`, \"g\");\nconst RE_DNSKEY_DSA = new RegExp(`\\\\bDNSKEY\\\\s+\\\\d+\\\\s+3\\\\s+(?:${NUM_DSA})\\\\b`, \"g\");\n\nconst RULE_DNSSEC_RSA: RuleMeta = {\n  id: \"dnssec-rsa-sig\",\n  title: \"DNSSEC RSA signing algorithm\",\n  description: \"DNSSEC zone signed with a classical RSA algorithm (RSASHA1/256/512)\",\n  category: \"signature\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"DNSSEC zone is signed with a classical RSA algorithm (RSASHA1/RSASHA1-NSEC3-SHA1/RSASHA256/RSASHA512); DNSKEY/RRSIG signatures become forgeable once a CRQC exists.\",\n  remediation:\n    \"Track IETF dnsop post-quantum DNSSEC signing work (ML-DSA); plan re-signing with a PQC algorithm once assigned an IANA DNSSEC algorithm number.\",\n};\nconst RULE_DNSSEC_ECDSA: RuleMeta = {\n  id: \"dnssec-ecdsa-sig\",\n  title: \"DNSSEC ECDSA signing algorithm\",\n  description: \"DNSSEC zone signed with a classical ECDSA algorithm (ECDSAP256SHA256/384SHA384)\",\n  category: \"signature\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"DNSSEC zone is signed with a classical ECDSA algorithm (ECDSAP256SHA256/ECDSAP384SHA384); DNSKEY/RRSIG signatures become forgeable once a CRQC exists.\",\n  remediation:\n    \"Track IETF dnsop post-quantum DNSSEC signing work (ML-DSA); plan re-signing with a PQC algorithm once assigned an IANA DNSSEC algorithm number.\",\n};\nconst RULE_DNSSEC_EDDSA: RuleMeta = {\n  id: \"dnssec-eddsa-sig\",\n  title: \"DNSSEC EdDSA signing algorithm\",\n  description: \"DNSSEC zone signed with a classical EdDSA algorithm (ED25519/ED448)\",\n  category: \"signature\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"DNSSEC zone is signed with a classical EdDSA algorithm (ED25519/ED448); modern but still classical — DNSKEY/RRSIG signatures become forgeable once a CRQC exists.\",\n  remediation:\n    \"Track IETF dnsop post-quantum DNSSEC signing work (ML-DSA); plan re-signing with a PQC algorithm once assigned an IANA DNSSEC algorithm number.\",\n};\nconst RULE_DNSSEC_DSA: RuleMeta = {\n  id: \"dnssec-dsa-sig\",\n  title: \"DNSSEC DSA signing algorithm (deprecated)\",\n  description:\n    \"DNSSEC zone signed with the deprecated classical DSA algorithm (DSA/DSA-NSEC3-SHA1)\",\n  category: \"signature\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"DSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"DNSSEC zone is signed with DSA/DSA-NSEC3-SHA1 — deprecated by RFC 8624 (MUST NOT sign) and, independent of that, forgeable once a CRQC exists.\",\n  remediation:\n    \"Re-sign with a non-deprecated algorithm today (RFC 8624); track IETF dnsop post-quantum DNSSEC signing work (ML-DSA) for the eventual PQC migration.\",\n};\n\n/** True when `content` carries some DNSSEC-specific marker (not just a bare algorithm token). */\nfunction hasDnssecMarker(content: string): boolean {\n  return (\n    content.includes(\"DNSKEY\") ||\n    content.includes(\"RRSIG\") ||\n    /dnssec/i.test(content) ||\n    /ldns-signzone|dnssec-signzone/.test(content)\n  );\n}\n\ninterface DnssecRule {\n  meta: RuleMeta;\n  res: readonly RegExp[];\n}\n\nconst DNSSEC_RULES: readonly DnssecRule[] = [\n  { meta: RULE_DNSSEC_RSA, res: [RE_NAMED_RSA, RE_DNSKEY_RSA] },\n  { meta: RULE_DNSSEC_ECDSA, res: [RE_NAMED_ECDSA, RE_DNSKEY_ECDSA] },\n  { meta: RULE_DNSSEC_EDDSA, res: [RE_NAMED_EDDSA, RE_DNSKEY_EDDSA] },\n  { meta: RULE_DNSSEC_DSA, res: [RE_NAMED_DSA, RE_DNSKEY_DSA] },\n];\n\n/** Detects classical DNSSEC signing algorithms in zone files and signer config. */\nexport const dnssecDetector: Detector = {\n  id: \"dnssec-crypto\",\n  description: \"Classical DNSSEC signing algorithms in zone files / signer config\",\n  scope: \"config\",\n  language: \"any\",\n  rules: DNSSEC_RULES.map((r) => r.meta),\n  appliesTo: (f) => hasExtension(f, DNSSEC_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    if (!hasDnssecMarker(content)) return [];\n\n    const findings: Finding[] = [];\n    for (const { meta, res } of DNSSEC_RULES) {\n      for (const re of res) {\n        eachMatch(re, content, (m) =>\n          findings.push(\n            findingFromRule(meta, { file, content, index: m.index, matchLength: m[0].length }),\n          ),\n        );\n      }\n    }\n    return findings;\n  },\n};\n"]}

package/dist/detectors/elixir.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Source-code detector for classical asymmetric cryptography in Elixir (the BEAM
+ * / Phoenix ecosystem), previously uncovered. Handles the three common surfaces:
+ *
+ *  - **Erlang `:crypto`** — `:crypto.generate_key(:rsa|:ecdh|:dh|:eddsa, …)`
+ *    (the curve atom disambiguates X25519/X448 from a generic ECDH curve) and
+ *    `:crypto.sign/:crypto.verify(:rsa|:ecdsa|:eddsa, …)`.
+ *  - **`X509`** (the `x509` hex package) — `X509.PrivateKey.new_rsa` / `new_ec`.
+ *  - **`JOSE`** (erlang-jose) — `JOSE.JWK.generate_key({:rsa|:ec|:okp, …})`.
+ *
+ * Lexical, like the other packs; the `:crypto.` atom-module syntax and the
+ * `X509.` / `JOSE.` module paths are distinctive, so the false-positive rate is low.
+ *
+ * HNDL: RSA and (EC/X)DH key agreement are harvest-now-decrypt-later exposed
+ * (hndl:true); ECDSA / EdDSA signatures are hndl:false but forgeable.
+ */
+import type { Detector } from "../types.js";
+/** Detects classical asymmetric crypto in Elixir (:crypto, X509, JOSE). */
+export declare const elixirDetector: Detector;
+//# sourceMappingURL=elixir.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elixir.d.ts","sourceRoot":"","sources":["../../src/detectors/elixir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAmB,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAuIhF,2EAA2E;AAC3E,eAAO,MAAM,cAAc,EAAE,QAoF5B,CAAC"}

package/dist/detectors/elixir.js

@@ -0,0 +1,195 @@
+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;
+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";
+    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.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, …}).
+        eachMatch(RE_EX_JOSE, content, (m) => {
+            const kind = m[1];
+            const cls = kind === "rsa" ? RSA_CLS : kind === "ec" ? EC_CLS : kind === "okp" ? EDDSA_CLS : 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;\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  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.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, …}).\n    eachMatch(RE_EX_JOSE, content, (m) => {\n      const kind = m[1];\n      const cls =\n        kind === \"rsa\" ? RSA_CLS : kind === \"ec\" ? EC_CLS : kind === \"okp\" ? EDDSA_CLS : 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/go.d.ts

@@ -6,11 +6,13 @@
  * `ecdsa.SignASN1`, `ecdh.X25519`, …) are precise, low-false-positive signals.
  *
  * Covered:
- *   - crypto/rsa   — GenerateKey, EncryptOAEP/PKCS1v15, SignPKCS1v15/PSS
- *   - crypto/ecdsa — GenerateKey, Sign/SignASN1
+ *   - crypto/rsa   — GenerateKey, EncryptOAEP/PKCS1v15, SignPKCS1v15/PSS, DecryptOAEP, VerifyPKCS1v15/PSS
+ *   - crypto/ecdsa — GenerateKey, Sign/SignASN1, Verify/VerifyASN1
  *   - crypto/ecdh  — P256/P384/P521/X25519 curve construction (key agreement)
- *   - crypto/ed25519 — GenerateKey, Sign
+ *   - crypto/elliptic — GenerateKey / ScalarMult (classic pre-1.20 ECDH)
+ *   - crypto/ed25519 — GenerateKey, Sign, Verify
  *   - crypto/dsa   — GenerateKey, GenerateParameters (deprecated)
+ *   - crypto/tls   — InsecureSkipVerify, legacy MinVersion (transport config hygiene)
  *
  * HNDL policy mirrors the other detectors: KEM / key agreement (RSA encryption,
  * ECDH) is harvest-now-decrypt-later exposed (hndl:true); signatures (RSA-sign,

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

@@ -1 +1 @@
-{"version":3,"file":"go.d.ts","sourceRoot":"","sources":["../../src/detectors/go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA8G/D,oFAAoF;AACpF,eAAO,MAAM,UAAU,EAAE,QAkCxB,CAAC"}
+{"version":3,"file":"go.d.ts","sourceRoot":"","sources":["../../src/detectors/go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAqR/D,oFAAoF;AACpF,eAAO,MAAM,UAAU,EAAE,QAoExB,CAAC"}