@quantakrypto/core 0.4.3 → 0.5.0

package/dist/detectors/database.js

@@ -0,0 +1,97 @@
+import { DOC_EXTENSIONS, eachMatch, findingFromRule, hasExtension, maskCommentLines, } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION } from "../cwe.js";
+const RE_PGCRYPTO = /\bpgp_pub_(?:encrypt|decrypt)\b/g;
+// Matches the no-verification TLS modes across libpq (`sslmode=require`), the
+// `PGSSLMODE` env var, MySQL (`ssl-mode=PREFERRED`/`REQUIRED`, hyphenated), and YAML
+// connection config (`sslmode: require`) — i.e. an optional `pg` prefix, `-`/`_` or no
+// separator, `:` or `=`, and the libpq/MySQL value spellings.
+const RE_WEAK_SSLMODE = /\b(?:pg)?ssl[-_]?mode\s*[:=]\s*["']?(?:allow|prefer(?:red)?|require[d]?)\b/gi;
+// SQL Server TDE: the database encryption key is protected by a classical RSA
+// asymmetric key / certificate. `CREATE ASYMMETRIC KEY … WITH ALGORITHM = RSA_2048`
+// is the distinctive form; the span between the two clauses is lazily bounded to keep
+// matching linear.
+const RE_MSSQL_TDE_RSA = /\bCREATE\s+ASYMMETRIC\s+KEY\b[\s\S]{0,300}?\bALGORITHM\s*=\s*RSA_\d+/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_MSSQL_TDE_RSA = {
+    id: "db-tde-rsa",
+    title: "SQL Server TDE RSA key",
+    description: "SQL Server CREATE ASYMMETRIC KEY ... WITH ALGORITHM = RSA_* (TDE key protection)",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Transparent Data Encryption protects the database encryption key with a classical RSA asymmetric key; the at-rest data is harvest-now-decrypt-later exposed once the RSA key falls.",
+    remediation: "Plan migration to a PQC KEM (ML-KEM-768) for TDE key protection as the database engine adds support; re-key long-lived encrypted databases.",
+};
+const RULE_WEAK_SSLMODE = {
+    id: "db-weak-sslmode",
+    title: "Database sslmode without verification",
+    description: "libpq sslmode is 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, SQL Server TDE, weak client sslmode)",
+    scope: "config",
+    language: "any",
+    rules: [RULE_PGCRYPTO, RULE_MSSQL_TDE_RSA, 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 = [];
+        // Mask SQL (`--`, single-line `/* … */`), shell/ini (`#`), and ini (`;`) line
+        // comments: a commented `-- pgp_pub_encrypt` or `; sslmode=require` is not active.
+        const scan = maskCommentLines(content, ["#", "--", ";", "/*"]);
+        if (file.toLowerCase().endsWith(".sql") && content.includes("pgp_pub_")) {
+            eachMatch(RE_PGCRYPTO, scan, (m) => findings.push(findingFromRule(RULE_PGCRYPTO, {
+                file,
+                content,
+                index: m.index,
+                matchLength: m[0].length,
+            })));
+        }
+        const lc = content.toLowerCase();
+        // Cheap prefilter; matches the separators the RE_WEAK_SSLMODE regex accepts
+        // (`sslmode`, `ssl-mode`, `ssl_mode`) so no supported form is gated out.
+        if (lc.includes("sslmode") || lc.includes("ssl-mode") || lc.includes("ssl_mode")) {
+            eachMatch(RE_WEAK_SSLMODE, scan, (m) => findings.push(findingFromRule(RULE_WEAK_SSLMODE, {
+                file,
+                content,
+                index: m.index,
+                matchLength: m[0].length,
+            })));
+        }
+        // SQL Server TDE: a classical RSA asymmetric key protecting the DEK.
+        if (lc.includes("asymmetric key")) {
+            eachMatch(RE_MSSQL_TDE_RSA, scan, (m) => findings.push(findingFromRule(RULE_MSSQL_TDE_RSA, {
+                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":"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","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 = allow | prefer | require` in any config/connection file — a\n *    mode that does NOT verify the server certificate, so the classical TLS session\n *    it negotiates is both MITM-able and harvestable. `disable` is excluded: it\n *    negotiates no TLS at all, so there is no key exchange to harvest (a plaintext\n *    concern, out of scope for a PQC-readiness scanner).\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport {\n  DOC_EXTENSIONS,\n  eachMatch,\n  findingFromRule,\n  hasExtension,\n  maskCommentLines,\n} from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION } from \"../cwe.js\";\n\nconst RE_PGCRYPTO = /\\bpgp_pub_(?:encrypt|decrypt)\\b/g;\n// Matches the no-verification TLS modes across libpq (`sslmode=require`), the\n// `PGSSLMODE` env var, MySQL (`ssl-mode=PREFERRED`/`REQUIRED`, hyphenated), and YAML\n// connection config (`sslmode: require`) — i.e. an optional `pg` prefix, `-`/`_` or no\n// separator, `:` or `=`, and the libpq/MySQL value spellings.\nconst RE_WEAK_SSLMODE =\n  /\\b(?:pg)?ssl[-_]?mode\\s*[:=]\\s*[\"']?(?:allow|prefer(?:red)?|require[d]?)\\b/gi;\n// SQL Server TDE: the database encryption key is protected by a classical RSA\n// asymmetric key / certificate. `CREATE ASYMMETRIC KEY … WITH ALGORITHM = RSA_2048`\n// is the distinctive form; the span between the two clauses is lazily bounded to keep\n// matching linear.\nconst RE_MSSQL_TDE_RSA = /\\bCREATE\\s+ASYMMETRIC\\s+KEY\\b[\\s\\S]{0,300}?\\bALGORITHM\\s*=\\s*RSA_\\d+/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_MSSQL_TDE_RSA: RuleMeta = {\n  id: \"db-tde-rsa\",\n  title: \"SQL Server TDE RSA key\",\n  description: \"SQL Server CREATE ASYMMETRIC KEY ... WITH ALGORITHM = RSA_* (TDE key protection)\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Transparent Data Encryption protects the database encryption key with a classical RSA asymmetric key; the at-rest data is harvest-now-decrypt-later exposed once the RSA key falls.\",\n  remediation:\n    \"Plan migration to a PQC KEM (ML-KEM-768) for TDE key protection as the database engine adds support; re-key long-lived encrypted databases.\",\n};\nconst RULE_WEAK_SSLMODE: RuleMeta = {\n  id: \"db-weak-sslmode\",\n  title: \"Database sslmode without verification\",\n  description: \"libpq sslmode is 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:\n    \"Classical crypto in database usage (pgcrypto public-key, SQL Server TDE, weak client sslmode)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: [RULE_PGCRYPTO, RULE_MSSQL_TDE_RSA, 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    // Mask SQL (`--`, single-line `/* … */`), shell/ini (`#`), and ini (`;`) line\n    // comments: a commented `-- pgp_pub_encrypt` or `; sslmode=require` is not active.\n    const scan = maskCommentLines(content, [\"#\", \"--\", \";\", \"/*\"]);\n    if (file.toLowerCase().endsWith(\".sql\") && content.includes(\"pgp_pub_\")) {\n      eachMatch(RE_PGCRYPTO, scan, (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    const lc = content.toLowerCase();\n    // Cheap prefilter; matches the separators the RE_WEAK_SSLMODE regex accepts\n    // (`sslmode`, `ssl-mode`, `ssl_mode`) so no supported form is gated out.\n    if (lc.includes(\"sslmode\") || lc.includes(\"ssl-mode\") || lc.includes(\"ssl_mode\")) {\n      eachMatch(RE_WEAK_SSLMODE, scan, (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    // SQL Server TDE: a classical RSA asymmetric key protecting the DEK.\n    if (lc.includes(\"asymmetric key\")) {\n      eachMatch(RE_MSSQL_TDE_RSA, scan, (m) =>\n        findings.push(\n          findingFromRule(RULE_MSSQL_TDE_RSA, {\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/dkim.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Config detector: classical DKIM email-signing keys and algorithms in DNS
+ * zone files, mail-server signer config (OpenDKIM), and captured
+ * `DKIM-Signature:` header fields (RFC 6376 + RFC 8463).
+ *
+ * DKIM (DomainKeys Identified Mail) authenticates the *origin* of email: the
+ * sending MTA signs selected header/body content with a private key, publishes
+ * the matching public key as a DNS TXT record at
+ * `<selector>._domainkey.<domain>`, and receivers verify the `DKIM-Signature`
+ * header against that published key. Like DNSSEC (see `dnssec.ts`), this is a
+ * pure *signature* surface: there is no confidentiality to harvest, so a DKIM
+ * key is NOT harvest-now-decrypt-later exposed (`hndl: false`). What breaks
+ * once a cryptographically-relevant quantum computer (CRQC) exists is
+ * unforgeability — an attacker who can derive the private key from the
+ * published public key can mint valid `DKIM-Signature` headers and spoof mail
+ * that passes DKIM/DMARC. So these findings are `category: "signature"`.
+ *
+ * Crypto surface, mapped to {@link AlgorithmFamily}:
+ *  - `k=rsa` DNS key-type tag / `a=rsa-sha256` / `a=rsa-sha1` (DKIM-Signature
+ *    algorithm tag) / OpenDKIM `SigningAlgorithm rsa-sha256|rsa-sha1`   → RSA
+ *  - `k=ed25519` DNS key-type tag / `a=ed25519-sha256` / OpenDKIM
+ *    `SigningAlgorithm ed25519-sha256` (RFC 8463)                        → EdDSA
+ *
+ * Ed25519 DKIM (RFC 8463) is MODERN but still CLASSICAL: rotating an RSA DKIM
+ * key to Ed25519 shrinks the DNS record and is good hygiene, but it is NOT a
+ * post-quantum fix — an Ed25519 signature is just as forgeable under a CRQC.
+ * The remediation text says so honestly: there is no standardized PQC DKIM yet;
+ * the only real action is to track IETF work.
+ *
+ * Two match shapes are covered per family, both gated to a small config
+ * extension set AND to a file-level DKIM marker (see `hasDkimMarker`) so the
+ * short tag tokens (`k=rsa`, `a=rsa-sha256`) can't fire on unrelated config:
+ *
+ *  1. DNS KEY-TYPE tag — `k=rsa` / `k=ed25519` inside a published DKIM TXT
+ *     record (`v=DKIM1; k=rsa; p=MIGf...`). Whitespace around `=` is tolerated.
+ *  2. SIGNING-ALGORITHM tag — the `a=` tag of a `DKIM-Signature` header
+ *     (`a=rsa-sha256`, `a=ed25519-sha256`) and the OpenDKIM `SigningAlgorithm`
+ *     directive (`SigningAlgorithm rsa-sha256`). The RSA variant deliberately
+ *     also matches the legacy `rsa-sha1`.
+ *
+ * Fast reject: `detect()` bails unless the file carries a DKIM-specific marker
+ * (`v=DKIM1`, `_domainkey`, a `DKIM-Signature` field, an OpenDKIM
+ * `SigningAlgorithm` directive, or a bare `k=rsa`/`k=ed25519` key-type tag).
+ * This stops the generic-looking `k=rsa` / `a=rsa-sha256` tokens from firing on
+ * an unrelated `.conf` that happens to contain an `a=`/`k=` assignment for its
+ * own reasons. Prose is excluded twice over: `appliesTo` restricts to config
+ * extensions (README/`.md` never applies), and `detect()` re-guards against
+ * {@link DOC_EXTENSIONS} defensively so a docs file that slipped through a
+ * broader gate could never be flagged for mentioning `k=rsa` in a sentence.
+ */
+import type { Detector } from "../types.js";
+/** Detects classical DKIM signing keys/algorithms in zone files and mail signer config. */
+export declare const dkimDetector: Detector;
+//# sourceMappingURL=dkim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dkim.d.ts","sourceRoot":"","sources":["../../src/detectors/dkim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA2F/D,2FAA2F;AAC3F,eAAO,MAAM,YAAY,EAAE,QA6B1B,CAAC"}

package/dist/detectors/dkim.js

@@ -0,0 +1,92 @@
+import { DOC_EXTENSIONS, eachMatch, findingFromRule, hasExtension, maskCommentLines, } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+// DKIM records live in DNS zone files (`.zone`/`.db`), mail-server signer config
+// (`.conf`), and captured header/TXT fixtures (`.txt`). Gated further by
+// `hasDkimMarker` so the short tag tokens can't fire on unrelated config.
+const DKIM_EXTENSIONS = [".zone", ".db", ".conf", ".txt"];
+// --- RSA (k=rsa / rsa-sha256 / rsa-sha1) ---
+// DNS key-type tag: `k=rsa` in a published DKIM TXT record. Whitespace tolerated
+// around `=`; case-insensitive since tags are conventionally lowercase but not
+// required to be. `\b` after `rsa` keeps it from matching `rsa-...` substrings.
+const RE_RSA_KEYTAG = /\bk\s*=\s*rsa\b/gi;
+// DKIM-Signature `a=` tag: `a=rsa-sha256` / `a=rsa-sha1`.
+const RE_RSA_ALGTAG = /\ba\s*=\s*rsa-sha(?:256|1)\b/gi;
+// OpenDKIM signer directive: `SigningAlgorithm rsa-sha256` / `rsa-sha1`.
+const RE_RSA_OPENDKIM = /\bSigningAlgorithm\s+rsa-sha(?:256|1)\b/gi;
+// --- EdDSA (k=ed25519 / ed25519-sha256, RFC 8463) ---
+const RE_EDDSA_KEYTAG = /\bk\s*=\s*ed25519\b/gi;
+const RE_EDDSA_ALGTAG = /\ba\s*=\s*ed25519-sha256\b/gi;
+const RE_EDDSA_OPENDKIM = /\bSigningAlgorithm\s+ed25519-sha256\b/gi;
+const RULE_DKIM_RSA = {
+    id: "dkim-rsa-key",
+    title: "DKIM RSA signing key/algorithm",
+    description: "DKIM email signing configured with a classical RSA key/algorithm (k=rsa, a=rsa-sha256/rsa-sha1)",
+    category: "signature",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "DKIM email signing uses a classical RSA key/algorithm (k=rsa / rsa-sha256 / rsa-sha1); DKIM-Signature headers become forgeable once a CRQC exists, allowing DKIM/DMARC-passing spoofed mail.",
+    remediation: "There is no standardized post-quantum DKIM algorithm yet — track IETF work; note that rotating RSA to Ed25519 (RFC 8463) is good hygiene but NOT a PQC fix, since Ed25519 is still classical and equally forgeable under a CRQC.",
+};
+const RULE_DKIM_EDDSA = {
+    id: "dkim-ed25519-key",
+    title: "DKIM Ed25519 signing key/algorithm",
+    description: "DKIM email signing configured with a classical Ed25519 key/algorithm (k=ed25519, a=ed25519-sha256, RFC 8463)",
+    category: "signature",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "EdDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "DKIM email signing uses an Ed25519 key/algorithm (k=ed25519 / ed25519-sha256, RFC 8463) — modern but still classical; DKIM-Signature headers become forgeable once a CRQC exists.",
+    remediation: "There is no standardized post-quantum DKIM algorithm yet — track IETF work. Ed25519 is already the smaller/modern DKIM choice but is NOT post-quantum: it stays forgeable under a CRQC, so no rotation today resolves the quantum exposure.",
+};
+/**
+ * True when `content` carries a DKIM-specific marker. Deliberately does NOT accept
+ * a bare `k=rsa` / `k=ed25519` tag as its own marker: that tag is exactly what the
+ * RSA/EdDSA rules match, so treating it as the gate would be self-satisfying and
+ * fire on unrelated prose ("set `k=rsa` for the legacy importer"). A real DKIM
+ * record always also carries `v=DKIM1`, `_domainkey`, a `DKIM-Signature` field, or
+ * the OpenDKIM `SigningAlgorithm` directive — one of those must be present.
+ */
+function hasDkimMarker(content) {
+    return (/\bDKIM1\b/i.test(content) ||
+        content.includes("_domainkey") ||
+        /DKIM-Signature/i.test(content) ||
+        /\bSigningAlgorithm\b/i.test(content));
+}
+const DKIM_RULES = [
+    { meta: RULE_DKIM_RSA, res: [RE_RSA_KEYTAG, RE_RSA_ALGTAG, RE_RSA_OPENDKIM] },
+    { meta: RULE_DKIM_EDDSA, res: [RE_EDDSA_KEYTAG, RE_EDDSA_ALGTAG, RE_EDDSA_OPENDKIM] },
+];
+/** Detects classical DKIM signing keys/algorithms in zone files and mail signer config. */
+export const dkimDetector = {
+    id: "dkim-crypto",
+    description: "Classical DKIM email signing keys/algorithms in zone files / mail signer config",
+    scope: "config",
+    language: "any",
+    rules: DKIM_RULES.map((r) => r.meta),
+    appliesTo: (f) => hasExtension(f, DKIM_EXTENSIONS) && !hasExtension(f, DOC_EXTENSIONS),
+    detect({ file, content }) {
+        // Defensive doc guard: even if a broader gate ever let a prose file through,
+        // a README mentioning `k=rsa` in a sentence must never be flagged.
+        if (hasExtension(file, DOC_EXTENSIONS))
+            return [];
+        if (!hasDkimMarker(content))
+            return [];
+        // Mask whole comment lines so a commented-out record can't fire: zone files
+        // use `;`, mail/OpenDKIM config uses `#` and `//`. Offsets are preserved so
+        // finding line/column/snippet stay exact for the live lines that remain.
+        const scan = maskCommentLines(content, [";", "#", "//"]);
+        const findings = [];
+        for (const { meta, res } of DKIM_RULES) {
+            for (const re of res) {
+                eachMatch(re, scan, (m) => findings.push(findingFromRule(meta, { file, content, index: m.index, matchLength: m[0].length })));
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=dkim.js.map

package/dist/detectors/dkim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dkim.js","sourceRoot":"","sources":["../../src/detectors/dkim.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Config detector: classical DKIM email-signing keys and algorithms in DNS\n * zone files, mail-server signer config (OpenDKIM), and captured\n * `DKIM-Signature:` header fields (RFC 6376 + RFC 8463).\n *\n * DKIM (DomainKeys Identified Mail) authenticates the *origin* of email: the\n * sending MTA signs selected header/body content with a private key, publishes\n * the matching public key as a DNS TXT record at\n * `<selector>._domainkey.<domain>`, and receivers verify the `DKIM-Signature`\n * header against that published key. Like DNSSEC (see `dnssec.ts`), this is a\n * pure *signature* surface: there is no confidentiality to harvest, so a DKIM\n * key is NOT harvest-now-decrypt-later exposed (`hndl: false`). What breaks\n * once a cryptographically-relevant quantum computer (CRQC) exists is\n * unforgeability — an attacker who can derive the private key from the\n * published public key can mint valid `DKIM-Signature` headers and spoof mail\n * that passes DKIM/DMARC. So these findings are `category: \"signature\"`.\n *\n * Crypto surface, mapped to {@link AlgorithmFamily}:\n *  - `k=rsa` DNS key-type tag / `a=rsa-sha256` / `a=rsa-sha1` (DKIM-Signature\n *    algorithm tag) / OpenDKIM `SigningAlgorithm rsa-sha256|rsa-sha1`   → RSA\n *  - `k=ed25519` DNS key-type tag / `a=ed25519-sha256` / OpenDKIM\n *    `SigningAlgorithm ed25519-sha256` (RFC 8463)                        → EdDSA\n *\n * Ed25519 DKIM (RFC 8463) is MODERN but still CLASSICAL: rotating an RSA DKIM\n * key to Ed25519 shrinks the DNS record and is good hygiene, but it is NOT a\n * post-quantum fix — an Ed25519 signature is just as forgeable under a CRQC.\n * The remediation text says so honestly: there is no standardized PQC DKIM yet;\n * the only real action is to track IETF work.\n *\n * Two match shapes are covered per family, both gated to a small config\n * extension set AND to a file-level DKIM marker (see `hasDkimMarker`) so the\n * short tag tokens (`k=rsa`, `a=rsa-sha256`) can't fire on unrelated config:\n *\n *  1. DNS KEY-TYPE tag — `k=rsa` / `k=ed25519` inside a published DKIM TXT\n *     record (`v=DKIM1; k=rsa; p=MIGf...`). Whitespace around `=` is tolerated.\n *  2. SIGNING-ALGORITHM tag — the `a=` tag of a `DKIM-Signature` header\n *     (`a=rsa-sha256`, `a=ed25519-sha256`) and the OpenDKIM `SigningAlgorithm`\n *     directive (`SigningAlgorithm rsa-sha256`). The RSA variant deliberately\n *     also matches the legacy `rsa-sha1`.\n *\n * Fast reject: `detect()` bails unless the file carries a DKIM-specific marker\n * (`v=DKIM1`, `_domainkey`, a `DKIM-Signature` field, an OpenDKIM\n * `SigningAlgorithm` directive, or a bare `k=rsa`/`k=ed25519` key-type tag).\n * This stops the generic-looking `k=rsa` / `a=rsa-sha256` tokens from firing on\n * an unrelated `.conf` that happens to contain an `a=`/`k=` assignment for its\n * own reasons. Prose is excluded twice over: `appliesTo` restricts to config\n * extensions (README/`.md` never applies), and `detect()` re-guards against\n * {@link DOC_EXTENSIONS} defensively so a docs file that slipped through a\n * broader gate could never be flagged for mentioning `k=rsa` in a sentence.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport {\n  DOC_EXTENSIONS,\n  eachMatch,\n  findingFromRule,\n  hasExtension,\n  maskCommentLines,\n} from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO } from \"../cwe.js\";\n\n// DKIM records live in DNS zone files (`.zone`/`.db`), mail-server signer config\n// (`.conf`), and captured header/TXT fixtures (`.txt`). Gated further by\n// `hasDkimMarker` so the short tag tokens can't fire on unrelated config.\nconst DKIM_EXTENSIONS: readonly string[] = [\".zone\", \".db\", \".conf\", \".txt\"];\n\n// --- RSA (k=rsa / rsa-sha256 / rsa-sha1) ---\n// DNS key-type tag: `k=rsa` in a published DKIM TXT record. Whitespace tolerated\n// around `=`; case-insensitive since tags are conventionally lowercase but not\n// required to be. `\\b` after `rsa` keeps it from matching `rsa-...` substrings.\nconst RE_RSA_KEYTAG = /\\bk\\s*=\\s*rsa\\b/gi;\n// DKIM-Signature `a=` tag: `a=rsa-sha256` / `a=rsa-sha1`.\nconst RE_RSA_ALGTAG = /\\ba\\s*=\\s*rsa-sha(?:256|1)\\b/gi;\n// OpenDKIM signer directive: `SigningAlgorithm rsa-sha256` / `rsa-sha1`.\nconst RE_RSA_OPENDKIM = /\\bSigningAlgorithm\\s+rsa-sha(?:256|1)\\b/gi;\n\n// --- EdDSA (k=ed25519 / ed25519-sha256, RFC 8463) ---\nconst RE_EDDSA_KEYTAG = /\\bk\\s*=\\s*ed25519\\b/gi;\nconst RE_EDDSA_ALGTAG = /\\ba\\s*=\\s*ed25519-sha256\\b/gi;\nconst RE_EDDSA_OPENDKIM = /\\bSigningAlgorithm\\s+ed25519-sha256\\b/gi;\n\nconst RULE_DKIM_RSA: RuleMeta = {\n  id: \"dkim-rsa-key\",\n  title: \"DKIM RSA signing key/algorithm\",\n  description:\n    \"DKIM email signing configured with a classical RSA key/algorithm (k=rsa, a=rsa-sha256/rsa-sha1)\",\n  category: \"signature\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"DKIM email signing uses a classical RSA key/algorithm (k=rsa / rsa-sha256 / rsa-sha1); DKIM-Signature headers become forgeable once a CRQC exists, allowing DKIM/DMARC-passing spoofed mail.\",\n  remediation:\n    \"There is no standardized post-quantum DKIM algorithm yet — track IETF work; note that rotating RSA to Ed25519 (RFC 8463) is good hygiene but NOT a PQC fix, since Ed25519 is still classical and equally forgeable under a CRQC.\",\n};\n\nconst RULE_DKIM_EDDSA: RuleMeta = {\n  id: \"dkim-ed25519-key\",\n  title: \"DKIM Ed25519 signing key/algorithm\",\n  description:\n    \"DKIM email signing configured with a classical Ed25519 key/algorithm (k=ed25519, a=ed25519-sha256, RFC 8463)\",\n  category: \"signature\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"DKIM email signing uses an Ed25519 key/algorithm (k=ed25519 / ed25519-sha256, RFC 8463) — modern but still classical; DKIM-Signature headers become forgeable once a CRQC exists.\",\n  remediation:\n    \"There is no standardized post-quantum DKIM algorithm yet — track IETF work. Ed25519 is already the smaller/modern DKIM choice but is NOT post-quantum: it stays forgeable under a CRQC, so no rotation today resolves the quantum exposure.\",\n};\n\n/**\n * True when `content` carries a DKIM-specific marker. Deliberately does NOT accept\n * a bare `k=rsa` / `k=ed25519` tag as its own marker: that tag is exactly what the\n * RSA/EdDSA rules match, so treating it as the gate would be self-satisfying and\n * fire on unrelated prose (\"set `k=rsa` for the legacy importer\"). A real DKIM\n * record always also carries `v=DKIM1`, `_domainkey`, a `DKIM-Signature` field, or\n * the OpenDKIM `SigningAlgorithm` directive — one of those must be present.\n */\nfunction hasDkimMarker(content: string): boolean {\n  return (\n    /\\bDKIM1\\b/i.test(content) ||\n    content.includes(\"_domainkey\") ||\n    /DKIM-Signature/i.test(content) ||\n    /\\bSigningAlgorithm\\b/i.test(content)\n  );\n}\n\ninterface DkimRule {\n  meta: RuleMeta;\n  res: readonly RegExp[];\n}\n\nconst DKIM_RULES: readonly DkimRule[] = [\n  { meta: RULE_DKIM_RSA, res: [RE_RSA_KEYTAG, RE_RSA_ALGTAG, RE_RSA_OPENDKIM] },\n  { meta: RULE_DKIM_EDDSA, res: [RE_EDDSA_KEYTAG, RE_EDDSA_ALGTAG, RE_EDDSA_OPENDKIM] },\n];\n\n/** Detects classical DKIM signing keys/algorithms in zone files and mail signer config. */\nexport const dkimDetector: Detector = {\n  id: \"dkim-crypto\",\n  description: \"Classical DKIM email signing keys/algorithms in zone files / mail signer config\",\n  scope: \"config\",\n  language: \"any\",\n  rules: DKIM_RULES.map((r) => r.meta),\n  appliesTo: (f) => hasExtension(f, DKIM_EXTENSIONS) && !hasExtension(f, DOC_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    // Defensive doc guard: even if a broader gate ever let a prose file through,\n    // a README mentioning `k=rsa` in a sentence must never be flagged.\n    if (hasExtension(file, DOC_EXTENSIONS)) return [];\n    if (!hasDkimMarker(content)) return [];\n\n    // Mask whole comment lines so a commented-out record can't fire: zone files\n    // use `;`, mail/OpenDKIM config uses `#` and `//`. Offsets are preserved so\n    // finding line/column/snippet stay exact for the live lines that remain.\n    const scan = maskCommentLines(content, [\";\", \"#\", \"//\"]);\n    const findings: Finding[] = [];\n    for (const { meta, res } of DKIM_RULES) {\n      for (const re of res) {\n        eachMatch(re, scan, (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/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;AAoH/D,mFAAmF;AACnF,eAAO,MAAM,cAAc,EAAE,QA0B5B,CAAC"}

package/dist/detectors/dnssec.js

@@ -0,0 +1,116 @@
+import { eachMatch, findingFromRule, hasExtension, maskCommentLines } 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. ---
+// Case-insensitive: BIND `dnssec-policy` and Knot config conventionally write the
+// mnemonics in lowercase (`algorithm rsasha256;`, `algorithm ed25519;`), so a
+// case-sensitive match would miss the primary real-world signer-config syntax. Still
+// gated by `hasDnssecMarker` + the DNSSEC extensions, so generic tokens can't fire.
+const RE_NAMED_RSA = /\bRSASHA(?:256|512|1(?:-NSEC3-SHA1)?)\b/gi;
+const RE_NAMED_ECDSA = /\bECDSAP(?:256SHA256|384SHA384)\b/gi;
+const RE_NAMED_EDDSA = /\bED(?:25519|448)\b/gi;
+// 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: `[C]DNSKEY <flags> 3 <algorithm>` presentation RDATA (RFC 4034
+// §2). `C?` also matches CDNSKEY (child-zone key with identical RDATA, RFC 7344). ---
+const RE_DNSKEY_RSA = new RegExp(`\\bC?DNSKEY\\s+\\d+\\s+3\\s+(?:${NUM_RSA})\\b`, "g");
+const RE_DNSKEY_ECDSA = new RegExp(`\\bC?DNSKEY\\s+\\d+\\s+3\\s+(?:${NUM_ECDSA})\\b`, "g");
+const RE_DNSKEY_EDDSA = new RegExp(`\\bC?DNSKEY\\s+\\d+\\s+3\\s+(?:${NUM_EDDSA})\\b`, "g");
+const RE_DNSKEY_DSA = new RegExp(`\\bC?DNSKEY\\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 [];
+        // Mask whole comment lines so a commented-out algorithm can't fire: zone files
+        // use `;`, named.conf uses `#` and `//`. These extensions are not centrally
+        // stripped; offsets are preserved so finding locations stay exact.
+        const scan = maskCommentLines(content, [";", "#", "//"]);
+        const findings = [];
+        for (const { meta, res } of DNSSEC_RULES) {
+            for (const re of res) {
+                eachMatch(re, scan, (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, maskCommentLines } 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. ---\n// Case-insensitive: BIND `dnssec-policy` and Knot config conventionally write the\n// mnemonics in lowercase (`algorithm rsasha256;`, `algorithm ed25519;`), so a\n// case-sensitive match would miss the primary real-world signer-config syntax. Still\n// gated by `hasDnssecMarker` + the DNSSEC extensions, so generic tokens can't fire.\nconst RE_NAMED_RSA = /\\bRSASHA(?:256|512|1(?:-NSEC3-SHA1)?)\\b/gi;\nconst RE_NAMED_ECDSA = /\\bECDSAP(?:256SHA256|384SHA384)\\b/gi;\nconst RE_NAMED_EDDSA = /\\bED(?:25519|448)\\b/gi;\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: `[C]DNSKEY <flags> 3 <algorithm>` presentation RDATA (RFC 4034\n// §2). `C?` also matches CDNSKEY (child-zone key with identical RDATA, RFC 7344). ---\nconst RE_DNSKEY_RSA = new RegExp(`\\\\bC?DNSKEY\\\\s+\\\\d+\\\\s+3\\\\s+(?:${NUM_RSA})\\\\b`, \"g\");\nconst RE_DNSKEY_ECDSA = new RegExp(`\\\\bC?DNSKEY\\\\s+\\\\d+\\\\s+3\\\\s+(?:${NUM_ECDSA})\\\\b`, \"g\");\nconst RE_DNSKEY_EDDSA = new RegExp(`\\\\bC?DNSKEY\\\\s+\\\\d+\\\\s+3\\\\s+(?:${NUM_EDDSA})\\\\b`, \"g\");\nconst RE_DNSKEY_DSA = new RegExp(`\\\\bC?DNSKEY\\\\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    // Mask whole comment lines so a commented-out algorithm can't fire: zone files\n    // use `;`, named.conf uses `#` and `//`. These extensions are not centrally\n    // stripped; offsets are preserved so finding locations stay exact.\n    const scan = maskCommentLines(content, [\";\", \"#\", \"//\"]);\n    const findings: Finding[] = [];\n    for (const { meta, res } of DNSSEC_RULES) {\n      for (const re of res) {\n        eachMatch(re, scan, (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;AA4IhF,2EAA2E;AAC3E,eAAO,MAAM,cAAc,EAAE,QA8G5B,CAAC"}