@quantakrypto/core 0.4.3 → 0.5.0

package/dist/detectors/jwk.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Config detector: classical key material in JSON Web Keys (JWK / JWKS, RFC 7517
+ * / 7518). JWKs appear in `.json` / `.jwks` files, OIDC discovery documents, and
+ * config — a real key-material surface the source packs (which look at *code*)
+ * and the PEM detector (which looks at PEM markers) both miss.
+ *
+ * Detection keys off the JWK's distinctive JSON fields:
+ *  - `"kty":"RSA"`                          → classical RSA key.
+ *  - `"crv":"P-256"|"P-384"|"P-521"|…`      → classical EC key (ECDSA + ECDH).
+ *  - `"crv":"Ed25519"|"Ed448"`              → EdDSA signing key.
+ *  - `"crv":"X25519"|"X448"`                → classical Montgomery-curve key agreement.
+ *
+ * Usage-aware classification: when a key's surrounding `"use"` / `"alg"` marks it
+ * as a SIGNING key (`use:"sig"`, or an `RS`/`PS`/`ES` signature alg), the finding
+ * is a `signature` (`hndl:false`) — a signing key is forgeable at a CRQC but not
+ * harvest-now exposed. An encryption/unspecified key stays `hndl:true`.
+ *
+ * Deferrals to avoid double-counting: skipped on doc extensions (a README JWK
+ * example is not live) and inside CloudFormation/ARM templates, where the
+ * cloudformation detector owns the `kty` of a `Microsoft.KeyVault` key resource.
+ */
+import type { Detector } from "../types.js";
+/** Detects classical JSON Web Key (JWK/JWKS) material in any JSON/text file. */
+export declare const jwkDetector: Detector;
+//# sourceMappingURL=jwk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jwk.d.ts","sourceRoot":"","sources":["../../src/detectors/jwk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAqG/D,gFAAgF;AAChF,eAAO,MAAM,WAAW,EAAE,QA8CzB,CAAC"}

package/dist/detectors/jwk.js

@@ -0,0 +1,131 @@
+import { DOC_EXTENSIONS, eachMatch, enclosingObject, findingFromRule, hasExtension, } from "../detect-utils.js";
+import { isCloudTemplateFile } from "./cloudformation.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+const JWK_RULES = [
+    {
+        re: /"kty"\s*:\s*"RSA"/g,
+        meta: {
+            id: "jwk-rsa",
+            title: "RSA JSON Web Key (JWK)",
+            description: 'JWK with "kty":"RSA" (RFC 7518)',
+            category: "certificate",
+            severity: "medium",
+            confidence: "high",
+            algorithm: "RSA",
+            hndl: true,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: "RSA JSON Web Key (JWK); classical RSA, not quantum-safe.",
+            remediation: "Re-issue with PQC keys (ML-KEM-768 for encryption, ML-DSA-65 for signatures).",
+        },
+    },
+    {
+        re: /"crv"\s*:\s*"(?:P-256K?|P-384|P-521|secp256k1)"/g,
+        meta: {
+            id: "jwk-ec",
+            title: "EC JSON Web Key (JWK)",
+            description: 'JWK with an "crv" naming a NIST/secp curve (RFC 7518)',
+            category: "key-exchange",
+            severity: "medium",
+            confidence: "high",
+            algorithm: "ECDH",
+            hndl: true,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: "Elliptic-curve JSON Web Key (JWK); a classical EC key feeds BOTH ECDSA signatures and ECDH key agreement — the ECDH path is harvest-now-decrypt-later exposed.",
+            remediation: "For key agreement: hybrid X25519MLKEM768 (ML-KEM-768). For signatures: ML-DSA-65 (FIPS 204).",
+        },
+    },
+    {
+        re: /"crv"\s*:\s*"Ed(?:25519|448)"/g,
+        meta: {
+            id: "jwk-eddsa",
+            title: "EdDSA JSON Web Key (JWK)",
+            description: 'JWK OKP key with "crv":"Ed25519"/"Ed448" (RFC 8037)',
+            category: "signature",
+            severity: "low",
+            confidence: "high",
+            algorithm: "EdDSA",
+            hndl: false,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: "EdDSA (Ed25519/Ed448) JSON Web Key (JWK); classical and forgeable by a quantum attacker.",
+            remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).",
+        },
+    },
+    {
+        re: /"crv"\s*:\s*"X(?:25519|448)"/g,
+        meta: {
+            id: "jwk-xdh",
+            title: "X25519/X448 JSON Web Key (JWK)",
+            description: 'JWK OKP key with "crv":"X25519"/"X448" (RFC 8037)',
+            category: "key-exchange",
+            severity: "medium",
+            confidence: "high",
+            algorithm: "X25519",
+            hndl: true,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: "X25519/X448 JSON Web Key (JWK); modern but classical key agreement, and harvest-now-decrypt-later exposed.",
+            remediation: "Migrate key agreement to hybrid X25519MLKEM768 (ML-KEM-768).",
+        },
+    },
+];
+/**
+ * True when THIS key's own object marks it as a signing key via `use`/`alg`. The
+ * caller passes the enclosing `{…}` object so a neighbouring key in a JWKS array
+ * can't contaminate the result, and an explicit `"use":"enc"` on the key always
+ * wins (never classify an encryption key as a signature).
+ */
+function isSigningUse(objectText, sigAlg) {
+    if (/"use"\s*:\s*"enc"/.test(objectText))
+        return false;
+    return /"use"\s*:\s*"sig"/.test(objectText) || sigAlg.test(objectText);
+}
+const RSA_SIG_ALG = /"alg"\s*:\s*"(?:RS|PS)(?:256|384|512)"/;
+const EC_SIG_ALG = /"alg"\s*:\s*"ES(?:256K?|384|512)"/;
+/** Detects classical JSON Web Key (JWK/JWKS) material in any JSON/text file. */
+export const jwkDetector = {
+    id: "jwk-material",
+    description: "Classical key material in JSON Web Keys (JWK / JWKS)",
+    scope: "config",
+    language: "any",
+    rules: JWK_RULES.map((r) => r.meta),
+    appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS),
+    detect({ file, content }) {
+        // Fast reject: a JWK always has one of these two members.
+        if (!content.includes('"kty"') && !content.includes('"crv"'))
+            return [];
+        // The ONLY overlap with the cloudformation detector is the ARM Key Vault key
+        // `kty:"RSA"` (cfn-arm-keyvault-rsa), which only fires when Microsoft.KeyVault is
+        // present. Defer just the RSA rule in that case — everything else (crv keys, and
+        // JWKs embedded in AWS CloudFormation, which cfn does not own) is still reported.
+        const isArm = isCloudTemplateFile(file, content) && content.includes("Microsoft.KeyVault");
+        const findings = [];
+        for (const rule of JWK_RULES) {
+            eachMatch(rule.re, content, (m) => {
+                if (rule.meta.id === "jwk-rsa" && isArm)
+                    return; // cfn-arm-keyvault-rsa owns it
+                const at = { file, content, index: m.index, matchLength: m[0].length };
+                // Analyse the key's OWN enclosing object so a neighbouring key in a JWKS
+                // array can't flip this key's sig/enc classification.
+                const obj = enclosingObject(content, m.index);
+                let overrides;
+                if (rule.meta.id === "jwk-rsa" && isSigningUse(obj, RSA_SIG_ALG)) {
+                    overrides = {
+                        category: "signature",
+                        hndl: false,
+                        message: "RSA JSON Web Key (JWK) used for signing (RS*/PS*); forgeable by a quantum attacker.",
+                    };
+                }
+                else if (rule.meta.id === "jwk-ec" && isSigningUse(obj, EC_SIG_ALG)) {
+                    overrides = {
+                        category: "signature",
+                        algorithm: "ECDSA",
+                        hndl: false,
+                        message: "Elliptic-curve JSON Web Key (JWK) used for ECDSA signing; forgeable by a quantum attacker.",
+                    };
+                }
+                findings.push(findingFromRule(rule.meta, at, overrides));
+            });
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=jwk.js.map

package/dist/detectors/jwk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwk.js","sourceRoot":"","sources":["../../src/detectors/jwk.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Config detector: classical key material in JSON Web Keys (JWK / JWKS, RFC 7517\n * / 7518). JWKs appear in `.json` / `.jwks` files, OIDC discovery documents, and\n * config — a real key-material surface the source packs (which look at *code*)\n * and the PEM detector (which looks at PEM markers) both miss.\n *\n * Detection keys off the JWK's distinctive JSON fields:\n *  - `\"kty\":\"RSA\"`                          → classical RSA key.\n *  - `\"crv\":\"P-256\"|\"P-384\"|\"P-521\"|…`      → classical EC key (ECDSA + ECDH).\n *  - `\"crv\":\"Ed25519\"|\"Ed448\"`              → EdDSA signing key.\n *  - `\"crv\":\"X25519\"|\"X448\"`                → classical Montgomery-curve key agreement.\n *\n * Usage-aware classification: when a key's surrounding `\"use\"` / `\"alg\"` marks it\n * as a SIGNING key (`use:\"sig\"`, or an `RS`/`PS`/`ES` signature alg), the finding\n * is a `signature` (`hndl:false`) — a signing key is forgeable at a CRQC but not\n * harvest-now exposed. An encryption/unspecified key stays `hndl:true`.\n *\n * Deferrals to avoid double-counting: skipped on doc extensions (a README JWK\n * example is not live) and inside CloudFormation/ARM templates, where the\n * cloudformation detector owns the `kty` of a `Microsoft.KeyVault` key resource.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport {\n  DOC_EXTENSIONS,\n  eachMatch,\n  enclosingObject,\n  findingFromRule,\n  hasExtension,\n} from \"../detect-utils.js\";\nimport { isCloudTemplateFile } from \"./cloudformation.js\";\nimport { CWE_BROKEN_CRYPTO } from \"../cwe.js\";\n\ninterface JwkRule {\n  re: RegExp;\n  meta: RuleMeta;\n}\n\nconst JWK_RULES: JwkRule[] = [\n  {\n    re: /\"kty\"\\s*:\\s*\"RSA\"/g,\n    meta: {\n      id: \"jwk-rsa\",\n      title: \"RSA JSON Web Key (JWK)\",\n      description: 'JWK with \"kty\":\"RSA\" (RFC 7518)',\n      category: \"certificate\",\n      severity: \"medium\",\n      confidence: \"high\",\n      algorithm: \"RSA\",\n      hndl: true,\n      cwe: CWE_BROKEN_CRYPTO,\n      message: \"RSA JSON Web Key (JWK); classical RSA, not quantum-safe.\",\n      remediation: \"Re-issue with PQC keys (ML-KEM-768 for encryption, ML-DSA-65 for signatures).\",\n    },\n  },\n  {\n    re: /\"crv\"\\s*:\\s*\"(?:P-256K?|P-384|P-521|secp256k1)\"/g,\n    meta: {\n      id: \"jwk-ec\",\n      title: \"EC JSON Web Key (JWK)\",\n      description: 'JWK with an \"crv\" naming a NIST/secp curve (RFC 7518)',\n      category: \"key-exchange\",\n      severity: \"medium\",\n      confidence: \"high\",\n      algorithm: \"ECDH\",\n      hndl: true,\n      cwe: CWE_BROKEN_CRYPTO,\n      message:\n        \"Elliptic-curve JSON Web Key (JWK); a classical EC key feeds BOTH ECDSA signatures and ECDH key agreement — the ECDH path is harvest-now-decrypt-later exposed.\",\n      remediation:\n        \"For key agreement: hybrid X25519MLKEM768 (ML-KEM-768). For signatures: ML-DSA-65 (FIPS 204).\",\n    },\n  },\n  {\n    re: /\"crv\"\\s*:\\s*\"Ed(?:25519|448)\"/g,\n    meta: {\n      id: \"jwk-eddsa\",\n      title: \"EdDSA JSON Web Key (JWK)\",\n      description: 'JWK OKP key with \"crv\":\"Ed25519\"/\"Ed448\" (RFC 8037)',\n      category: \"signature\",\n      severity: \"low\",\n      confidence: \"high\",\n      algorithm: \"EdDSA\",\n      hndl: false,\n      cwe: CWE_BROKEN_CRYPTO,\n      message:\n        \"EdDSA (Ed25519/Ed448) JSON Web Key (JWK); classical and forgeable by a quantum attacker.\",\n      remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).\",\n    },\n  },\n  {\n    re: /\"crv\"\\s*:\\s*\"X(?:25519|448)\"/g,\n    meta: {\n      id: \"jwk-xdh\",\n      title: \"X25519/X448 JSON Web Key (JWK)\",\n      description: 'JWK OKP key with \"crv\":\"X25519\"/\"X448\" (RFC 8037)',\n      category: \"key-exchange\",\n      severity: \"medium\",\n      confidence: \"high\",\n      algorithm: \"X25519\",\n      hndl: true,\n      cwe: CWE_BROKEN_CRYPTO,\n      message:\n        \"X25519/X448 JSON Web Key (JWK); modern but classical key agreement, and harvest-now-decrypt-later exposed.\",\n      remediation: \"Migrate key agreement to hybrid X25519MLKEM768 (ML-KEM-768).\",\n    },\n  },\n];\n\n/**\n * True when THIS key's own object marks it as a signing key via `use`/`alg`. The\n * caller passes the enclosing `{…}` object so a neighbouring key in a JWKS array\n * can't contaminate the result, and an explicit `\"use\":\"enc\"` on the key always\n * wins (never classify an encryption key as a signature).\n */\nfunction isSigningUse(objectText: string, sigAlg: RegExp): boolean {\n  if (/\"use\"\\s*:\\s*\"enc\"/.test(objectText)) return false;\n  return /\"use\"\\s*:\\s*\"sig\"/.test(objectText) || sigAlg.test(objectText);\n}\n\nconst RSA_SIG_ALG = /\"alg\"\\s*:\\s*\"(?:RS|PS)(?:256|384|512)\"/;\nconst EC_SIG_ALG = /\"alg\"\\s*:\\s*\"ES(?:256K?|384|512)\"/;\n\n/** Detects classical JSON Web Key (JWK/JWKS) material in any JSON/text file. */\nexport const jwkDetector: Detector = {\n  id: \"jwk-material\",\n  description: \"Classical key material in JSON Web Keys (JWK / JWKS)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: JWK_RULES.map((r) => r.meta),\n  appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    // Fast reject: a JWK always has one of these two members.\n    if (!content.includes('\"kty\"') && !content.includes('\"crv\"')) return [];\n    // The ONLY overlap with the cloudformation detector is the ARM Key Vault key\n    // `kty:\"RSA\"` (cfn-arm-keyvault-rsa), which only fires when Microsoft.KeyVault is\n    // present. Defer just the RSA rule in that case — everything else (crv keys, and\n    // JWKs embedded in AWS CloudFormation, which cfn does not own) is still reported.\n    const isArm = isCloudTemplateFile(file, content) && content.includes(\"Microsoft.KeyVault\");\n\n    const findings: Finding[] = [];\n    for (const rule of JWK_RULES) {\n      eachMatch(rule.re, content, (m) => {\n        if (rule.meta.id === \"jwk-rsa\" && isArm) return; // cfn-arm-keyvault-rsa owns it\n        const at = { file, content, index: m.index, matchLength: m[0].length };\n        // Analyse the key's OWN enclosing object so a neighbouring key in a JWKS\n        // array can't flip this key's sig/enc classification.\n        const obj = enclosingObject(content, m.index);\n        let overrides;\n        if (rule.meta.id === \"jwk-rsa\" && isSigningUse(obj, RSA_SIG_ALG)) {\n          overrides = {\n            category: \"signature\" as const,\n            hndl: false,\n            message:\n              \"RSA JSON Web Key (JWK) used for signing (RS*/PS*); forgeable by a quantum attacker.\",\n          };\n        } else if (rule.meta.id === \"jwk-ec\" && isSigningUse(obj, EC_SIG_ALG)) {\n          overrides = {\n            category: \"signature\" as const,\n            algorithm: \"ECDSA\" as const,\n            hndl: false,\n            message:\n              \"Elliptic-curve JSON Web Key (JWK) used for ECDSA signing; forgeable by a quantum attacker.\",\n          };\n        }\n        findings.push(findingFromRule(rule.meta, at, overrides));\n      });\n    }\n    return findings;\n  },\n};\n"]}

package/dist/detectors/k8s.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Config detector: classical crypto in Kubernetes manifests — cert-manager key
+ * algorithms and service-mesh (Istio) TLS floors. These mint the certificates
+ * and secure the pod-to-pod traffic of a cluster, a surface neither the language
+ * packs nor the Terraform detector see.
+ *
+ * Covered (gated by a cert-manager / Istio marker in the document to keep the
+ * generic `algorithm:` / `minProtocolVersion:` keys from firing on unrelated YAML):
+ *  - cert-manager `Certificate`/`Issuer` `privateKey.algorithm` (or legacy
+ *    `keyAlgorithm`): `RSA` | `ECDSA` | `Ed25519`.
+ *  - Istio `minProtocolVersion: TLSV1_0 | TLSV1_1` — a legacy TLS floor on mesh
+ *    traffic, whose (EC)DHE key exchange is classical and harvestable.
+ */
+import type { Detector } from "../types.js";
+/** Detects classical cert-manager keys and legacy Istio TLS floors in K8s YAML. */
+export declare const k8sDetector: Detector;
+//# sourceMappingURL=k8s.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"k8s.d.ts","sourceRoot":"","sources":["../../src/detectors/k8s.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAoE/D,mFAAmF;AACnF,eAAO,MAAM,WAAW,EAAE,QAgCzB,CAAC"}

package/dist/detectors/k8s.js

@@ -0,0 +1,88 @@
+import { eachMatch, findingFromRule, hasExtension, maskCommentLines } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO, CWE_RISKY_PRIMITIVE } from "../cwe.js";
+const K8S_EXTENSIONS = [".yaml", ".yml", ".json"];
+const RE_CM_RSA = /(?:algorithm|keyAlgorithm):\s*["']?RSA\b/g;
+const RE_CM_ECDSA = /(?:algorithm|keyAlgorithm):\s*["']?ECDSA\b/g;
+const RE_CM_ED25519 = /(?:algorithm|keyAlgorithm):\s*["']?Ed25519\b/g;
+const RE_ISTIO_LEGACY_TLS = /minProtocolVersion:\s*["']?TLSV1_[01]\b/g;
+const RULE_CM_RSA = {
+    id: "k8s-certmanager-rsa",
+    title: "cert-manager RSA key",
+    description: "cert-manager Certificate/Issuer privateKey.algorithm = RSA",
+    category: "certificate",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "cert-manager mints certificates with a classical RSA key, which is not quantum-safe.",
+    remediation: "Plan migration to PQC certificate keys (ML-DSA-65) as the CA/issuer chain adds support.",
+};
+const RULE_CM_ECDSA = {
+    id: "k8s-certmanager-ecdsa",
+    title: "cert-manager ECDSA key",
+    description: "cert-manager Certificate/Issuer privateKey.algorithm = ECDSA",
+    category: "certificate",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "cert-manager mints certificates with a classical ECDSA key, forgeable by a quantum attacker.",
+    remediation: "Plan migration to ML-DSA-65 (FIPS 204) certificate keys.",
+};
+const RULE_CM_ED25519 = {
+    id: "k8s-certmanager-ed25519",
+    title: "cert-manager Ed25519 key",
+    description: "cert-manager Certificate/Issuer privateKey.algorithm = Ed25519",
+    category: "certificate",
+    severity: "low",
+    confidence: "high",
+    algorithm: "EdDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "cert-manager mints certificates with a classical Ed25519 key, forgeable by a quantum attacker.",
+    remediation: "Plan migration to ML-DSA-65 (FIPS 204) certificate keys.",
+};
+const RULE_ISTIO_LEGACY_TLS = {
+    id: "k8s-istio-legacy-tls",
+    title: "Istio legacy TLS floor",
+    description: "Istio minProtocolVersion allows TLS 1.0 / 1.1 on mesh traffic",
+    category: "tls",
+    severity: "medium",
+    confidence: "high",
+    hndl: false,
+    cwe: CWE_RISKY_PRIMITIVE,
+    message: "Istio mesh TLS floor allows TLS 1.0/1.1; its classical (EC)DHE key exchange is weak and harvestable.",
+    remediation: "Raise minProtocolVersion to TLSV1_3 and track PQC-hybrid mesh KEX (X25519MLKEM768).",
+};
+/** Detects classical cert-manager keys and legacy Istio TLS floors in K8s YAML. */
+export const k8sDetector = {
+    id: "k8s-crypto",
+    description: "Classical crypto in Kubernetes manifests (cert-manager keys, Istio TLS floors)",
+    scope: "config",
+    language: "any",
+    rules: [RULE_CM_RSA, RULE_CM_ECDSA, RULE_CM_ED25519, RULE_ISTIO_LEGACY_TLS],
+    appliesTo: (f) => hasExtension(f, K8S_EXTENSIONS),
+    detect({ file, content }) {
+        const isCertManager = content.includes("cert-manager.io") ||
+            /kind:\s*["']?(?:Certificate|Issuer|ClusterIssuer)\b/.test(content);
+        const isIstio = content.includes("minProtocolVersion");
+        if (!isCertManager && !isIstio)
+            return [];
+        // A `# algorithm: RSA` YAML comment is not an active setting; match over
+        // comment-masked content (offsets preserved).
+        const scan = maskCommentLines(content, ["#"]);
+        const findings = [];
+        const add = (re, rule) => eachMatch(re, scan, (m) => findings.push(findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length })));
+        if (isCertManager) {
+            add(RE_CM_RSA, RULE_CM_RSA);
+            add(RE_CM_ECDSA, RULE_CM_ECDSA);
+            add(RE_CM_ED25519, RULE_CM_ED25519);
+        }
+        if (isIstio)
+            add(RE_ISTIO_LEGACY_TLS, RULE_ISTIO_LEGACY_TLS);
+        return findings;
+    },
+};
+//# sourceMappingURL=k8s.js.map

package/dist/detectors/k8s.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"k8s.js","sourceRoot":"","sources":["../../src/detectors/k8s.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Config detector: classical crypto in Kubernetes manifests — cert-manager key\n * algorithms and service-mesh (Istio) TLS floors. These mint the certificates\n * and secure the pod-to-pod traffic of a cluster, a surface neither the language\n * packs nor the Terraform detector see.\n *\n * Covered (gated by a cert-manager / Istio marker in the document to keep the\n * generic `algorithm:` / `minProtocolVersion:` keys from firing on unrelated YAML):\n *  - cert-manager `Certificate`/`Issuer` `privateKey.algorithm` (or legacy\n *    `keyAlgorithm`): `RSA` | `ECDSA` | `Ed25519`.\n *  - Istio `minProtocolVersion: TLSV1_0 | TLSV1_1` — a legacy TLS floor on mesh\n *    traffic, whose (EC)DHE key exchange is classical and harvestable.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport { eachMatch, findingFromRule, hasExtension, maskCommentLines } from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO, CWE_RISKY_PRIMITIVE } from \"../cwe.js\";\n\nconst K8S_EXTENSIONS: readonly string[] = [\".yaml\", \".yml\", \".json\"];\n\nconst RE_CM_RSA = /(?:algorithm|keyAlgorithm):\\s*[\"']?RSA\\b/g;\nconst RE_CM_ECDSA = /(?:algorithm|keyAlgorithm):\\s*[\"']?ECDSA\\b/g;\nconst RE_CM_ED25519 = /(?:algorithm|keyAlgorithm):\\s*[\"']?Ed25519\\b/g;\nconst RE_ISTIO_LEGACY_TLS = /minProtocolVersion:\\s*[\"']?TLSV1_[01]\\b/g;\n\nconst RULE_CM_RSA: RuleMeta = {\n  id: \"k8s-certmanager-rsa\",\n  title: \"cert-manager RSA key\",\n  description: \"cert-manager Certificate/Issuer privateKey.algorithm = RSA\",\n  category: \"certificate\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"cert-manager mints certificates with a classical RSA key, which is not quantum-safe.\",\n  remediation:\n    \"Plan migration to PQC certificate keys (ML-DSA-65) as the CA/issuer chain adds support.\",\n};\nconst RULE_CM_ECDSA: RuleMeta = {\n  id: \"k8s-certmanager-ecdsa\",\n  title: \"cert-manager ECDSA key\",\n  description: \"cert-manager Certificate/Issuer privateKey.algorithm = ECDSA\",\n  category: \"certificate\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"cert-manager mints certificates with a classical ECDSA key, forgeable by a quantum attacker.\",\n  remediation: \"Plan migration to ML-DSA-65 (FIPS 204) certificate keys.\",\n};\nconst RULE_CM_ED25519: RuleMeta = {\n  id: \"k8s-certmanager-ed25519\",\n  title: \"cert-manager Ed25519 key\",\n  description: \"cert-manager Certificate/Issuer privateKey.algorithm = Ed25519\",\n  category: \"certificate\",\n  severity: \"low\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"cert-manager mints certificates with a classical Ed25519 key, forgeable by a quantum attacker.\",\n  remediation: \"Plan migration to ML-DSA-65 (FIPS 204) certificate keys.\",\n};\nconst RULE_ISTIO_LEGACY_TLS: RuleMeta = {\n  id: \"k8s-istio-legacy-tls\",\n  title: \"Istio legacy TLS floor\",\n  description: \"Istio minProtocolVersion allows TLS 1.0 / 1.1 on mesh traffic\",\n  category: \"tls\",\n  severity: \"medium\",\n  confidence: \"high\",\n  hndl: false,\n  cwe: CWE_RISKY_PRIMITIVE,\n  message:\n    \"Istio mesh TLS floor allows TLS 1.0/1.1; its classical (EC)DHE key exchange is weak and harvestable.\",\n  remediation:\n    \"Raise minProtocolVersion to TLSV1_3 and track PQC-hybrid mesh KEX (X25519MLKEM768).\",\n};\n\n/** Detects classical cert-manager keys and legacy Istio TLS floors in K8s YAML. */\nexport const k8sDetector: Detector = {\n  id: \"k8s-crypto\",\n  description: \"Classical crypto in Kubernetes manifests (cert-manager keys, Istio TLS floors)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: [RULE_CM_RSA, RULE_CM_ECDSA, RULE_CM_ED25519, RULE_ISTIO_LEGACY_TLS],\n  appliesTo: (f) => hasExtension(f, K8S_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const isCertManager =\n      content.includes(\"cert-manager.io\") ||\n      /kind:\\s*[\"']?(?:Certificate|Issuer|ClusterIssuer)\\b/.test(content);\n    const isIstio = content.includes(\"minProtocolVersion\");\n    if (!isCertManager && !isIstio) return [];\n\n    // A `# algorithm: RSA` YAML comment is not an active setting; match over\n    // comment-masked content (offsets preserved).\n    const scan = maskCommentLines(content, [\"#\"]);\n    const findings: Finding[] = [];\n    const add = (re: RegExp, rule: RuleMeta) =>\n      eachMatch(re, scan, (m) =>\n        findings.push(\n          findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n        ),\n      );\n    if (isCertManager) {\n      add(RE_CM_RSA, RULE_CM_RSA);\n      add(RE_CM_ECDSA, RULE_CM_ECDSA);\n      add(RE_CM_ED25519, RULE_CM_ED25519);\n    }\n    if (isIstio) add(RE_ISTIO_LEGACY_TLS, RULE_ISTIO_LEGACY_TLS);\n    return findings;\n  },\n};\n"]}

package/dist/detectors/keystore.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Config detector: classical cryptographic KEYSTORES committed to a repository —
+ * Java KeyStore (JKS), JCEKS, PKCS#12 (.p12/.pfx), and BouncyCastle (.bks). These
+ * binary containers hold private keys and certificate chains, essentially always
+ * classical (RSA / EC / DSA). A keystore in version control is committed key
+ * material: harvest-now-decrypt-later exposed and retroactively un-fixable.
+ *
+ * The scan pipeline reads these extensions byte-preserving (latin1; see
+ * {@link ../walk.ts isKeystorePath} and scan.ts), so `content.charCodeAt(i)` is the
+ * i-th file byte and we can identify the container by its magic number. We do NOT
+ * parse the enclosed key algorithm (that needs full ASN.1 / proprietary parsing);
+ * flagging the presence of a classical keystore is the actionable signal.
+ *
+ * The match is sensitive key material, so reporters drop the (binary) snippet.
+ */
+import type { Detector } from "../types.js";
+/** Detects committed classical keystores by magic number / extension. */
+export declare const keystoreDetector: Detector;
+//# sourceMappingURL=keystore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keystore.d.ts","sourceRoot":"","sources":["../../src/detectors/keystore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA4D/D,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,EAAE,QAgC9B,CAAC"}

package/dist/detectors/keystore.js

@@ -0,0 +1,76 @@
+import { findingFromRule, hasExtension } from "../detect-utils.js";
+import { CWE_HARDCODED_KEY } from "../cwe.js";
+const KEYSTORE_EXTENSIONS = [
+    ".jks",
+    ".keystore",
+    ".jceks",
+    ".bks",
+    ".p12",
+    ".pfx",
+];
+function baseRule(id, title, message) {
+    return {
+        id,
+        title,
+        description: message,
+        category: "certificate",
+        severity: "high",
+        confidence: "high",
+        hndl: true,
+        cwe: CWE_HARDCODED_KEY,
+        sensitive: true,
+        message,
+        remediation: "Remove key material from version control and rotate it; store keys in a secret manager / HSM. Plan re-issuance with PQC keys (ML-DSA-65 / ML-KEM-768) as tooling supports it.",
+    };
+}
+const RULE_JKS = baseRule("keystore-jks", "Java KeyStore (JKS)", "A Java KeyStore (JKS) holds classical private keys / certificates (RSA/EC/DSA); a keystore in version control is committed, harvest-now-decrypt-later exposed key material.");
+const RULE_JCEKS = baseRule("keystore-jceks", "Java JCEKS keystore", "A JCEKS keystore holds classical key material (RSA/EC/DSA); committed to version control it is harvest-now-decrypt-later exposed.");
+const RULE_PKCS12 = baseRule("keystore-pkcs12", "PKCS#12 keystore", "A PKCS#12 container (a `.p12`/`.pfx`, or a modern `.jks`/`.keystore` — keytool writes PKCS#12 by default since Java 9) holds classical private keys / certificate chains (RSA/EC); committed to version control it is harvest-now-decrypt-later exposed.");
+const RULE_BKS = baseRule("keystore-bks", "BouncyCastle keystore (.bks)", "A BouncyCastle (.bks) keystore holds classical key material; committed to version control it is harvest-now-decrypt-later exposed.");
+/** Bytes-equal check against `content` read as latin1 (charCodeAt == file byte). */
+function magic(content, ...bytes) {
+    if (content.length < bytes.length)
+        return false;
+    for (let i = 0; i < bytes.length; i++) {
+        if (content.charCodeAt(i) !== bytes[i])
+            return false;
+    }
+    return true;
+}
+/** Detects committed classical keystores by magic number / extension. */
+export const keystoreDetector = {
+    id: "keystore-material",
+    description: "Committed classical cryptographic keystores (JKS, JCEKS, PKCS#12, BKS)",
+    scope: "config",
+    language: "any",
+    rules: [RULE_JKS, RULE_JCEKS, RULE_PKCS12, RULE_BKS],
+    appliesTo: (f) => hasExtension(f, KEYSTORE_EXTENSIONS),
+    detect({ file, content }) {
+        const at = { file, content, index: 0, matchLength: 4 };
+        // JKS: 0xFEEDFEED. JCEKS: 0xCECECECE.
+        if (magic(content, 0xfe, 0xed, 0xfe, 0xed))
+            return [findingFromRule(RULE_JKS, at)];
+        if (magic(content, 0xce, 0xce, 0xce, 0xce))
+            return [findingFromRule(RULE_JCEKS, at)];
+        // PKCS#12 is a DER SEQUENCE. Since Java 9, `keytool` writes PKCS#12 BY DEFAULT
+        // even for files named `.jks`/`.keystore` (and Android release keystores are
+        // PKCS#12), so this runs for ANY keystore extension once the JKS/JCEKS magics
+        // fail. Accept the long-form length octets 0x81/0x82/0x83 (real PKCS#12 is
+        // always >127 bytes, so short-form would be a false positive).
+        if (content.length >= 2 && content.charCodeAt(0) === 0x30) {
+            const lenOctet = content.charCodeAt(1);
+            // Long-form DER length (0x81/0x82/0x83) or BER indefinite length (0x80, emitted
+            // by NSS/Firefox .p12 exports). Short-form is excluded (real PKCS#12 is >127 B).
+            if (lenOctet === 0x80 || lenOctet === 0x81 || lenOctet === 0x82 || lenOctet === 0x83) {
+                return [findingFromRule(RULE_PKCS12, { ...at, matchLength: 2 })];
+            }
+        }
+        // BouncyCastle keystores have no stable magic; key off the extension, but
+        // require some content so an empty `.bks` placeholder does not fire.
+        if (file.toLowerCase().endsWith(".bks") && content.length > 0) {
+            return [findingFromRule(RULE_BKS, { ...at, matchLength: 1 })];
+        }
+        return [];
+    },
+};
+//# sourceMappingURL=keystore.js.map

package/dist/detectors/keystore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore.js","sourceRoot":"","sources":["../../src/detectors/keystore.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Config detector: classical cryptographic KEYSTORES committed to a repository —\n * Java KeyStore (JKS), JCEKS, PKCS#12 (.p12/.pfx), and BouncyCastle (.bks). These\n * binary containers hold private keys and certificate chains, essentially always\n * classical (RSA / EC / DSA). A keystore in version control is committed key\n * material: harvest-now-decrypt-later exposed and retroactively un-fixable.\n *\n * The scan pipeline reads these extensions byte-preserving (latin1; see\n * {@link ../walk.ts isKeystorePath} and scan.ts), so `content.charCodeAt(i)` is the\n * i-th file byte and we can identify the container by its magic number. We do NOT\n * parse the enclosed key algorithm (that needs full ASN.1 / proprietary parsing);\n * flagging the presence of a classical keystore is the actionable signal.\n *\n * The match is sensitive key material, so reporters drop the (binary) snippet.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport { findingFromRule, hasExtension } from \"../detect-utils.js\";\nimport { CWE_HARDCODED_KEY } from \"../cwe.js\";\n\nconst KEYSTORE_EXTENSIONS: readonly string[] = [\n  \".jks\",\n  \".keystore\",\n  \".jceks\",\n  \".bks\",\n  \".p12\",\n  \".pfx\",\n];\n\nfunction baseRule(id: string, title: string, message: string): RuleMeta {\n  return {\n    id,\n    title,\n    description: message,\n    category: \"certificate\",\n    severity: \"high\",\n    confidence: \"high\",\n    hndl: true,\n    cwe: CWE_HARDCODED_KEY,\n    sensitive: true,\n    message,\n    remediation:\n      \"Remove key material from version control and rotate it; store keys in a secret manager / HSM. Plan re-issuance with PQC keys (ML-DSA-65 / ML-KEM-768) as tooling supports it.\",\n  };\n}\n\nconst RULE_JKS = baseRule(\n  \"keystore-jks\",\n  \"Java KeyStore (JKS)\",\n  \"A Java KeyStore (JKS) holds classical private keys / certificates (RSA/EC/DSA); a keystore in version control is committed, harvest-now-decrypt-later exposed key material.\",\n);\nconst RULE_JCEKS = baseRule(\n  \"keystore-jceks\",\n  \"Java JCEKS keystore\",\n  \"A JCEKS keystore holds classical key material (RSA/EC/DSA); committed to version control it is harvest-now-decrypt-later exposed.\",\n);\nconst RULE_PKCS12 = baseRule(\n  \"keystore-pkcs12\",\n  \"PKCS#12 keystore\",\n  \"A PKCS#12 container (a `.p12`/`.pfx`, or a modern `.jks`/`.keystore` — keytool writes PKCS#12 by default since Java 9) holds classical private keys / certificate chains (RSA/EC); committed to version control it is harvest-now-decrypt-later exposed.\",\n);\nconst RULE_BKS = baseRule(\n  \"keystore-bks\",\n  \"BouncyCastle keystore (.bks)\",\n  \"A BouncyCastle (.bks) keystore holds classical key material; committed to version control it is harvest-now-decrypt-later exposed.\",\n);\n\n/** Bytes-equal check against `content` read as latin1 (charCodeAt == file byte). */\nfunction magic(content: string, ...bytes: number[]): boolean {\n  if (content.length < bytes.length) return false;\n  for (let i = 0; i < bytes.length; i++) {\n    if (content.charCodeAt(i) !== bytes[i]) return false;\n  }\n  return true;\n}\n\n/** Detects committed classical keystores by magic number / extension. */\nexport const keystoreDetector: Detector = {\n  id: \"keystore-material\",\n  description: \"Committed classical cryptographic keystores (JKS, JCEKS, PKCS#12, BKS)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: [RULE_JKS, RULE_JCEKS, RULE_PKCS12, RULE_BKS],\n  appliesTo: (f) => hasExtension(f, KEYSTORE_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const at = { file, content, index: 0, matchLength: 4 };\n    // JKS: 0xFEEDFEED. JCEKS: 0xCECECECE.\n    if (magic(content, 0xfe, 0xed, 0xfe, 0xed)) return [findingFromRule(RULE_JKS, at)];\n    if (magic(content, 0xce, 0xce, 0xce, 0xce)) return [findingFromRule(RULE_JCEKS, at)];\n    // PKCS#12 is a DER SEQUENCE. Since Java 9, `keytool` writes PKCS#12 BY DEFAULT\n    // even for files named `.jks`/`.keystore` (and Android release keystores are\n    // PKCS#12), so this runs for ANY keystore extension once the JKS/JCEKS magics\n    // fail. Accept the long-form length octets 0x81/0x82/0x83 (real PKCS#12 is\n    // always >127 bytes, so short-form would be a false positive).\n    if (content.length >= 2 && content.charCodeAt(0) === 0x30) {\n      const lenOctet = content.charCodeAt(1);\n      // Long-form DER length (0x81/0x82/0x83) or BER indefinite length (0x80, emitted\n      // by NSS/Firefox .p12 exports). Short-form is excluded (real PKCS#12 is >127 B).\n      if (lenOctet === 0x80 || lenOctet === 0x81 || lenOctet === 0x82 || lenOctet === 0x83) {\n        return [findingFromRule(RULE_PKCS12, { ...at, matchLength: 2 })];\n      }\n    }\n    // BouncyCastle keystores have no stable magic; key off the extension, but\n    // require some content so an empty `.bks` placeholder does not fire.\n    if (file.toLowerCase().endsWith(\".bks\") && content.length > 0) {\n      return [findingFromRule(RULE_BKS, { ...at, matchLength: 1 })];\n    }\n    return [];\n  },\n};\n"]}

package/dist/detectors/mesh.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Config detector: classical crypto in SERVICE MESH configuration — the
+ * control-plane identity/CA systems and mesh-internal TLS settings of
+ * Linkerd, HashiCorp Consul Connect, and Istio. These mint the mTLS identity
+ * certificates that secure sidecar-to-sidecar traffic and are configured in
+ * their own Helm values / HCL / CRD surfaces, distinct from what `k8s.ts`
+ * already covers (cert-manager `Certificate`/`Issuer` keys and Istio's
+ * `minProtocolVersion` TLS floor — NOT duplicated here).
+ *
+ * Covered (gated by a mesh marker in the document to keep generic keys like
+ * `scheme:` / `private_key_type` from firing on unrelated YAML/HCL):
+ *  - Linkerd control-plane identity issuer: Helm values `identityTrustAnchorsPEM`
+ *    and `identity.issuer.scheme` / nested `issuer.scheme: linkerd.io/tls` — the
+ *    default self-managed Linkerd identity scheme, which mints workload
+ *    certificates from an ECDSA P-256 trust anchor. Flagged as a classical mesh
+ *    CA (certificate, ECDSA, hndl:false) since Linkerd's identity issuer signs
+ *    forgeable-by-quantum leaf certs, not a confidentiality key.
+ *  - HashiCorp Consul Connect: the `connect { ca_config { private_key_type =
+ *    "ec" | "rsa" } } }` mesh CA provider setting (also `ca_provider`). Flagged
+ *    as a classical mesh CA (certificate; ECDSA for "ec", RSA for "rsa").
+ * Istio `tls.cipherSuites:` `ECDHE-RSA-*` / `ECDHE-ECDSA-*` suites are NOT handled
+ * here — the language-agnostic `tls-classical-kex` token rule in `source.ts`
+ * already flags those cipher strings in any config file, so a rule here would
+ * double-count.
+ */
+import type { Detector } from "../types.js";
+/**
+ * Detects classical asymmetric crypto in service-mesh configuration: Linkerd's
+ * default ECDSA identity issuer and Consul Connect's mesh CA private key type.
+ * (Istio ECDHE cipher-suite strings are covered by `source.ts`'s
+ * `tls-classical-kex` token rule, so they are not duplicated here.)
+ */
+export declare const meshDetector: Detector;
+//# sourceMappingURL=mesh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/detectors/mesh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAoE/D;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,QA8B1B,CAAC"}

package/dist/detectors/mesh.js

@@ -0,0 +1,91 @@
+import { eachMatch, findingFromRule, hasExtension, maskCommentLines } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+// `.json` is included because Consul agent config is commonly JSON (the
+// `private_key_type` rules already support the JSON `:` form); the content gates
+// keep unrelated generic JSON/YAML out.
+const MESH_EXTENSIONS = [".yaml", ".yml", ".hcl", ".json"];
+// Linkerd's default self-managed identity scheme (`linkerd.io/tls`, as opposed
+// to a `kubernetes.io/tls` bring-your-own-cert secret) mints its trust anchor
+// and issuer credentials as ECDSA P-256 by default. Matched in both nested
+// YAML form (`scheme: linkerd.io/tls`) and the flattened Helm `--set`/values
+// key form (`identity.issuer.scheme: linkerd.io/tls`), plus the distinctive
+// `identityTrustAnchorsPEM` values key which only exists in Linkerd charts.
+const RE_MESH_LINKERD_ECDSA = /identityTrustAnchorsPEM\b|(?:identity\.issuer\.scheme|scheme)\s*[:=]\s*["']?linkerd\.io\/tls\b/g;
+// Consul Connect's CA provider config: `private_key_type = "ec" | "rsa"`
+// inside a `ca_config` block. Matched in both HCL (`=`) and JSON (`:`) forms,
+// mirroring the terraform.ts attribute-matching convention.
+const RE_MESH_CONSUL_RSA = /(?<![\w"-])"?private_key_type"?\s*[:=]\s*"rsa"/gi;
+const RE_MESH_CONSUL_EC = /(?<![\w"-])"?private_key_type"?\s*[:=]\s*"ec"/gi;
+const RULE_MESH_LINKERD_ECDSA = {
+    id: "mesh-linkerd-identity-ecdsa",
+    title: "Linkerd ECDSA identity issuer",
+    description: "Linkerd control-plane identity issuer (default ECDSA P-256 mesh CA)",
+    category: "certificate",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Linkerd's control-plane identity issuer mints workload certificates from a classical ECDSA P-256 trust anchor by default, forgeable by a quantum attacker.",
+    remediation: "Plan migration to ML-DSA-65 (FIPS 204) once Linkerd's identity issuer supports PQC signing.",
+};
+const RULE_MESH_CONSUL_RSA = {
+    id: "mesh-consul-connect-rsa",
+    title: "Consul Connect RSA mesh CA",
+    description: 'Consul Connect ca_config private_key_type = "rsa"',
+    category: "certificate",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Consul Connect's mesh CA issues leaf certificates from a classical RSA private key, which is not quantum-safe.",
+    remediation: "Plan migration to PQC certificate keys (ML-DSA-65) as the Connect CA provider adds support.",
+};
+const RULE_MESH_CONSUL_EC = {
+    id: "mesh-consul-connect-ec",
+    title: "Consul Connect EC mesh CA",
+    description: 'Consul Connect ca_config private_key_type = "ec"',
+    category: "certificate",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Consul Connect's mesh CA issues leaf certificates from a classical EC private key, forgeable by a quantum attacker.",
+    remediation: "Plan migration to ML-DSA-65 (FIPS 204) as the Connect CA provider adds support.",
+};
+/**
+ * Detects classical asymmetric crypto in service-mesh configuration: Linkerd's
+ * default ECDSA identity issuer and Consul Connect's mesh CA private key type.
+ * (Istio ECDHE cipher-suite strings are covered by `source.ts`'s
+ * `tls-classical-kex` token rule, so they are not duplicated here.)
+ */
+export const meshDetector = {
+    id: "service-mesh-crypto",
+    description: "Classical crypto in service-mesh config (Linkerd identity, Consul Connect CA)",
+    scope: "config",
+    language: "any",
+    rules: [RULE_MESH_LINKERD_ECDSA, RULE_MESH_CONSUL_RSA, RULE_MESH_CONSUL_EC],
+    appliesTo: (f) => hasExtension(f, MESH_EXTENSIONS),
+    detect({ file, content }) {
+        const isLinkerd = content.includes("linkerd") || content.includes("identityTrustAnchors");
+        const isConsulConnect = content.includes("consul") && content.includes("connect");
+        if (!isLinkerd && !isConsulConnect)
+            return [];
+        // Mask whole comment lines (YAML/HCL `#`, HCL/JSON5 `//`) so a commented-out
+        // directive can't fire — `.yaml`/`.hcl`/`.json` are not centrally stripped.
+        // Offsets are preserved, so the finding location stays exact.
+        const scan = maskCommentLines(content, ["#", "//"]);
+        const findings = [];
+        const add = (re, rule) => eachMatch(re, scan, (m) => findings.push(findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length })));
+        if (isLinkerd)
+            add(RE_MESH_LINKERD_ECDSA, RULE_MESH_LINKERD_ECDSA);
+        if (isConsulConnect) {
+            add(RE_MESH_CONSUL_RSA, RULE_MESH_CONSUL_RSA);
+            add(RE_MESH_CONSUL_EC, RULE_MESH_CONSUL_EC);
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=mesh.js.map

package/dist/detectors/mesh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh.js","sourceRoot":"","sources":["../../src/detectors/mesh.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Config detector: classical crypto in SERVICE MESH configuration — the\n * control-plane identity/CA systems and mesh-internal TLS settings of\n * Linkerd, HashiCorp Consul Connect, and Istio. These mint the mTLS identity\n * certificates that secure sidecar-to-sidecar traffic and are configured in\n * their own Helm values / HCL / CRD surfaces, distinct from what `k8s.ts`\n * already covers (cert-manager `Certificate`/`Issuer` keys and Istio's\n * `minProtocolVersion` TLS floor — NOT duplicated here).\n *\n * Covered (gated by a mesh marker in the document to keep generic keys like\n * `scheme:` / `private_key_type` from firing on unrelated YAML/HCL):\n *  - Linkerd control-plane identity issuer: Helm values `identityTrustAnchorsPEM`\n *    and `identity.issuer.scheme` / nested `issuer.scheme: linkerd.io/tls` — the\n *    default self-managed Linkerd identity scheme, which mints workload\n *    certificates from an ECDSA P-256 trust anchor. Flagged as a classical mesh\n *    CA (certificate, ECDSA, hndl:false) since Linkerd's identity issuer signs\n *    forgeable-by-quantum leaf certs, not a confidentiality key.\n *  - HashiCorp Consul Connect: the `connect { ca_config { private_key_type =\n *    \"ec\" | \"rsa\" } } }` mesh CA provider setting (also `ca_provider`). Flagged\n *    as a classical mesh CA (certificate; ECDSA for \"ec\", RSA for \"rsa\").\n * Istio `tls.cipherSuites:` `ECDHE-RSA-*` / `ECDHE-ECDSA-*` suites are NOT handled\n * here — the language-agnostic `tls-classical-kex` token rule in `source.ts`\n * already flags those cipher strings in any config file, so a rule here would\n * double-count.\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\n// `.json` is included because Consul agent config is commonly JSON (the\n// `private_key_type` rules already support the JSON `:` form); the content gates\n// keep unrelated generic JSON/YAML out.\nconst MESH_EXTENSIONS: readonly string[] = [\".yaml\", \".yml\", \".hcl\", \".json\"];\n\n// Linkerd's default self-managed identity scheme (`linkerd.io/tls`, as opposed\n// to a `kubernetes.io/tls` bring-your-own-cert secret) mints its trust anchor\n// and issuer credentials as ECDSA P-256 by default. Matched in both nested\n// YAML form (`scheme: linkerd.io/tls`) and the flattened Helm `--set`/values\n// key form (`identity.issuer.scheme: linkerd.io/tls`), plus the distinctive\n// `identityTrustAnchorsPEM` values key which only exists in Linkerd charts.\nconst RE_MESH_LINKERD_ECDSA =\n  /identityTrustAnchorsPEM\\b|(?:identity\\.issuer\\.scheme|scheme)\\s*[:=]\\s*[\"']?linkerd\\.io\\/tls\\b/g;\n\n// Consul Connect's CA provider config: `private_key_type = \"ec\" | \"rsa\"`\n// inside a `ca_config` block. Matched in both HCL (`=`) and JSON (`:`) forms,\n// mirroring the terraform.ts attribute-matching convention.\nconst RE_MESH_CONSUL_RSA = /(?<![\\w\"-])\"?private_key_type\"?\\s*[:=]\\s*\"rsa\"/gi;\nconst RE_MESH_CONSUL_EC = /(?<![\\w\"-])\"?private_key_type\"?\\s*[:=]\\s*\"ec\"/gi;\n\nconst RULE_MESH_LINKERD_ECDSA: RuleMeta = {\n  id: \"mesh-linkerd-identity-ecdsa\",\n  title: \"Linkerd ECDSA identity issuer\",\n  description: \"Linkerd control-plane identity issuer (default ECDSA P-256 mesh CA)\",\n  category: \"certificate\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Linkerd's control-plane identity issuer mints workload certificates from a classical ECDSA P-256 trust anchor by default, forgeable by a quantum attacker.\",\n  remediation:\n    \"Plan migration to ML-DSA-65 (FIPS 204) once Linkerd's identity issuer supports PQC signing.\",\n};\nconst RULE_MESH_CONSUL_RSA: RuleMeta = {\n  id: \"mesh-consul-connect-rsa\",\n  title: \"Consul Connect RSA mesh CA\",\n  description: 'Consul Connect ca_config private_key_type = \"rsa\"',\n  category: \"certificate\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Consul Connect's mesh CA issues leaf certificates from a classical RSA private key, which is not quantum-safe.\",\n  remediation:\n    \"Plan migration to PQC certificate keys (ML-DSA-65) as the Connect CA provider adds support.\",\n};\nconst RULE_MESH_CONSUL_EC: RuleMeta = {\n  id: \"mesh-consul-connect-ec\",\n  title: \"Consul Connect EC mesh CA\",\n  description: 'Consul Connect ca_config private_key_type = \"ec\"',\n  category: \"certificate\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Consul Connect's mesh CA issues leaf certificates from a classical EC private key, forgeable by a quantum attacker.\",\n  remediation: \"Plan migration to ML-DSA-65 (FIPS 204) as the Connect CA provider adds support.\",\n};\n/**\n * Detects classical asymmetric crypto in service-mesh configuration: Linkerd's\n * default ECDSA identity issuer and Consul Connect's mesh CA private key type.\n * (Istio ECDHE cipher-suite strings are covered by `source.ts`'s\n * `tls-classical-kex` token rule, so they are not duplicated here.)\n */\nexport const meshDetector: Detector = {\n  id: \"service-mesh-crypto\",\n  description: \"Classical crypto in service-mesh config (Linkerd identity, Consul Connect CA)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: [RULE_MESH_LINKERD_ECDSA, RULE_MESH_CONSUL_RSA, RULE_MESH_CONSUL_EC],\n  appliesTo: (f) => hasExtension(f, MESH_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const isLinkerd = content.includes(\"linkerd\") || content.includes(\"identityTrustAnchors\");\n    const isConsulConnect = content.includes(\"consul\") && content.includes(\"connect\");\n    if (!isLinkerd && !isConsulConnect) return [];\n\n    // Mask whole comment lines (YAML/HCL `#`, HCL/JSON5 `//`) so a commented-out\n    // directive can't fire — `.yaml`/`.hcl`/`.json` are not centrally stripped.\n    // Offsets are preserved, so the finding location stays exact.\n    const scan = maskCommentLines(content, [\"#\", \"//\"]);\n    const findings: Finding[] = [];\n    const add = (re: RegExp, rule: RuleMeta) =>\n      eachMatch(re, scan, (m) =>\n        findings.push(\n          findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n        ),\n      );\n    if (isLinkerd) add(RE_MESH_LINKERD_ECDSA, RULE_MESH_LINKERD_ECDSA);\n    if (isConsulConnect) {\n      add(RE_MESH_CONSUL_RSA, RULE_MESH_CONSUL_RSA);\n      add(RE_MESH_CONSUL_EC, RULE_MESH_CONSUL_EC);\n    }\n    return findings;\n  },\n};\n"]}

package/dist/detectors/messaging.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Config detector: classical transport crypto in message brokers / event streams
+ * (Kafka, RabbitMQ, MQTT/Mosquitto, NATS). Broker traffic is "communication
+ * between things"; a legacy TLS floor or a classical (EC)DHE cipher suite makes
+ * every message in flight harvest-now-decrypt-later exposed.
+ *
+ * Covered in broker config files (`.properties`, `.conf`, `.cfg`, `.ini`):
+ *  - Kafka `ssl.protocol` / `ssl.enabled.protocols = TLSv1 | TLSv1.1` (legacy).
+ *  - MQTT/Mosquitto `tls_version tlsv1 | tlsv1.1` (legacy).
+ *  - Kafka `ssl.cipher.suites` naming a static-RSA `TLS_RSA_WITH_*` key-transport
+ *    suite (the ECDHE/DHE suites are owned by source.ts's `tls-classical-kex`).
+ */
+import type { Detector } from "../types.js";
+/** Detects classical transport crypto in message-broker / event-stream config. */
+export declare const messagingDetector: Detector;
+//# sourceMappingURL=messaging.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messaging.d.ts","sourceRoot":"","sources":["../../src/detectors/messaging.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAsE/D,kFAAkF;AAClF,eAAO,MAAM,iBAAiB,EAAE,QAsB/B,CAAC"}