@quantakrypto/core 0.4.2 → 0.4.4

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;
+  },
+};

package/src/detectors/mesh.ts

@@ -0,0 +1,154 @@
+/**
+ * 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 `DestinationRule` / `Gateway` `tls.cipherSuites:` listing a classical
+ *    `ECDHE-RSA-*` / `ECDHE-ECDSA-*` suite — the (EC)DHE key exchange in these
+ *    suites is classical and harvest-now-decrypt-later exposed (tls, ECDH,
+ *    hndl:true). This complements, and does not duplicate, `k8s.ts`'s
+ *    `minProtocolVersion` legacy-TLS-floor rule.
+ */
+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 MESH_EXTENSIONS: readonly string[] = [".yaml", ".yml", ".hcl"];
+
+// 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;
+
+// Istio mesh TLS cipher suites: OpenSSL-style suite names naming classical
+// ECDHE key exchange combined with an RSA or ECDSA certificate. These are
+// distinctive tokens (no generic-config collision risk).
+const RE_MESH_ISTIO_CLASSICAL_CIPHER = /\bECDHE-(?:RSA|ECDSA)-[A-Z0-9_-]+\b/g;
+
+const RULE_MESH_LINKERD_ECDSA: RuleMeta = {
+  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: RuleMeta = {
+  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: RuleMeta = {
+  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.",
+};
+const RULE_MESH_ISTIO_CLASSICAL_CIPHER: RuleMeta = {
+  id: "mesh-istio-classical-cipher",
+  title: "Istio classical ECDHE cipher suite",
+  description:
+    "Istio DestinationRule/Gateway tls.cipherSuites lists a classical ECDHE-RSA/ECDHE-ECDSA suite",
+  category: "tls",
+  severity: "medium",
+  confidence: "high",
+  algorithm: "ECDH",
+  hndl: true,
+  cwe: CWE_RISKY_PRIMITIVE,
+  message:
+    "Istio mesh TLS cipher suite allows classical ECDHE key exchange, which is harvest-now-decrypt-later exposed.",
+  remediation:
+    "Prefer TLS 1.3 AEAD suites and track PQC-hybrid mesh key exchange (X25519MLKEM768) as Envoy/BoringSSL adds support.",
+};
+
+/**
+ * Detects classical asymmetric crypto in service-mesh configuration: Linkerd's
+ * default ECDSA identity issuer, Consul Connect's mesh CA private key type,
+ * and classical ECDHE cipher suites in Istio DestinationRule/Gateway TLS
+ * policy.
+ */
+export const meshDetector: Detector = {
+  id: "service-mesh-crypto",
+  description:
+    "Classical crypto in service-mesh config (Linkerd identity, Consul Connect CA, Istio cipher suites)",
+  scope: "config",
+  language: "any",
+  rules: [
+    RULE_MESH_LINKERD_ECDSA,
+    RULE_MESH_CONSUL_RSA,
+    RULE_MESH_CONSUL_EC,
+    RULE_MESH_ISTIO_CLASSICAL_CIPHER,
+  ],
+  appliesTo: (f) => hasExtension(f, MESH_EXTENSIONS),
+  detect({ file, content }): Finding[] {
+    const isLinkerd = content.includes("linkerd") || content.includes("identityTrustAnchors");
+    const isConsulConnect = content.includes("consul") && content.includes("connect");
+    const isIstioCipher = content.includes("DestinationRule") || content.includes("cipherSuites");
+    if (!isLinkerd && !isConsulConnect && !isIstioCipher) 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 (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);
+    }
+    if (isIstioCipher) add(RE_MESH_ISTIO_CLASSICAL_CIPHER, RULE_MESH_ISTIO_CLASSICAL_CIPHER);
+    return findings;
+  },
+};

package/src/detectors/messaging.ts

@@ -0,0 +1,98 @@
+/**
+ * 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 classical `ECDHE_RSA` / `ECDHE_ECDSA` /
+ *    `TLS_RSA` suite — the harvestable key-exchange path.
+ */
+import type { Detector, Finding, RuleMeta } from "../types.js";
+import { eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
+import { CWE_RISKY_PRIMITIVE, CWE_BROKEN_CRYPTO } from "../cwe.js";
+
+const MQ_EXTENSIONS: readonly string[] = [".properties", ".conf", ".cfg", ".ini"];
+
+interface MqRule {
+  re: RegExp;
+  meta: RuleMeta;
+}
+
+const MQ_RULES: MqRule[] = [
+  {
+    // Match TLSv1 (=1.0) and TLSv1.1 but never TLSv1.2 / TLSv1.3: the negative
+    // lookahead stops "TLSv1" from matching the "TLSv1" inside "TLSv1.3".
+    re: /\bssl\.(?:enabled\.)?protocols?\s*=\s*[^\n]*\bTLSv1(?:\.1)?(?![.\d])/gi,
+    meta: {
+      id: "mq-kafka-legacy-tls",
+      title: "Kafka legacy TLS protocol",
+      description: "Kafka ssl.protocol / ssl.enabled.protocols permits TLS 1.0 / 1.1",
+      category: "tls",
+      severity: "medium",
+      confidence: "high",
+      hndl: false,
+      cwe: CWE_RISKY_PRIMITIVE,
+      message:
+        "Kafka broker permits legacy TLS 1.0/1.1; its classical key exchange is weak and harvestable.",
+      remediation: "Require TLS 1.3 and track PQC-hybrid KEX (X25519MLKEM768).",
+    },
+  },
+  {
+    re: /\btls_version\s+tlsv1(?:\.1)?(?![.\d])/gi,
+    meta: {
+      id: "mq-mqtt-legacy-tls",
+      title: "MQTT legacy TLS version",
+      description: "Mosquitto/MQTT tls_version permits TLS 1.0 / 1.1",
+      category: "tls",
+      severity: "medium",
+      confidence: "high",
+      hndl: false,
+      cwe: CWE_RISKY_PRIMITIVE,
+      message:
+        "MQTT broker permits legacy TLS 1.0/1.1; its classical key exchange is weak and harvestable.",
+      remediation: "Require TLS 1.3 and track PQC-hybrid KEX for device fleets.",
+    },
+  },
+  {
+    re: /\bssl\.cipher\.suites\s*=\s*[^\n]*(?:ECDHE_RSA|ECDHE_ECDSA|TLS_RSA|_DHE_RSA)/g,
+    meta: {
+      id: "mq-classical-cipher",
+      title: "Broker classical (EC)DHE cipher suite",
+      description: "Kafka ssl.cipher.suites names a classical ECDHE/DHE/RSA suite",
+      category: "tls",
+      severity: "medium",
+      confidence: "high",
+      algorithm: "ECDH",
+      hndl: true,
+      cwe: CWE_BROKEN_CRYPTO,
+      message:
+        "Broker TLS is pinned to a classical (EC)DHE/RSA cipher suite; the key exchange is harvest-now-decrypt-later exposed.",
+      remediation:
+        "Move to TLS 1.3 with a PQC-hybrid group (X25519MLKEM768) once the broker/runtime supports it.",
+    },
+  },
+];
+
+/** Detects classical transport crypto in message-broker / event-stream config. */
+export const messagingDetector: Detector = {
+  id: "messaging-transport",
+  description: "Classical transport crypto in message brokers (Kafka, MQTT, RabbitMQ, NATS)",
+  scope: "config",
+  language: "any",
+  rules: MQ_RULES.map((r) => r.meta),
+  appliesTo: (f) => hasExtension(f, MQ_EXTENSIONS),
+  detect({ file, content }): Finding[] {
+    const findings: Finding[] = [];
+    for (const rule of MQ_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/pem.ts

@@ -51,7 +51,7 @@ const PEM_RULES: PemRule[] = [
       sensitive: true,
       message: "Embedded EC private key (SEC1 PEM); classical ECDSA/ECDH key, not quantum-safe.",
       remediation:
-        "Migrate to ML-DSA (FIPS 204) keys and remove embedded private keys from source.",
+        "Migrate to ML-DSA (FIPS 204) for signatures or hybrid X25519MLKEM768 for key agreement; remove embedded private keys from source.",
     },
   },
   {
@@ -86,7 +86,8 @@ const PEM_RULES: PemRule[] = [
       cwe: CWE_HARDCODED_KEY,
       sensitive: true,
       message: "Embedded OpenSSH private key (RSA/ECDSA/Ed25519); classical and not quantum-safe.",
-      remediation: "Rotate the key; plan migration to PQC-capable SSH (e.g. sntrup761x25519).",
+      remediation:
+        "Rotate the key; plan migration to PQC-capable SSH (prefer the mlkem768x25519-sha256 KEX, OpenSSH 10's default since Apr 2025).",
     },
   },
   {
@@ -157,6 +158,57 @@ const PEM_RULES: PemRule[] = [
       remediation: "Plan re-issuance with PQC-capable CAs as ML-DSA certificate profiles mature.",
     },
   },
+  {
+    re: /-----BEGIN (?:RSA )?PUBLIC KEY-----/g,
+    meta: {
+      id: "pem-public-key",
+      title: "Classical public key (PEM)",
+      description: "SubjectPublicKeyInfo / PKCS#1 RSA public key block",
+      category: "certificate",
+      severity: "low",
+      confidence: "high",
+      algorithm: "unknown",
+      hndl: false,
+      cwe: CWE_BROKEN_CRYPTO,
+      message:
+        "Embedded classical public key (RSA/EC/DSA); its key pair is not quantum-safe — forgeable signatures or classical key exchange.",
+      remediation: "Re-issue with PQC keys (ML-DSA / ML-KEM) as the ecosystem adopts them.",
+    },
+  },
+  {
+    re: /-----BEGIN DH PARAMETERS-----/g,
+    meta: {
+      id: "pem-dh-parameters",
+      title: "Diffie-Hellman parameters (PEM)",
+      description: "Finite-field DH group parameters block",
+      category: "key-exchange",
+      severity: "medium",
+      confidence: "high",
+      algorithm: "DH",
+      hndl: true,
+      cwe: CWE_BROKEN_CRYPTO,
+      message:
+        "Embedded finite-field Diffie-Hellman parameters; classical DH key exchange is harvest-now-decrypt-later exposed.",
+      remediation: "Migrate key exchange to hybrid X25519MLKEM768 (ML-KEM-768).",
+    },
+  },
+  {
+    re: /-----BEGIN (?:NEW )?CERTIFICATE REQUEST-----/g,
+    meta: {
+      id: "pem-cert-request",
+      title: "Certificate signing request (PEM)",
+      description: "PKCS#10 certificate request block",
+      category: "certificate",
+      severity: "low",
+      confidence: "high",
+      algorithm: "unknown",
+      hndl: false,
+      cwe: CWE_BROKEN_CRYPTO,
+      message:
+        "Embedded PKCS#10 CSR; carries a classical public key and will be signed with classical crypto.",
+      remediation: "Re-generate with PQC keys as PQC-capable CAs mature.",
+    },
+  },
 ];
 
 /** Detects PEM key/certificate material in arbitrary files. */