@quantakrypto/core 0.4.3 → 0.5.0

package/dist/detectors/terraform.js

@@ -0,0 +1,150 @@
+import { eachMatch, findingFromRule, hasExtension, maskBlockComments, maskCommentLines, } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+const TF_EXTENSIONS = [".tf", ".tf.json"];
+// Each attribute is matched in BOTH HCL (`algorithm = "RSA"`) and the `.tf.json`
+// variant (`"algorithm": "RSA"`): an optional quote around the key, and `:` or
+// `=` as the separator. The `(?<![\w"-])` lookbehind stops a longer attribute
+// name (`my_algorithm`) from matching on its suffix.
+// RSA: tls_private_key `"RSA"` plus the Google KMS `RSA_SIGN_…` / `RSA_DECRYPT_…`.
+const RE_TF_RSA = /(?<![\w"-])"?algorithm"?\s*[:=]\s*"RSA(?:_[A-Z0-9_]+)?"/g;
+// ECDSA / EC signing: tls_private_key `"ECDSA"` and Google KMS `"EC_SIGN_…"`.
+const RE_TF_ECDSA = /(?<![\w"-])"?algorithm"?\s*[:=]\s*"(?:ECDSA|EC_SIGN_[A-Z0-9_]+)"/g;
+// EdDSA signing: hashicorp/tls `tls_private_key` `algorithm = "ED25519"` (a supported,
+// classical algorithm the RSA/ECDSA rules miss).
+const RE_TF_ED25519 = /(?<![\w"-])"?algorithm"?\s*[:=]\s*"ED25519"/g;
+// AWS KMS key specs: the legacy `customer_master_key_spec` and the modern `key_spec`
+// alias (aws provider v4+). The `(?<![\w"-])` lookbehind rejects the `key_spec` suffix
+// inside `customer_master_key_spec` (preceded by `_`), so no double-count.
+const RE_TF_KMS_RSA = /(?<![\w"-])"?(?:customer_master_key_spec|key_spec)"?\s*[:=]\s*"RSA_\d+"/g;
+const RE_TF_KMS_EC = /(?<![\w"-])"?(?:customer_master_key_spec|key_spec)"?\s*[:=]\s*"ECC_[A-Z0-9_]+"/g;
+// `key_type` key material: Azure Key Vault (`"RSA"` / `"EC"`, incl. `-HSM`) and
+// HashiCorp Vault PKI, which uses the lowercase `"rsa"` / `"ec"` tokens — so the value
+// is matched case-insensitively. The `"…"` bound keeps `"ec"` from matching `"ecc"`,
+// and `customer_master_key_spec` (AWS) is a different attribute handled above.
+const RE_TF_AZ_RSA = /(?<![\w"-])"?key_type"?\s*[:=]\s*"RSA(?:-HSM)?"/gi;
+const RE_TF_AZ_EC = /(?<![\w"-])"?key_type"?\s*[:=]\s*"EC(?:-HSM)?"/gi;
+const RULE_TF_RSA = {
+    id: "tf-rsa-key",
+    title: "Terraform RSA key",
+    description: "Terraform tls_private_key / KMS RSA key material",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Terraform provisions a classical RSA key, which is not quantum-safe.",
+    remediation: "Plan migration to PQC (ML-KEM-768 for encryption, ML-DSA-65 for signatures).",
+};
+const RULE_TF_ECDSA = {
+    id: "tf-ecdsa-key",
+    title: "Terraform ECDSA key",
+    description: "Terraform tls_private_key / KMS EC signing key",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Terraform provisions a classical ECDSA key, forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).",
+};
+const RULE_TF_ED25519 = {
+    id: "tf-ed25519-key",
+    title: "Terraform Ed25519 key",
+    description: 'Terraform tls_private_key algorithm = "ED25519"',
+    category: "signature",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "EdDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Terraform provisions a classical Ed25519 key, forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).",
+};
+const RULE_TF_KMS_RSA = {
+    id: "tf-kms-rsa",
+    title: "Terraform AWS KMS RSA CMK",
+    description: 'Terraform aws_kms_key customer_master_key_spec = "RSA_*"',
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Terraform provisions a classical RSA KMS customer master key (harvest-now-decrypt-later exposed for encryption CMKs).",
+    remediation: "Plan migration to PQC as cloud KMS adds ML-KEM / ML-DSA key specs.",
+};
+const RULE_TF_KMS_EC = {
+    id: "tf-kms-ec",
+    title: "Terraform AWS KMS EC CMK",
+    description: 'Terraform aws_kms_key customer_master_key_spec = "ECC_*"',
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Terraform provisions a classical EC KMS customer master key; EC keys feed 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).",
+};
+const RULE_TF_AZ_RSA = {
+    id: "tf-keyvault-rsa",
+    title: "Terraform Azure Key Vault RSA key",
+    description: 'Terraform azurerm_key_vault_key key_type = "RSA"',
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Terraform provisions a classical RSA Azure Key Vault key, which is not quantum-safe.",
+    remediation: "Plan migration to PQC (ML-KEM-768 / ML-DSA-65).",
+};
+const RULE_TF_AZ_EC = {
+    id: "tf-keyvault-ec",
+    title: "Terraform Azure Key Vault EC key",
+    description: 'Terraform azurerm_key_vault_key key_type = "EC"',
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Terraform provisions a classical EC Azure Key Vault key; EC keys feed 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).",
+};
+/** Detects classical asymmetric crypto provisioned in Terraform / OpenTofu. */
+export const terraformDetector = {
+    id: "terraform-crypto",
+    description: "Classical asymmetric crypto provisioned by Terraform / OpenTofu (IaC)",
+    scope: "config",
+    language: "any",
+    rules: [
+        RULE_TF_RSA,
+        RULE_TF_ECDSA,
+        RULE_TF_ED25519,
+        RULE_TF_KMS_RSA,
+        RULE_TF_KMS_EC,
+        RULE_TF_AZ_RSA,
+        RULE_TF_AZ_EC,
+    ],
+    appliesTo: (f) => hasExtension(f, TF_EXTENSIONS),
+    detect({ file, content }) {
+        const findings = [];
+        // A commented HCL argument (`# algorithm = "RSA"`, `//` lines, and `/* … */` block
+        // comments) is not an active resource argument. Mask block comments then line
+        // comments; offsets preserved.
+        const scan = maskCommentLines(maskBlockComments(content), ["#", "//"]);
+        const add = (re, rule) => eachMatch(re, scan, (m) => findings.push(findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length })));
+        add(RE_TF_RSA, RULE_TF_RSA);
+        add(RE_TF_ECDSA, RULE_TF_ECDSA);
+        add(RE_TF_ED25519, RULE_TF_ED25519);
+        add(RE_TF_KMS_RSA, RULE_TF_KMS_RSA);
+        add(RE_TF_KMS_EC, RULE_TF_KMS_EC);
+        add(RE_TF_AZ_RSA, RULE_TF_AZ_RSA);
+        add(RE_TF_AZ_EC, RULE_TF_AZ_EC);
+        return findings;
+    },
+};
+//# sourceMappingURL=terraform.js.map

package/dist/detectors/terraform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terraform.js","sourceRoot":"","sources":["../../src/detectors/terraform.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * IaC detector: classical asymmetric cryptography provisioned by Terraform /\n * OpenTofu (`.tf`, `.tf.json`). Infrastructure-as-code mints real keys and CMKs\n * that never appear in application source, so this is a distinct surface from the\n * language packs.\n *\n * Covered:\n *  - hashicorp/tls `tls_private_key`:      `algorithm = \"RSA\" | \"ECDSA\"`\n *  - Google Cloud KMS `version_template`:  `algorithm = \"RSA_SIGN_…\" | \"EC_SIGN_…\"`\n *  - AWS KMS `aws_kms_key`:                `customer_master_key_spec = \"RSA_…\" | \"ECC_…\"`\n *  - Azure `azurerm_key_vault_key`:        `key_type = \"RSA\" | \"EC\"` (+ HSM variants)\n *\n * The HCL assignment forms (`algorithm = \"…\"`, `customer_master_key_spec = \"…\"`,\n * `key_type = \"…\"`) are specific enough inside `.tf` files that the false-positive\n * risk is low. EC keys are classified conservatively as key-agreement-capable\n * (hndl:true) since a provisioned EC key can feed ECDH.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport {\n  eachMatch,\n  findingFromRule,\n  hasExtension,\n  maskBlockComments,\n  maskCommentLines,\n} from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO } from \"../cwe.js\";\n\nconst TF_EXTENSIONS: readonly string[] = [\".tf\", \".tf.json\"];\n\n// Each attribute is matched in BOTH HCL (`algorithm = \"RSA\"`) and the `.tf.json`\n// variant (`\"algorithm\": \"RSA\"`): an optional quote around the key, and `:` or\n// `=` as the separator. The `(?<![\\w\"-])` lookbehind stops a longer attribute\n// name (`my_algorithm`) from matching on its suffix.\n// RSA: tls_private_key `\"RSA\"` plus the Google KMS `RSA_SIGN_…` / `RSA_DECRYPT_…`.\nconst RE_TF_RSA = /(?<![\\w\"-])\"?algorithm\"?\\s*[:=]\\s*\"RSA(?:_[A-Z0-9_]+)?\"/g;\n// ECDSA / EC signing: tls_private_key `\"ECDSA\"` and Google KMS `\"EC_SIGN_…\"`.\nconst RE_TF_ECDSA = /(?<![\\w\"-])\"?algorithm\"?\\s*[:=]\\s*\"(?:ECDSA|EC_SIGN_[A-Z0-9_]+)\"/g;\n// EdDSA signing: hashicorp/tls `tls_private_key` `algorithm = \"ED25519\"` (a supported,\n// classical algorithm the RSA/ECDSA rules miss).\nconst RE_TF_ED25519 = /(?<![\\w\"-])\"?algorithm\"?\\s*[:=]\\s*\"ED25519\"/g;\n// AWS KMS key specs: the legacy `customer_master_key_spec` and the modern `key_spec`\n// alias (aws provider v4+). The `(?<![\\w\"-])` lookbehind rejects the `key_spec` suffix\n// inside `customer_master_key_spec` (preceded by `_`), so no double-count.\nconst RE_TF_KMS_RSA = /(?<![\\w\"-])\"?(?:customer_master_key_spec|key_spec)\"?\\s*[:=]\\s*\"RSA_\\d+\"/g;\nconst RE_TF_KMS_EC =\n  /(?<![\\w\"-])\"?(?:customer_master_key_spec|key_spec)\"?\\s*[:=]\\s*\"ECC_[A-Z0-9_]+\"/g;\n// `key_type` key material: Azure Key Vault (`\"RSA\"` / `\"EC\"`, incl. `-HSM`) and\n// HashiCorp Vault PKI, which uses the lowercase `\"rsa\"` / `\"ec\"` tokens — so the value\n// is matched case-insensitively. The `\"…\"` bound keeps `\"ec\"` from matching `\"ecc\"`,\n// and `customer_master_key_spec` (AWS) is a different attribute handled above.\nconst RE_TF_AZ_RSA = /(?<![\\w\"-])\"?key_type\"?\\s*[:=]\\s*\"RSA(?:-HSM)?\"/gi;\nconst RE_TF_AZ_EC = /(?<![\\w\"-])\"?key_type\"?\\s*[:=]\\s*\"EC(?:-HSM)?\"/gi;\n\nconst RULE_TF_RSA: RuleMeta = {\n  id: \"tf-rsa-key\",\n  title: \"Terraform RSA key\",\n  description: \"Terraform tls_private_key / KMS RSA key material\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Terraform provisions a classical RSA key, which is not quantum-safe.\",\n  remediation: \"Plan migration to PQC (ML-KEM-768 for encryption, ML-DSA-65 for signatures).\",\n};\nconst RULE_TF_ECDSA: RuleMeta = {\n  id: \"tf-ecdsa-key\",\n  title: \"Terraform ECDSA key\",\n  description: \"Terraform tls_private_key / KMS EC signing key\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Terraform provisions a classical ECDSA key, forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).\",\n};\nconst RULE_TF_ED25519: RuleMeta = {\n  id: \"tf-ed25519-key\",\n  title: \"Terraform Ed25519 key\",\n  description: 'Terraform tls_private_key algorithm = \"ED25519\"',\n  category: \"signature\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Terraform provisions a classical Ed25519 key, forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).\",\n};\nconst RULE_TF_KMS_RSA: RuleMeta = {\n  id: \"tf-kms-rsa\",\n  title: \"Terraform AWS KMS RSA CMK\",\n  description: 'Terraform aws_kms_key customer_master_key_spec = \"RSA_*\"',\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Terraform provisions a classical RSA KMS customer master key (harvest-now-decrypt-later exposed for encryption CMKs).\",\n  remediation: \"Plan migration to PQC as cloud KMS adds ML-KEM / ML-DSA key specs.\",\n};\nconst RULE_TF_KMS_EC: RuleMeta = {\n  id: \"tf-kms-ec\",\n  title: \"Terraform AWS KMS EC CMK\",\n  description: 'Terraform aws_kms_key customer_master_key_spec = \"ECC_*\"',\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Terraform provisions a classical EC KMS customer master key; EC keys feed 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};\nconst RULE_TF_AZ_RSA: RuleMeta = {\n  id: \"tf-keyvault-rsa\",\n  title: \"Terraform Azure Key Vault RSA key\",\n  description: 'Terraform azurerm_key_vault_key key_type = \"RSA\"',\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Terraform provisions a classical RSA Azure Key Vault key, which is not quantum-safe.\",\n  remediation: \"Plan migration to PQC (ML-KEM-768 / ML-DSA-65).\",\n};\nconst RULE_TF_AZ_EC: RuleMeta = {\n  id: \"tf-keyvault-ec\",\n  title: \"Terraform Azure Key Vault EC key\",\n  description: 'Terraform azurerm_key_vault_key key_type = \"EC\"',\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Terraform provisions a classical EC Azure Key Vault key; EC keys feed 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/** Detects classical asymmetric crypto provisioned in Terraform / OpenTofu. */\nexport const terraformDetector: Detector = {\n  id: \"terraform-crypto\",\n  description: \"Classical asymmetric crypto provisioned by Terraform / OpenTofu (IaC)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: [\n    RULE_TF_RSA,\n    RULE_TF_ECDSA,\n    RULE_TF_ED25519,\n    RULE_TF_KMS_RSA,\n    RULE_TF_KMS_EC,\n    RULE_TF_AZ_RSA,\n    RULE_TF_AZ_EC,\n  ],\n  appliesTo: (f) => hasExtension(f, TF_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const findings: Finding[] = [];\n    // A commented HCL argument (`# algorithm = \"RSA\"`, `//` lines, and `/* … */` block\n    // comments) is not an active resource argument. Mask block comments then line\n    // comments; offsets preserved.\n    const scan = maskCommentLines(maskBlockComments(content), [\"#\", \"//\"]);\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    add(RE_TF_RSA, RULE_TF_RSA);\n    add(RE_TF_ECDSA, RULE_TF_ECDSA);\n    add(RE_TF_ED25519, RULE_TF_ED25519);\n    add(RE_TF_KMS_RSA, RULE_TF_KMS_RSA);\n    add(RE_TF_KMS_EC, RULE_TF_KMS_EC);\n    add(RE_TF_AZ_RSA, RULE_TF_AZ_RSA);\n    add(RE_TF_AZ_EC, RULE_TF_AZ_EC);\n    return findings;\n  },\n};\n"]}

package/dist/detectors/vault.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Config detector: classical asymmetric keys in native HashiCorp Vault server
+ * config / policy (HCL). Terraform-provisioned Vault is caught by the terraform
+ * detector (`.tf`); this covers Vault's OWN `.hcl` config — the `transit` and
+ * `pki` secrets engines, whose keys sign and wrap real production data.
+ *
+ * Covered (gated to a `transit`/`pki` marker to avoid firing on unrelated HCL):
+ *  - transit key `type = "rsa-2048|3072|4096"` (RSA — key wrapping / signing).
+ *  - transit key `type = "ecdsa-p256|p384|p521"` / `"ed25519"` (classical signing).
+ *  - pki role `key_type = "rsa" | "ec"`.
+ */
+import type { Detector } from "../types.js";
+/** Detects classical asymmetric keys in native Vault HCL config. */
+export declare const vaultDetector: Detector;
+//# sourceMappingURL=vault.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vault.d.ts","sourceRoot":"","sources":["../../src/detectors/vault.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAkF/D,oEAAoE;AACpE,eAAO,MAAM,aAAa,EAAE,QAyB3B,CAAC"}

package/dist/detectors/vault.js

@@ -0,0 +1,97 @@
+import { eachMatch, findingFromRule, hasExtension, maskCommentLines } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+const HCL_EXTENSIONS = [".hcl"];
+const RE_TRANSIT_RSA = /\btype\s*=\s*"rsa-\d+"/g;
+const RE_TRANSIT_ECDSA = /\btype\s*=\s*"ecdsa-p\d+"/g;
+const RE_TRANSIT_ED25519 = /\btype\s*=\s*"ed25519"/g;
+const RE_PKI_RSA = /\bkey_type\s*=\s*"rsa"/g;
+const RE_PKI_EC = /\bkey_type\s*=\s*"ec"/g;
+const RULE_TRANSIT_RSA = {
+    id: "vault-transit-rsa",
+    title: "Vault transit RSA key",
+    description: 'Vault transit secrets engine key type = "rsa-*"',
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Vault transit provisions a classical RSA key (signing / key wrapping), not quantum-safe.",
+    remediation: "Plan migration to PQC (ML-KEM-768 for wrapping, ML-DSA-65 for signing) as Vault adds support.",
+};
+const RULE_TRANSIT_ECDSA = {
+    id: "vault-transit-ecdsa",
+    title: "Vault transit ECDSA key",
+    description: 'Vault transit secrets engine key type = "ecdsa-p*"',
+    category: "signature",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Vault transit provisions a classical ECDSA signing key, forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).",
+};
+const RULE_TRANSIT_ED25519 = {
+    id: "vault-transit-ed25519",
+    title: "Vault transit Ed25519 key",
+    description: 'Vault transit secrets engine key type = "ed25519"',
+    category: "signature",
+    severity: "low",
+    confidence: "high",
+    algorithm: "EdDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Vault transit provisions a classical Ed25519 signing key, forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).",
+};
+const RULE_PKI_RSA = {
+    id: "vault-pki-rsa",
+    title: "Vault PKI RSA role",
+    description: 'Vault pki secrets engine role key_type = "rsa"',
+    category: "certificate",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Vault PKI mints certificates with a classical RSA key, not quantum-safe.",
+    remediation: "Plan migration to PQC certificate keys (ML-DSA-65) as the CA chain adds support.",
+};
+const RULE_PKI_EC = {
+    id: "vault-pki-ec",
+    title: "Vault PKI EC role",
+    description: 'Vault pki secrets engine role key_type = "ec"',
+    category: "certificate",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Vault PKI mints certificates with a classical EC key, forgeable by a quantum attacker.",
+    remediation: "Plan migration to ML-DSA-65 (FIPS 204) certificate keys.",
+};
+/** Detects classical asymmetric keys in native Vault HCL config. */
+export const vaultDetector = {
+    id: "vault-crypto",
+    description: "Classical asymmetric keys in native HashiCorp Vault config (transit, pki)",
+    scope: "config",
+    language: "any",
+    rules: [RULE_TRANSIT_RSA, RULE_TRANSIT_ECDSA, RULE_TRANSIT_ED25519, RULE_PKI_RSA, RULE_PKI_EC],
+    appliesTo: (f) => hasExtension(f, HCL_EXTENSIONS),
+    detect({ file, content }) {
+        // Gate: only inside a Vault transit / pki context.
+        if (!content.includes("transit") && !content.includes("pki"))
+            return [];
+        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 })));
+        add(RE_TRANSIT_RSA, RULE_TRANSIT_RSA);
+        add(RE_TRANSIT_ECDSA, RULE_TRANSIT_ECDSA);
+        add(RE_TRANSIT_ED25519, RULE_TRANSIT_ED25519);
+        add(RE_PKI_RSA, RULE_PKI_RSA);
+        add(RE_PKI_EC, RULE_PKI_EC);
+        return findings;
+    },
+};
+//# sourceMappingURL=vault.js.map

package/dist/detectors/vault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault.js","sourceRoot":"","sources":["../../src/detectors/vault.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Config detector: classical asymmetric keys in native HashiCorp Vault server\n * config / policy (HCL). Terraform-provisioned Vault is caught by the terraform\n * detector (`.tf`); this covers Vault's OWN `.hcl` config — the `transit` and\n * `pki` secrets engines, whose keys sign and wrap real production data.\n *\n * Covered (gated to a `transit`/`pki` marker to avoid firing on unrelated HCL):\n *  - transit key `type = \"rsa-2048|3072|4096\"` (RSA — key wrapping / signing).\n *  - transit key `type = \"ecdsa-p256|p384|p521\"` / `\"ed25519\"` (classical signing).\n *  - pki role `key_type = \"rsa\" | \"ec\"`.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport { eachMatch, findingFromRule, hasExtension, maskCommentLines } from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO } from \"../cwe.js\";\n\nconst HCL_EXTENSIONS: readonly string[] = [\".hcl\"];\n\nconst RE_TRANSIT_RSA = /\\btype\\s*=\\s*\"rsa-\\d+\"/g;\nconst RE_TRANSIT_ECDSA = /\\btype\\s*=\\s*\"ecdsa-p\\d+\"/g;\nconst RE_TRANSIT_ED25519 = /\\btype\\s*=\\s*\"ed25519\"/g;\nconst RE_PKI_RSA = /\\bkey_type\\s*=\\s*\"rsa\"/g;\nconst RE_PKI_EC = /\\bkey_type\\s*=\\s*\"ec\"/g;\n\nconst RULE_TRANSIT_RSA: RuleMeta = {\n  id: \"vault-transit-rsa\",\n  title: \"Vault transit RSA key\",\n  description: 'Vault transit secrets engine key type = \"rsa-*\"',\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Vault transit provisions a classical RSA key (signing / key wrapping), not quantum-safe.\",\n  remediation:\n    \"Plan migration to PQC (ML-KEM-768 for wrapping, ML-DSA-65 for signing) as Vault adds support.\",\n};\nconst RULE_TRANSIT_ECDSA: RuleMeta = {\n  id: \"vault-transit-ecdsa\",\n  title: \"Vault transit ECDSA key\",\n  description: 'Vault transit secrets engine key type = \"ecdsa-p*\"',\n  category: \"signature\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Vault transit provisions a classical ECDSA signing key, forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).\",\n};\nconst RULE_TRANSIT_ED25519: RuleMeta = {\n  id: \"vault-transit-ed25519\",\n  title: \"Vault transit Ed25519 key\",\n  description: 'Vault transit secrets engine key type = \"ed25519\"',\n  category: \"signature\",\n  severity: \"low\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Vault transit provisions a classical Ed25519 signing key, forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205).\",\n};\nconst RULE_PKI_RSA: RuleMeta = {\n  id: \"vault-pki-rsa\",\n  title: \"Vault PKI RSA role\",\n  description: 'Vault pki secrets engine role 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: \"Vault PKI mints certificates with a classical RSA key, not quantum-safe.\",\n  remediation: \"Plan migration to PQC certificate keys (ML-DSA-65) as the CA chain adds support.\",\n};\nconst RULE_PKI_EC: RuleMeta = {\n  id: \"vault-pki-ec\",\n  title: \"Vault PKI EC role\",\n  description: 'Vault pki secrets engine role 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: \"Vault PKI mints certificates with a classical EC key, forgeable by a quantum attacker.\",\n  remediation: \"Plan migration to ML-DSA-65 (FIPS 204) certificate keys.\",\n};\n\n/** Detects classical asymmetric keys in native Vault HCL config. */\nexport const vaultDetector: Detector = {\n  id: \"vault-crypto\",\n  description: \"Classical asymmetric keys in native HashiCorp Vault config (transit, pki)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: [RULE_TRANSIT_RSA, RULE_TRANSIT_ECDSA, RULE_TRANSIT_ED25519, RULE_PKI_RSA, RULE_PKI_EC],\n  appliesTo: (f) => hasExtension(f, HCL_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    // Gate: only inside a Vault transit / pki context.\n    if (!content.includes(\"transit\") && !content.includes(\"pki\")) return [];\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    add(RE_TRANSIT_RSA, RULE_TRANSIT_RSA);\n    add(RE_TRANSIT_ECDSA, RULE_TRANSIT_ECDSA);\n    add(RE_TRANSIT_ED25519, RULE_TRANSIT_ED25519);\n    add(RE_PKI_RSA, RULE_PKI_RSA);\n    add(RE_PKI_EC, RULE_PKI_EC);\n    return findings;\n  },\n};\n"]}

package/dist/detectors/vpn.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Config detector: classical key exchange in network transport / VPN config —
+ * WireGuard and IPsec (strongSwan). These are the tunnels carrying "communication
+ * between things"; their key exchange is classical and so harvest-now-decrypt-later
+ * exposed (a recorded tunnel is decryptable once a CRQC exists).
+ *
+ * Covered (each gated so it only fires inside the relevant config):
+ *  - **WireGuard** — `[Interface]`/`[Peer]` sections with `PrivateKey`/`PublicKey`.
+ *    WireGuard's Noise handshake is Curve25519 with NO standard PQC option, so this
+ *    is an especially sharp finding: it cannot be made quantum-safe without a
+ *    tunnel-wrapping layer. The private key is treated as sensitive key material.
+ *  - **IPsec / strongSwan** — IKE/ESP proposals naming classical DH groups
+ *    (`modp*` = finite-field DH, `ecp*` = ECDH).
+ *
+ * `sshd_config` / `ssh_config` KexAlgorithms are intentionally NOT handled here —
+ * the language-agnostic SSH token detector in `source.ts` (`ssh-kex-classical`)
+ * already covers them; a rule here would double-count.
+ */
+import type { Detector } from "../types.js";
+/** Detects classical key exchange in WireGuard / IPsec network config. */
+export declare const vpnDetector: Detector;
+//# sourceMappingURL=vpn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vpn.d.ts","sourceRoot":"","sources":["../../src/detectors/vpn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAwD/D,0EAA0E;AAC1E,eAAO,MAAM,WAAW,EAAE,QA2BzB,CAAC"}

package/dist/detectors/vpn.js

@@ -0,0 +1,73 @@
+import { eachMatch, findingFromRule, hasExtension, maskCommentLines } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+const CONF_EXTENSIONS = [".conf"];
+const RE_WG_KEY = /\b(?:PrivateKey|PublicKey)\s*=\s*[A-Za-z0-9+/]{42,}=/g;
+const RE_IPSEC_MODP = /\bmodp\d+\b/gi;
+const RE_IPSEC_ECP = /\becp\d+(?:bp)?\b/gi;
+const RULE_WG = {
+    id: "net-wireguard-x25519",
+    title: "WireGuard Curve25519 key",
+    description: "WireGuard [Interface]/[Peer] key — Curve25519 Noise handshake (no PQC option)",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "X25519",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    sensitive: true,
+    message: "WireGuard tunnel keyed by classical Curve25519 (Noise); WireGuard has no standard post-quantum KEM, so the tunnel is harvest-now-decrypt-later exposed until wrapped by a PQC layer.",
+    remediation: "Wrap the tunnel in a PQC-hybrid transport (e.g. a TLS 1.3 X25519MLKEM768 layer) or track WireGuard PQC proposals; rotate keys when available.",
+};
+const RULE_IPSEC_DH = {
+    id: "net-ipsec-modp-dh",
+    title: "IPsec classical DH group (modp)",
+    description: "IPsec/strongSwan IKE/ESP proposal names a finite-field DH group (modp*)",
+    category: "key-exchange",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "DH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "IPsec proposal uses a classical finite-field Diffie-Hellman group (modp*); the tunnel key exchange is harvest-now-decrypt-later exposed.",
+    remediation: "Add a PQC/hybrid IKE proposal (ML-KEM) as your IPsec stack supports it.",
+};
+const RULE_IPSEC_EC = {
+    id: "net-ipsec-ecp-ecdh",
+    title: "IPsec classical ECDH group (ecp)",
+    description: "IPsec/strongSwan IKE/ESP proposal names an elliptic-curve DH group (ecp*)",
+    category: "key-exchange",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "ECDH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "IPsec proposal uses a classical elliptic-curve Diffie-Hellman group (ecp*); the tunnel key exchange is harvest-now-decrypt-later exposed.",
+    remediation: "Add a PQC/hybrid IKE proposal (X25519MLKEM768 / ML-KEM) as your IPsec stack supports it.",
+};
+/** Detects classical key exchange in WireGuard / IPsec network config. */
+export const vpnDetector = {
+    id: "network-transport-crypto",
+    description: "Classical key exchange in network transport / VPN config (WireGuard, IPsec)",
+    scope: "config",
+    language: "any",
+    rules: [RULE_WG, RULE_IPSEC_DH, RULE_IPSEC_EC],
+    appliesTo: (f) => hasExtension(f, CONF_EXTENSIONS),
+    detect({ file, content }) {
+        const findings = [];
+        const push = (rule, index, length) => findings.push(findingFromRule(rule, { file, content, index, matchLength: length }));
+        // ipsec.conf / wg configs use `#` line comments. Match over comment-masked
+        // content (offsets preserved); gates stay on the original.
+        const scan = maskCommentLines(content, ["#"]);
+        // WireGuard: gated to a WireGuard config section.
+        if (content.includes("[Interface]") || content.includes("[Peer]")) {
+            eachMatch(RE_WG_KEY, scan, (m) => push(RULE_WG, m.index, m[0].length));
+        }
+        // IPsec / strongSwan: gated to a proposal assignment.
+        if (/\b(?:ike|esp|proposals?|keyexchange)\s*=/i.test(content)) {
+            eachMatch(RE_IPSEC_MODP, scan, (m) => push(RULE_IPSEC_DH, m.index, m[0].length));
+            eachMatch(RE_IPSEC_ECP, scan, (m) => push(RULE_IPSEC_EC, m.index, m[0].length));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=vpn.js.map

package/dist/detectors/vpn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vpn.js","sourceRoot":"","sources":["../../src/detectors/vpn.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Config detector: classical key exchange in network transport / VPN config —\n * WireGuard and IPsec (strongSwan). These are the tunnels carrying \"communication\n * between things\"; their key exchange is classical and so harvest-now-decrypt-later\n * exposed (a recorded tunnel is decryptable once a CRQC exists).\n *\n * Covered (each gated so it only fires inside the relevant config):\n *  - **WireGuard** — `[Interface]`/`[Peer]` sections with `PrivateKey`/`PublicKey`.\n *    WireGuard's Noise handshake is Curve25519 with NO standard PQC option, so this\n *    is an especially sharp finding: it cannot be made quantum-safe without a\n *    tunnel-wrapping layer. The private key is treated as sensitive key material.\n *  - **IPsec / strongSwan** — IKE/ESP proposals naming classical DH groups\n *    (`modp*` = finite-field DH, `ecp*` = ECDH).\n *\n * `sshd_config` / `ssh_config` KexAlgorithms are intentionally NOT handled here —\n * the language-agnostic SSH token detector in `source.ts` (`ssh-kex-classical`)\n * already covers them; a rule here would 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\nconst CONF_EXTENSIONS: readonly string[] = [\".conf\"];\n\nconst RE_WG_KEY = /\\b(?:PrivateKey|PublicKey)\\s*=\\s*[A-Za-z0-9+/]{42,}=/g;\nconst RE_IPSEC_MODP = /\\bmodp\\d+\\b/gi;\nconst RE_IPSEC_ECP = /\\becp\\d+(?:bp)?\\b/gi;\n\nconst RULE_WG: RuleMeta = {\n  id: \"net-wireguard-x25519\",\n  title: \"WireGuard Curve25519 key\",\n  description: \"WireGuard [Interface]/[Peer] key — Curve25519 Noise handshake (no PQC option)\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"X25519\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  sensitive: true,\n  message:\n    \"WireGuard tunnel keyed by classical Curve25519 (Noise); WireGuard has no standard post-quantum KEM, so the tunnel is harvest-now-decrypt-later exposed until wrapped by a PQC layer.\",\n  remediation:\n    \"Wrap the tunnel in a PQC-hybrid transport (e.g. a TLS 1.3 X25519MLKEM768 layer) or track WireGuard PQC proposals; rotate keys when available.\",\n};\nconst RULE_IPSEC_DH: RuleMeta = {\n  id: \"net-ipsec-modp-dh\",\n  title: \"IPsec classical DH group (modp)\",\n  description: \"IPsec/strongSwan IKE/ESP proposal names a finite-field DH group (modp*)\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"DH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"IPsec proposal uses a classical finite-field Diffie-Hellman group (modp*); the tunnel key exchange is harvest-now-decrypt-later exposed.\",\n  remediation: \"Add a PQC/hybrid IKE proposal (ML-KEM) as your IPsec stack supports it.\",\n};\nconst RULE_IPSEC_EC: RuleMeta = {\n  id: \"net-ipsec-ecp-ecdh\",\n  title: \"IPsec classical ECDH group (ecp)\",\n  description: \"IPsec/strongSwan IKE/ESP proposal names an elliptic-curve DH group (ecp*)\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"IPsec proposal uses a classical elliptic-curve Diffie-Hellman group (ecp*); the tunnel key exchange is harvest-now-decrypt-later exposed.\",\n  remediation:\n    \"Add a PQC/hybrid IKE proposal (X25519MLKEM768 / ML-KEM) as your IPsec stack supports it.\",\n};\n\n/** Detects classical key exchange in WireGuard / IPsec network config. */\nexport const vpnDetector: Detector = {\n  id: \"network-transport-crypto\",\n  description: \"Classical key exchange in network transport / VPN config (WireGuard, IPsec)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: [RULE_WG, RULE_IPSEC_DH, RULE_IPSEC_EC],\n  appliesTo: (f) => hasExtension(f, CONF_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const findings: Finding[] = [];\n    const push = (rule: RuleMeta, index: number, length: number) =>\n      findings.push(findingFromRule(rule, { file, content, index, matchLength: length }));\n    // ipsec.conf / wg configs use `#` line comments. Match over comment-masked\n    // content (offsets preserved); gates stay on the original.\n    const scan = maskCommentLines(content, [\"#\"]);\n\n    // WireGuard: gated to a WireGuard config section.\n    if (content.includes(\"[Interface]\") || content.includes(\"[Peer]\")) {\n      eachMatch(RE_WG_KEY, scan, (m) => push(RULE_WG, m.index, m[0].length));\n    }\n\n    // IPsec / strongSwan: gated to a proposal assignment.\n    if (/\\b(?:ike|esp|proposals?|keyexchange)\\s*=/i.test(content)) {\n      eachMatch(RE_IPSEC_MODP, scan, (m) => push(RULE_IPSEC_DH, m.index, m[0].length));\n      eachMatch(RE_IPSEC_ECP, scan, (m) => push(RULE_IPSEC_EC, m.index, m[0].length));\n    }\n    return findings;\n  },\n};\n"]}

package/dist/detectors/weak-hash.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Config/source detector: weak hash functions (SHA-1, MD5) used specifically in
+ * a DIGITAL-SIGNATURE or X.509 CERTIFICATE algorithm — NOT generic hashing and
+ * NOT password hashing.
+ *
+ * WHY THIS LIVES IN A PQC-READINESS TOOL (quantum-adjacent, not quantum-broken).
+ * SHA-1/MD5 are not "quantum-broken" — Grover only halves preimage strength and
+ * a CRQC does not conjure signature-hash collisions. We flag them anyway, and
+ * frame them as *quantum-adjacent: same migration window*:
+ *   - NIST SP 800-131A Rev 3 disallows SHA-1 for generating digital signatures
+ *     and retires SHA-1 entirely by 2030 — the SAME transition window the same
+ *     document sets for the classical→PQC migration. One standard, one deadline.
+ *   - CNSA 2.0 pairs its PQC mandate (ML-KEM / ML-DSA) with SHA-384/512; a
+ *     CNSA-2.0 target that re-keys to PQC must also drop SHA-1 from its
+ *     signature/certificate chain in the same effort.
+ *   - A quantum-readiness migration RE-KEYS and RE-SIGNS every certificate and
+ *     signature anyway. Surfacing weak signature hashes in that same pass costs
+ *     nothing extra and closes a today-exploitable gap (SHA-1/MD5 signature
+ *     forgery via chosen-prefix collisions) alongside the future one.
+ * We deliberately do NOT claim these hashes are broken by quantum computers.
+ *
+ * WHY THE SCOPE IS NARROW (signature/certificate ONLY).
+ * A bare `sha1(x)` or `sha1sum file` is often a perfectly acceptable
+ * non-security checksum (ETags, cache keys, content addressing, Git object ids).
+ * PASSWORD hashing with a weak/fast hash is a real weakness too, but it is a
+ * DIFFERENT weakness (CWE-916, needs a slow KDF like Argon2/bcrypt/scrypt), a
+ * different remediation, and — crucially — is NOT on the PQC migration path, so
+ * it does not belong in this detector. We only fire when the weak hash is bound
+ * to a signature/certificate algorithm, where "move to SHA-256+ while you re-key
+ * for PQC" is exactly the right, single remediation. That binding is enforced by
+ * a file-level fast-reject marker (see `hasSignatureMarker`) plus regexes that
+ * only match signature/cert *algorithm identifiers*, never a lone hash call.
+ *
+ * SURFACES COVERED (all verified signature/certificate contexts):
+ *  1. Java JCA standard names — `Signature.getInstance("SHA1withRSA")`,
+ *     `"MD5withRSA"`, `"SHA1withDSA"`, `"SHA1withECDSA"` (JDK Standard Algorithm
+ *     Names). Regex anchors on the `…with(RSA|DSA|ECDSA)` shape, so the token is
+ *     unambiguously a signature algorithm, never a bare digest.
+ *  2. .NET signing calls — a weak hash passed to `.SignData(…)` / `.SignHash(…)`
+ *     as `HashAlgorithmName.SHA1` or the legacy string `"SHA1"` (e.g.
+ *     `RSACryptoServiceProvider.SignData(data, "SHA1")`). Matched only INSIDE the
+ *     sign call, so an unrelated `HashAlgorithmName.SHA1` used for a checksum is
+ *     not flagged.
+ *  3. X.509 / ASN.1 signature-algorithm identifiers — the OID *names*
+ *     (`sha1WithRSAEncryption`, `md5WithRSAEncryption`, `ecdsa-with-SHA1`,
+ *     `dsaWithSHA1`) and their dotted OIDs (`1.2.840.113549.1.1.5` =
+ *     sha1WithRSAEncryption, `1.2.840.113549.1.1.4` = md5WithRSAEncryption,
+ *     `1.2.840.10045.4.1` = ecdsa-with-SHA1). These are certificate
+ *     signatureAlgorithm values by definition.
+ *  4. OpenSSL CLI in a signing/cert context — `-sha1` / `-md5` on the same line
+ *     as `openssl` AND a certificate/signing subcommand or flag
+ *     (`req` / `x509` / `ca` / `-sign` / `-signkey`). A bare `openssl dgst -sha1
+ *     file` (a checksum, no `-sign`) is intentionally NOT matched.
+ *
+ * NOT DUPLICATED: XML-DSig `rsa-sha1` (see `xmldsig.ts`) and DKIM `rsa-sha1`
+ * (see `dkim.ts`) already emit SIGNATURE findings on their own surfaces; this
+ * detector deliberately does not touch those and focuses on the Java / .NET /
+ * X.509 / OpenSSL surfaces above.
+ *
+ * Category is `hash` (weak/pre-quantum hash usage — the previously-unused
+ * category). `hndl: false` — a signature has no confidentiality to harvest.
+ * `algorithm: "unknown"` — the weak *hash* is not itself an asymmetric family;
+ * the signature it weakens is (RSA/ECDSA/DSA), but the finding is about the hash.
+ */
+import type { Detector } from "../types.js";
+/**
+ * Detects SHA-1 / MD5 used specifically in signature or certificate algorithms
+ * (Java JCA, .NET signing calls, X.509 OID names/OIDs, OpenSSL cert/signing CLI).
+ */
+export declare const weakHashDetector: Detector;
+//# sourceMappingURL=weak-hash.d.ts.map

package/dist/detectors/weak-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weak-hash.d.ts","sourceRoot":"","sources":["../../src/detectors/weak-hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAsH/D;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,QA8B9B,CAAC"}

package/dist/detectors/weak-hash.js

@@ -0,0 +1,116 @@
+import { DOC_EXTENSIONS, eachMatch, findingFromRule, hasExtension, maskBlockComments, maskCommentLines, } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+// --- SHA-1 in a signature/certificate algorithm identifier ---------------------
+// Java JCA standard names: `SHA1withRSA`, `SHA1withDSA`, `SHA1withECDSA`. The
+// `…with(RSA|DSA|ECDSA)` shape makes the token unambiguously a signature alg.
+// `-?` tolerates the `SHA-1` spelling; `i` covers case variation in real code.
+const RE_SHA1_JAVA = /\bSHA-?1with(?:RSA|DSA|ECDSA)\b/gi;
+// X.509 / ASN.1 signature-algorithm OID *names*.
+const RE_SHA1_X509 = /\b(?:sha-?1WithRSAEncryption|ecdsa-with-SHA-?1|dsaWithSHA-?1)\b/gi;
+// X.509 signature-algorithm dotted OIDs (sha1WithRSAEncryption, ecdsa-with-SHA1).
+// Lookarounds keep the id from matching inside a longer OID.
+const RE_SHA1_OID = /(?<![\d.])(?:1\.2\.840\.113549\.1\.1\.5|1\.2\.840\.10045\.4\.1)(?![\d.])/g;
+// OpenSSL CLI: `-sha1` on the same line as `openssl` AND an actual SIGNING marker
+// (`req` / `ca` subcommand, or `-sign`/`-signkey`/`-CA`/`-CAkey`), in either order.
+// A bare `x509` subcommand is NOT a signing marker — `openssl x509 -fingerprint
+// -sha1` / `-subject_hash` are read-only thumbprint/identifier ops, not signature
+// generation (audit M1). `openssl dgst -sha1 file` (checksum) is likewise unmatched.
+const OPENSSL_SIGN = String.raw `(?:\breq\b|\bca\b|-sign(?:key)?\b|-CA(?:key)?\b)`;
+const RE_SHA1_OPENSSL = new RegExp(`openssl\\b[^\\n]*?${OPENSSL_SIGN}[^\\n]*?-sha1\\b|openssl\\b[^\\n]*?-sha1\\b[^\\n]*?${OPENSSL_SIGN}`, "gi");
+// .NET: a weak hash bound to a signing call (`.SignData(…)` / `.SignHash(…)`), as
+// `HashAlgorithmName.SHA1` or the legacy `"SHA1"` string arg. Bounded by `;` (the
+// statement), NOT `)` — the first argument is often itself a call
+// (`.SignData(Encoding.UTF8.GetBytes(m), HashAlgorithmName.SHA1, …)`), so a
+// `[^)]` span would stop at the inner `)` and miss it (audit H3).
+const RE_SHA1_DOTNET = /\.Sign(?:Data|Hash)\s*\([^;]*?(?:HashAlgorithmName\.SHA-?1|["']SHA-?1["'])/gi;
+// --- MD5 in a signature/certificate algorithm identifier -----------------------
+const RE_MD5_JAVA = /\bMD5with(?:RSA|DSA|ECDSA)\b/gi;
+const RE_MD5_X509 = /\bmd5WithRSAEncryption\b/gi;
+const RE_MD5_OID = /(?<![\d.])1\.2\.840\.113549\.1\.1\.4(?![\d.])/g;
+const RE_MD5_OPENSSL = new RegExp(`openssl\\b[^\\n]*?${OPENSSL_SIGN}[^\\n]*?-md5\\b|openssl\\b[^\\n]*?-md5\\b[^\\n]*?${OPENSSL_SIGN}`, "gi");
+const RE_MD5_DOTNET = /\.Sign(?:Data|Hash)\s*\([^;]*?(?:HashAlgorithmName\.MD5|["']MD5["'])/gi;
+const RULE_SHA1 = {
+    id: "weak-hash-sha1-signature",
+    title: "SHA-1 in a signature / certificate algorithm",
+    description: "SHA-1 used in a digital-signature or X.509 certificate algorithm (Java/.NET/X.509/OpenSSL)",
+    category: "hash",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "SHA-1 used in a digital-signature/certificate algorithm; SHA-1 is disallowed for signatures (NIST SP 800-131A Rev 3, fully retired 2030 — the same window as the PQC migration) and enables collision-based signature forgery. Quantum-adjacent: migrate the hash alongside the signature algorithm.",
+    remediation: "Move signature/certificate hashes to SHA-256 or stronger (SHA-384/512 for CNSA 2.0 targets) and re-issue affected certificates; fold the PQC signature migration (ML-DSA) into the same re-key/re-sign effort.",
+};
+const RULE_MD5 = {
+    id: "weak-hash-md5-signature",
+    title: "MD5 in a signature / certificate algorithm",
+    description: "MD5 used in a digital-signature or X.509 certificate algorithm (Java/.NET/X.509/OpenSSL)",
+    category: "hash",
+    severity: "high",
+    confidence: "high",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "MD5 used in a digital-signature/certificate algorithm; MD5 signatures are catastrophically broken today (practical chosen-prefix collisions have forged CA certificates) and must be replaced immediately. Quantum-adjacent: migrate the hash alongside the signature algorithm in the PQC re-sign pass.",
+    remediation: "Replace MD5 signature/certificate hashes with SHA-256 or stronger (SHA-384/512 for CNSA 2.0 targets) and re-issue affected certificates immediately; fold the PQC signature migration (ML-DSA) into the same re-key/re-sign effort.",
+};
+const WEAK_HASH_RULES = [
+    {
+        meta: RULE_SHA1,
+        res: [RE_SHA1_JAVA, RE_SHA1_X509, RE_SHA1_OID, RE_SHA1_OPENSSL, RE_SHA1_DOTNET],
+    },
+    { meta: RULE_MD5, res: [RE_MD5_JAVA, RE_MD5_X509, RE_MD5_OID, RE_MD5_OPENSSL, RE_MD5_DOTNET] },
+];
+/**
+ * True when `content` carries a signature/certificate marker — a signal that any
+ * weak hash present is bound to a signature or cert, not a bare checksum. This is
+ * the guard that keeps `sha1(x)` / `sha1sum` / a password hash from ever firing:
+ * without one of these markers the file is not scanned at all.
+ */
+function hasSignatureMarker(content) {
+    if (/with\s?RSA|with\s?DSA|with\s?ECDSA|WithRSAEncryption|ecdsa-with-SHA-?1|dsaWithSHA-?1/i.test(content)) {
+        return true;
+    }
+    if (/1\.2\.840\.113549\.1\.1\.[45]|1\.2\.840\.10045\.4\.1/.test(content))
+        return true;
+    if (/Signature\.getInstance|\.Sign(?:Data|Hash)\s*\(/.test(content))
+        return true;
+    // OpenSSL only counts as a marker with a cert/signing subcommand or flag.
+    if (/openssl/i.test(content) && /\b(?:req|x509|ca|-signkey|-sign|dgst)\b/i.test(content)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Detects SHA-1 / MD5 used specifically in signature or certificate algorithms
+ * (Java JCA, .NET signing calls, X.509 OID names/OIDs, OpenSSL cert/signing CLI).
+ */
+export const weakHashDetector = {
+    id: "weak-hash-signature",
+    description: "Weak hash (SHA-1/MD5) in a digital-signature or X.509 certificate algorithm",
+    scope: "config",
+    language: "any",
+    rules: WEAK_HASH_RULES.map((r) => r.meta),
+    // Skip prose/docs: a page explaining `SHA1withRSA` is not live config/code.
+    appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS),
+    detect({ file, content }) {
+        // Fast reject on the ORIGINAL content: only scan files whose weak hash is
+        // bound to a signature/cert context. A lone `sha1(...)` checksum or a
+        // password hash has no such marker and is skipped wholesale.
+        if (!hasSignatureMarker(content))
+            return [];
+        // Mask C-style block comments and `//` / `#` / `;` line comments so a
+        // commented-out algorithm can't fire. Offsets are preserved, so finding
+        // line/column/snippet for the live lines stay exact.
+        const scan = maskCommentLines(maskBlockComments(content), ["//", "#", ";"]);
+        const findings = [];
+        for (const { meta, res } of WEAK_HASH_RULES) {
+            for (const re of res) {
+                eachMatch(re, scan, (m) => findings.push(findingFromRule(meta, { file, content, index: m.index, matchLength: m[0].length })));
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=weak-hash.js.map