@quantakrypto/core 0.4.3 → 0.4.4

package/src/detectors/elixir.ts

@@ -0,0 +1,237 @@
+/**
+ * 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 { AlgorithmFamily, Detector, Finding, RuleMeta } from "../types.js";
+import { ELIXIR_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+
+const RE_EX_GEN = /:crypto\.generate_key\s*\(\s*:(\w+)/g;
+const RE_EX_SIGN = /:crypto\.(?:sign|verify)\s*\(\s*:(\w+)/g;
+const RE_EX_X509_RSA = /\bX509\.PrivateKey\.new_rsa\s*\(/g;
+const RE_EX_X509_EC = /\bX509\.PrivateKey\.new_ec\s*\(/g;
+const RE_EX_JOSE = /\bJOSE\.JWK\.generate_key\s*\(\s*\{\s*:(\w+)/g;
+
+interface Cls {
+  algo: AlgorithmFamily;
+  cat: Finding["category"];
+  sev: Finding["severity"];
+  hndl: boolean;
+  label: string;
+  remediation?: string;
+}
+const SIG_REM = "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)";
+const KEX_REM = "hybrid X25519MLKEM768 (ML-KEM-768)";
+
+const RULE_EX_KEYGEN: RuleMeta = {
+  id: "elixir-crypto-keygen",
+  title: "Elixir :crypto key generation",
+  description: ":crypto.generate_key (rsa/ecdh/dh/eddsa)",
+  category: "kem",
+  severity: "high",
+  confidence: "high",
+  algorithm: "RSA",
+  hndl: true,
+  cwe: CWE_BROKEN_CRYPTO,
+  message: "Generates a classical key pair via Erlang :crypto (Elixir) — not quantum-safe.",
+};
+const RULE_EX_SIGN: RuleMeta = {
+  id: "elixir-crypto-sign",
+  title: "Elixir :crypto signature",
+  description: ":crypto.sign / :crypto.verify (rsa/ecdsa/eddsa)",
+  category: "signature",
+  severity: "high",
+  confidence: "high",
+  algorithm: "unknown",
+  hndl: false,
+  cwe: CWE_BROKEN_CRYPTO,
+  message: "Classical signature via Erlang :crypto (Elixir) is forgeable by a quantum attacker.",
+  remediation: SIG_REM,
+};
+const RULE_EX_X509: RuleMeta = {
+  id: "elixir-x509-keygen",
+  title: "Elixir X509 key generation",
+  description: "X509.PrivateKey.new_rsa / new_ec",
+  category: "kem",
+  severity: "high",
+  confidence: "high",
+  algorithm: "RSA",
+  hndl: true,
+  cwe: CWE_BROKEN_CRYPTO,
+  message: "Generates a classical key pair via the X509 library (Elixir) — not quantum-safe.",
+};
+const RULE_EX_JOSE: RuleMeta = {
+  id: "elixir-jose-jwk",
+  title: "Elixir JOSE JWK generation",
+  description: "JOSE.JWK.generate_key ({:rsa|:ec|:okp})",
+  category: "kem",
+  severity: "high",
+  confidence: "high",
+  algorithm: "RSA",
+  hndl: true,
+  cwe: CWE_BROKEN_CRYPTO,
+  message: "Generates a classical JWK via JOSE (Elixir) — not quantum-safe.",
+};
+
+const RSA_CLS: Cls = { algo: "RSA", cat: "kem", sev: "high", hndl: true, label: "RSA" };
+const DH_CLS: Cls = { algo: "DH", cat: "key-exchange", sev: "high", hndl: true, label: "DH" };
+const ECDH_CLS: Cls = {
+  algo: "ECDH",
+  cat: "key-exchange",
+  sev: "high",
+  hndl: true,
+  label: "ECDH",
+  remediation: KEX_REM,
+};
+const X25519_CLS: Cls = {
+  algo: "X25519",
+  cat: "key-exchange",
+  sev: "medium",
+  hndl: true,
+  label: "X25519",
+  remediation: KEX_REM,
+};
+const X448_CLS: Cls = { ...X25519_CLS, algo: "X448", label: "X448" };
+const EDDSA_CLS: Cls = {
+  algo: "EdDSA",
+  cat: "signature",
+  sev: "low",
+  hndl: false,
+  label: "EdDSA",
+  remediation: SIG_REM,
+};
+const EC_CLS: Cls = {
+  algo: "ECDH",
+  cat: "key-exchange",
+  sev: "high",
+  hndl: true,
+  label: "EC (ECDSA/ECDH)",
+  remediation: KEX_REM,
+};
+
+/** Classify a `:crypto.generate_key(:<type>, …)` by its type atom (+ the curve
+ * atom in a short window for the ecdh X25519/X448 case). */
+function classifyGen(type: string, window: string): Cls | null {
+  switch (type) {
+    case "rsa":
+      return RSA_CLS;
+    case "dh":
+      return DH_CLS;
+    case "eddsa":
+    case "ed25519":
+      return EDDSA_CLS;
+    case "ecdh":
+      if (/:x25519\b/i.test(window)) return X25519_CLS;
+      if (/:x448\b/i.test(window)) return X448_CLS;
+      return ECDH_CLS;
+    default:
+      return null; // srp / other non-broken-in-this-model types
+  }
+}
+
+/** Signature algorithm classification for `:crypto.sign(:<type>, …)`. */
+function classifySign(type: string): AlgorithmFamily | null {
+  if (type === "rsa") return "RSA";
+  if (type === "ecdsa") return "ECDSA";
+  if (type === "eddsa" || type === "ed25519") return "EdDSA";
+  return null;
+}
+
+/** Detects classical asymmetric crypto in Elixir (:crypto, X509, JOSE). */
+export const elixirDetector: Detector = {
+  id: "elixir-crypto",
+  description: "Classical asymmetric crypto in Elixir (:crypto, X509, JOSE)",
+  scope: "source",
+  language: "elixir",
+  rules: [RULE_EX_KEYGEN, RULE_EX_SIGN, RULE_EX_X509, RULE_EX_JOSE],
+  appliesTo: (f) => hasExtension(f, ELIXIR_EXTENSIONS),
+  detect({ file, content }): Finding[] {
+    const findings: Finding[] = [];
+    const at = (m: RegExpExecArray) => ({
+      file,
+      content,
+      index: m.index,
+      matchLength: m[0].length,
+    });
+
+    // :crypto.generate_key(:type, …) — classify by the type atom (+ curve window).
+    eachMatch(RE_EX_GEN, content, (m) => {
+      const cls = classifyGen(m[1], content.slice(m.index, m.index + 80));
+      if (!cls) return;
+      findings.push(
+        findingFromRule(RULE_EX_KEYGEN, at(m), {
+          title: `Elixir :crypto ${cls.label} key generation`,
+          category: cls.cat,
+          severity: cls.sev,
+          algorithm: cls.algo,
+          hndl: cls.hndl,
+          message: `Generates a classical ${cls.label} key pair via Erlang :crypto (Elixir) — not quantum-safe.`,
+          ...(cls.remediation ? { remediation: cls.remediation } : {}),
+        }),
+      );
+    });
+
+    // :crypto.sign / :crypto.verify(:type, …).
+    eachMatch(RE_EX_SIGN, content, (m) => {
+      const algo = classifySign(m[1]);
+      if (!algo) return;
+      findings.push(
+        findingFromRule(RULE_EX_SIGN, at(m), {
+          algorithm: algo,
+          message: `Classical ${algo} signature via Erlang :crypto (Elixir) is forgeable by a quantum attacker.`,
+        }),
+      );
+    });
+
+    // X509.PrivateKey.new_rsa / new_ec.
+    eachMatch(RE_EX_X509_RSA, content, (m) =>
+      findings.push(findingFromRule(RULE_EX_X509, at(m), { algorithm: "RSA" })),
+    );
+    eachMatch(RE_EX_X509_EC, content, (m) =>
+      findings.push(
+        findingFromRule(RULE_EX_X509, at(m), {
+          title: "Elixir X509 EC key generation",
+          category: EC_CLS.cat,
+          algorithm: EC_CLS.algo,
+          hndl: EC_CLS.hndl,
+          message:
+            "Generates a classical EC key pair via the X509 library (Elixir); EC keys feed BOTH ECDSA and ECDH.",
+          remediation: KEX_REM,
+        }),
+      ),
+    );
+
+    // JOSE.JWK.generate_key({:rsa|:ec|:okp, …}).
+    eachMatch(RE_EX_JOSE, content, (m) => {
+      const kind = m[1];
+      const cls =
+        kind === "rsa" ? RSA_CLS : kind === "ec" ? EC_CLS : kind === "okp" ? EDDSA_CLS : null;
+      if (!cls) return;
+      findings.push(
+        findingFromRule(RULE_EX_JOSE, at(m), {
+          title: `Elixir JOSE ${cls.label} JWK`,
+          category: cls.cat,
+          severity: cls.sev,
+          algorithm: cls.algo,
+          hndl: cls.hndl,
+          message: `Generates a classical ${cls.label} JWK via JOSE (Elixir) — not quantum-safe.`,
+          ...(cls.remediation ? { remediation: cls.remediation } : {}),
+        }),
+      );
+    });
+
+    return findings;
+  },
+};

package/src/detectors/java.ts

@@ -328,7 +328,8 @@ const BC_CURVE_CLASS_RULES: Record<string, RuleMeta> = {
 /** Detects classical asymmetric crypto in Java / Kotlin (JCA + BouncyCastle). */
 export const javaDetector: Detector = {
   id: "java-crypto",
-  description: "Classical asymmetric crypto in Java/Kotlin (JCA getInstance + BouncyCastle)",
+  description:
+    "Classical asymmetric crypto on the JVM — Java/Kotlin/Scala (JCA getInstance + BouncyCastle)",
   scope: "source",
   language: "java",
   rules: [

package/src/detectors/jose.ts

@@ -0,0 +1,94 @@
+/**
+ * Config detector: classical KEY-MANAGEMENT (JWE) algorithms in JOSE. This is
+ * distinct from the JWS signature side (RS256/ES256, handled elsewhere) and from
+ * the JWK key-material detector: here we flag the `alg` values that wrap a
+ * content-encryption key with classical asymmetric crypto, because the encrypted
+ * payload is CONFIDENTIALITY — harvest-now-decrypt-later exposed. A JWE token
+ * captured today (from a log, an audit trail, a stored assertion) is decryptable
+ * once the wrapping key falls to a CRQC.
+ *
+ * Covered `alg` (RFC 7518 §4) values:
+ *  - `RSA-OAEP`, `RSA-OAEP-256`, `RSA1_5`  → RSA key encryption.
+ *  - `ECDH-ES`, `ECDH-ES+A128KW`, …        → classical EC Diffie-Hellman key agreement.
+ *
+ * These exact strings are JOSE identifiers, so a content-level match is precise;
+ * the detector applies to any file (config, JSON, source) after a fast reject.
+ */
+import type { Detector, Finding, RuleMeta } from "../types.js";
+import { DOC_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+
+interface JoseRule {
+  re: RegExp;
+  meta: RuleMeta;
+}
+
+const JOSE_RULES: JoseRule[] = [
+  {
+    re: /"alg"\s*:\s*"RSA(?:-OAEP(?:-256)?|1_5)"/g,
+    meta: {
+      id: "jose-jwe-rsa",
+      title: "JWE RSA key wrapping",
+      description: 'JWE "alg" of RSA-OAEP / RSA-OAEP-256 / RSA1_5 (RFC 7518)',
+      category: "kem",
+      severity: "high",
+      confidence: "high",
+      algorithm: "RSA",
+      hndl: true,
+      cwe: CWE_BROKEN_CRYPTO,
+      message:
+        "JWE wraps the content-encryption key with classical RSA (RSA-OAEP/RSA1_5); the encrypted payload is harvest-now-decrypt-later exposed.",
+      remediation:
+        "Plan migration to a post-quantum KEM (ML-KEM-768) for key wrapping as JOSE/COSE PQ algorithms are standardised.",
+    },
+  },
+  {
+    re: /"alg"\s*:\s*"ECDH-ES(?:\+A\d{3}KW)?"/g,
+    meta: {
+      id: "jose-jwe-ecdh",
+      title: "JWE ECDH-ES key agreement",
+      description: 'JWE "alg" of ECDH-ES / ECDH-ES+A*KW (RFC 7518)',
+      category: "key-exchange",
+      severity: "high",
+      confidence: "high",
+      algorithm: "ECDH",
+      hndl: true,
+      cwe: CWE_BROKEN_CRYPTO,
+      message:
+        "JWE derives the content-encryption key via classical ECDH-ES; the encrypted payload is harvest-now-decrypt-later exposed.",
+      remediation:
+        "Plan migration to hybrid post-quantum key agreement (X25519MLKEM768) as JOSE PQ algorithms are standardised.",
+    },
+  },
+];
+
+/** Detects classical JWE key-management (`alg`) values in JOSE tokens/config. */
+export const joseDetector: Detector = {
+  id: "jose-jwe-keymgmt",
+  description:
+    "Classical JWE key-management algorithms (RSA-OAEP, ECDH-ES) — confidentiality, HNDL",
+  scope: "config",
+  language: "any",
+  rules: JOSE_RULES.map((r) => r.meta),
+  // Prose examples (a README showing `"alg":"RSA-OAEP"`) are not JOSE config.
+  appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS),
+  detect({ file, content }): Finding[] {
+    // Fast reject: no JOSE key-management alg token present.
+    if (
+      !content.includes("RSA-OAEP") &&
+      !content.includes("RSA1_5") &&
+      !content.includes("ECDH-ES")
+    ) {
+      return [];
+    }
+    const findings: Finding[] = [];
+    for (const rule of JOSE_RULES) {
+      eachMatch(rule.re, content, (m) => {
+        findings.push(
+          findingFromRule(rule.meta, { file, content, index: m.index, matchLength: m[0].length }),
+        );
+      });
+    }
+    return findings;
+  },
+};

package/src/detectors/jwk.ts

@@ -0,0 +1,128 @@
+/**
+ * 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.
+ *
+ * Keying EC/OKP off `crv` (present in every EC/OKP JWK) rather than `kty` avoids
+ * double-counting a single key, and `"kty"`/`"crv"` are specific enough to RFC
+ * 7517 that the false-positive risk on ordinary JSON is low.
+ *
+ * HNDL: RSA and (EC)DH / X25519 / X448 key agreement are harvest-now-decrypt-later
+ * exposed (hndl:true); EdDSA signing keys are hndl:false but forgeable. A JWKS is
+ * usually PUBLIC keys, so severity is medium — the exposure is a classical key
+ * pair, not necessarily an embedded secret.
+ */
+import type { Detector, Finding, RuleMeta } from "../types.js";
+import { eachMatch, findingFromRule } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+
+interface JwkRule {
+  re: RegExp;
+  meta: RuleMeta;
+}
+
+const JWK_RULES: JwkRule[] = [
+  {
+    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).",
+    },
+  },
+];
+
+/** Detects classical JSON Web Key (JWK/JWKS) material in any JSON/text file. */
+export const jwkDetector: Detector = {
+  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: () => true,
+  detect({ file, content }): Finding[] {
+    // Fast reject: a JWK always has one of these two members.
+    if (!content.includes('"kty"') && !content.includes('"crv"')) return [];
+    const findings: Finding[] = [];
+    for (const rule of JWK_RULES) {
+      eachMatch(rule.re, content, (m) => {
+        findings.push(
+          findingFromRule(rule.meta, {
+            file,
+            content,
+            index: m.index,
+            matchLength: m[0].length,
+          }),
+        );
+      });
+    }
+    return findings;
+  },
+};

package/src/detectors/k8s.ts

@@ -0,0 +1,112 @@
+/**
+ * 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, Finding, RuleMeta } from "../types.js";
+import { eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO, CWE_RISKY_PRIMITIVE } from "../cwe.js";
+
+const K8S_EXTENSIONS: readonly string[] = [".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: RuleMeta = {
+  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: RuleMeta = {
+  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: RuleMeta = {
+  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: RuleMeta = {
+  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: Detector = {
+  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 }): Finding[] {
+    const isCertManager =
+      content.includes("cert-manager.io") ||
+      /kind:\s*["']?(?:Certificate|Issuer|ClusterIssuer)\b/.test(content);
+    const isIstio = content.includes("minProtocolVersion");
+    if (!isCertManager && !isIstio) return [];
+
+    const findings: Finding[] = [];
+    const add = (re: RegExp, rule: RuleMeta) =>
+      eachMatch(re, content, (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;
+  },
+};