@quantakrypto/core 0.4.1 → 0.4.3

package/dist/detectors/ruby.d.ts

@@ -1,13 +1,17 @@
 /**
  * Source-code detector for classical asymmetric cryptography in Ruby. Ruby's
  * asymmetric crypto is almost entirely `OpenSSL::PKey::{RSA,EC,DSA,DH}`, which
- * makes the signals precise. Lexical, same strategy as the other packs.
+ * makes the signals precise. Lexical, same strategy as the other packs. Beyond
+ * keygen it also covers RSA public-key encryption on a loaded key, DH key
+ * agreement, the type-agnostic `OpenSSL::PKey.read` loader, Ed25519 key
+ * generation, and disabled TLS peer verification (`VERIFY_NONE`).
  *
  * HNDL: RSA (keygen/encryption) and (EC)DH key agreement are harvest-now-
- * decrypt-later exposed (hndl:true); DSA signatures are hndl:false but forgeable.
- * `OpenSSL::PKey::EC` is ambiguous (feeds ECDSA + ECDH), so it is classified
- * conservatively as key-exchange-capable (hndl:true), like the other EC keygen
- * rules.
+ * decrypt-later exposed (hndl:true); DSA / Ed25519 signatures are hndl:false but
+ * forgeable. `OpenSSL::PKey::EC` is ambiguous (feeds ECDSA + ECDH), so it is
+ * classified conservatively as key-exchange-capable (hndl:true), like the other
+ * EC keygen rules; `OpenSSL::PKey.read` loads a key of unknown type and is
+ * likewise treated conservatively.
  */
 import type { Detector } from "../types.js";
 /** Detects classical asymmetric crypto in Ruby (OpenSSL::PKey). */

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

@@ -1 +1 @@
-{"version":3,"file":"ruby.d.ts","sourceRoot":"","sources":["../../src/detectors/ruby.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA+D/D,mEAAmE;AACnE,eAAO,MAAM,YAAY,EAAE,QAqB1B,CAAC"}
+{"version":3,"file":"ruby.d.ts","sourceRoot":"","sources":["../../src/detectors/ruby.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA2K/D,mEAAmE;AACnE,eAAO,MAAM,YAAY,EAAE,QAwC1B,CAAC"}

package/dist/detectors/ruby.js

@@ -1,9 +1,23 @@
 import { RUBY_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
-import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+import { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION } from "../cwe.js";
 const RE_RB_RSA = /\bOpenSSL::PKey::RSA\.(?:new|generate)\s*\(/g;
 const RE_RB_EC = /\bOpenSSL::PKey::EC\.(?:new|generate)\s*\(/g;
 const RE_RB_DSA = /\bOpenSSL::PKey::DSA\.(?:new|generate)\s*\(/g;
 const RE_RB_DH = /\bOpenSSL::PKey::DH\.new\s*\(/g;
+// RSA public-key encryption on an already-loaded key (audit F4-ruby / F9).
+const RE_RB_RSA_CRYPT = /\.public_encrypt\b|\.private_decrypt\b/g;
+// Finite-field DH shared-secret agreement.
+const RE_RB_DH_AGREE = /\bdh_compute_key\s*\(/g;
+// Type-agnostic key loader — could be RSA/EC/DSA/DH (conservative).
+const RE_RB_PKEY_READ = /\bOpenSSL::PKey\.read\s*\(/g;
+// Ed25519 signing key via the generic generate_key factory.
+const RE_RB_ED25519 = /\bOpenSSL::PKey\.generate_key\s*\(\s*["']ED25519["']/g;
+// `ed25519` gem — Ed25519::SigningKey / VerifyKey (signature keys).
+const RE_RB_ED25519_GEM = /\bEd25519::(?:SigningKey|VerifyKey)\b/g;
+// `rbnacl` (libsodium) — Curve25519/X25519 key agreement: PrivateKey, Box, GroupElement.
+const RE_RB_RBNACL = /\bRbNaCl::(?:PrivateKey|Box|GroupElement)\b/g;
+// TLS peer verification disabled (mirrors the JS tlsDetector rejectUnauthorized rule).
+const RE_RB_TLS_VERIFY_NONE = /\bOpenSSL::SSL::VERIFY_NONE\b/g;
 const RULE_RB_RSA = {
     id: "ruby-rsa",
     title: "Ruby RSA key/usage",
@@ -54,13 +68,112 @@ const RULE_RB_DH = {
     cwe: CWE_BROKEN_CRYPTO,
     message: "Finite-field Diffie-Hellman (Ruby/OpenSSL) is broken by Shor's algorithm (harvest-now-decrypt-later).",
 };
+const RULE_RB_RSA_CRYPT = {
+    id: "ruby-rsa-crypt",
+    title: "Ruby RSA public-key encryption",
+    description: "OpenSSL::PKey::RSA#public_encrypt / #private_decrypt",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "RSA public-key encryption/decryption (Ruby/OpenSSL) is harvest-now-decrypt-later exposed.",
+};
+const RULE_RB_DH_AGREE = {
+    id: "ruby-dh-agree",
+    title: "Ruby Diffie-Hellman key agreement",
+    description: "OpenSSL DH compute_key shared-secret agreement",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "DH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Finite-field Diffie-Hellman key agreement (Ruby/OpenSSL) is broken by Shor's algorithm (harvest-now-decrypt-later).",
+};
+const RULE_RB_PKEY_READ = {
+    id: "ruby-pkey-read",
+    title: "Ruby PKey loaded from serialized key",
+    description: "OpenSSL::PKey.read (type-agnostic key loader)",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "medium",
+    algorithm: "unknown",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Loads a classical asymmetric key of unknown type (RSA/EC/DSA/DH) via OpenSSL::PKey.read. Treated conservatively as key-exchange-capable (harvest-now-decrypt-later).",
+    remediation: "For key agreement: hybrid X25519MLKEM768 (ML-KEM-768). For signatures: ML-DSA-65 (FIPS 204).",
+};
+const RULE_RB_ED25519 = {
+    id: "ruby-ed25519",
+    title: "Ruby Ed25519 key generation",
+    description: 'OpenSSL::PKey.generate_key("ED25519")',
+    category: "signature",
+    severity: "low",
+    confidence: "high",
+    algorithm: "EdDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Generates an Ed25519 signing key (Ruby/OpenSSL) — modern but classical, and forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+};
+const RULE_RB_ED25519_GEM = {
+    id: "ruby-ed25519-gem",
+    title: "Ruby Ed25519 signature (ed25519 gem)",
+    description: "ed25519 gem Ed25519::SigningKey / Ed25519::VerifyKey",
+    category: "signature",
+    severity: "low",
+    confidence: "high",
+    algorithm: "EdDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Ed25519 signing/verification via the `ed25519` gem — modern but classical, and forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+};
+const RULE_RB_RBNACL = {
+    id: "ruby-rbnacl",
+    title: "Ruby X25519 key agreement (rbnacl)",
+    description: "rbnacl (libsodium) RbNaCl::PrivateKey / Box / GroupElement",
+    category: "key-exchange",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "X25519",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Curve25519/X25519 key agreement via the `rbnacl` gem (libsodium) — modern but classical key agreement, harvest-now-decrypt-later exposed.",
+};
+const RULE_RB_TLS_VERIFY_NONE = {
+    id: "ruby-tls-verify-none",
+    title: "Ruby TLS certificate verification disabled",
+    description: "OpenSSL::SSL::VERIFY_NONE",
+    category: "tls",
+    severity: "high",
+    confidence: "high",
+    hndl: false,
+    cwe: CWE_CERT_VALIDATION,
+    message: "OpenSSL::SSL::VERIFY_NONE disables TLS peer certificate verification (MITM risk).",
+    remediation: "Use OpenSSL::SSL::VERIFY_PEER and verify the certificate chain.",
+};
 /** Detects classical asymmetric crypto in Ruby (OpenSSL::PKey). */
 export const rubyDetector = {
     id: "ruby-crypto",
     description: "Classical asymmetric crypto in Ruby (OpenSSL::PKey::{RSA,EC,DSA,DH})",
     scope: "source",
     language: "ruby",
-    rules: [RULE_RB_RSA, RULE_RB_EC, RULE_RB_DSA, RULE_RB_DH],
+    rules: [
+        RULE_RB_RSA,
+        RULE_RB_EC,
+        RULE_RB_DSA,
+        RULE_RB_DH,
+        RULE_RB_RSA_CRYPT,
+        RULE_RB_DH_AGREE,
+        RULE_RB_PKEY_READ,
+        RULE_RB_ED25519,
+        RULE_RB_ED25519_GEM,
+        RULE_RB_RBNACL,
+        RULE_RB_TLS_VERIFY_NONE,
+    ],
     appliesTo: (f) => hasExtension(f, RUBY_EXTENSIONS),
     detect({ file, content }) {
         const findings = [];
@@ -69,6 +182,13 @@ export const rubyDetector = {
         add(RE_RB_EC, RULE_RB_EC);
         add(RE_RB_DSA, RULE_RB_DSA);
         add(RE_RB_DH, RULE_RB_DH);
+        add(RE_RB_RSA_CRYPT, RULE_RB_RSA_CRYPT);
+        add(RE_RB_DH_AGREE, RULE_RB_DH_AGREE);
+        add(RE_RB_PKEY_READ, RULE_RB_PKEY_READ);
+        add(RE_RB_ED25519, RULE_RB_ED25519);
+        add(RE_RB_ED25519_GEM, RULE_RB_ED25519_GEM);
+        add(RE_RB_RBNACL, RULE_RB_RBNACL);
+        add(RE_RB_TLS_VERIFY_NONE, RULE_RB_TLS_VERIFY_NONE);
         return findings;
     },
 };

package/dist/detectors/ruby.js.map

@@ -1 +1 @@
-{"version":3,"file":"ruby.js","sourceRoot":"","sources":["../../src/detectors/ruby.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ruby.js","sourceRoot":"","sources":["../../src/detectors/ruby.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Source-code detector for classical asymmetric cryptography in Ruby. Ruby's\n * asymmetric crypto is almost entirely `OpenSSL::PKey::{RSA,EC,DSA,DH}`, which\n * makes the signals precise. Lexical, same strategy as the other packs. Beyond\n * keygen it also covers RSA public-key encryption on a loaded key, DH key\n * agreement, the type-agnostic `OpenSSL::PKey.read` loader, Ed25519 key\n * generation, and disabled TLS peer verification (`VERIFY_NONE`).\n *\n * HNDL: RSA (keygen/encryption) and (EC)DH key agreement are harvest-now-\n * decrypt-later exposed (hndl:true); DSA / Ed25519 signatures are hndl:false but\n * forgeable. `OpenSSL::PKey::EC` is ambiguous (feeds ECDSA + ECDH), so it is\n * classified conservatively as key-exchange-capable (hndl:true), like the other\n * EC keygen rules; `OpenSSL::PKey.read` loads a key of unknown type and is\n * likewise treated conservatively.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport { RUBY_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION } from \"../cwe.js\";\n\nconst RE_RB_RSA = /\\bOpenSSL::PKey::RSA\\.(?:new|generate)\\s*\\(/g;\nconst RE_RB_EC = /\\bOpenSSL::PKey::EC\\.(?:new|generate)\\s*\\(/g;\nconst RE_RB_DSA = /\\bOpenSSL::PKey::DSA\\.(?:new|generate)\\s*\\(/g;\nconst RE_RB_DH = /\\bOpenSSL::PKey::DH\\.new\\s*\\(/g;\n// RSA public-key encryption on an already-loaded key (audit F4-ruby / F9).\nconst RE_RB_RSA_CRYPT = /\\.public_encrypt\\b|\\.private_decrypt\\b/g;\n// Finite-field DH shared-secret agreement.\nconst RE_RB_DH_AGREE = /\\bdh_compute_key\\s*\\(/g;\n// Type-agnostic key loader — could be RSA/EC/DSA/DH (conservative).\nconst RE_RB_PKEY_READ = /\\bOpenSSL::PKey\\.read\\s*\\(/g;\n// Ed25519 signing key via the generic generate_key factory.\nconst RE_RB_ED25519 = /\\bOpenSSL::PKey\\.generate_key\\s*\\(\\s*[\"']ED25519[\"']/g;\n// `ed25519` gem — Ed25519::SigningKey / VerifyKey (signature keys).\nconst RE_RB_ED25519_GEM = /\\bEd25519::(?:SigningKey|VerifyKey)\\b/g;\n// `rbnacl` (libsodium) — Curve25519/X25519 key agreement: PrivateKey, Box, GroupElement.\nconst RE_RB_RBNACL = /\\bRbNaCl::(?:PrivateKey|Box|GroupElement)\\b/g;\n// TLS peer verification disabled (mirrors the JS tlsDetector rejectUnauthorized rule).\nconst RE_RB_TLS_VERIFY_NONE = /\\bOpenSSL::SSL::VERIFY_NONE\\b/g;\n\nconst RULE_RB_RSA: RuleMeta = {\n  id: \"ruby-rsa\",\n  title: \"Ruby RSA key/usage\",\n  description: \"OpenSSL::PKey::RSA.new / .generate\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical RSA (Ruby/OpenSSL) is not quantum-safe and RSA encryption is HNDL-exposed.\",\n};\nconst RULE_RB_EC: RuleMeta = {\n  id: \"ruby-ec\",\n  title: \"Ruby EC key generation\",\n  description: \"OpenSSL::PKey::EC.new / .generate\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Generates a classical EC key pair (Ruby/OpenSSL). EC keys feed BOTH ECDSA signatures and ECDH key agreement; the ECDH path is harvest-now-decrypt-later exposed.\",\n  remediation:\n    \"For key agreement: hybrid X25519MLKEM768 (ML-KEM-768). For signatures: ML-DSA-65 (FIPS 204).\",\n};\nconst RULE_RB_DSA: RuleMeta = {\n  id: \"ruby-dsa\",\n  title: \"Ruby DSA key/signature\",\n  description: \"OpenSSL::PKey::DSA.new / .generate\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"DSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical DSA (Ruby/OpenSSL) is deprecated and forgeable by a quantum attacker.\",\n  remediation: \"Rotate off DSA and migrate to ML-DSA-65 (FIPS 204).\",\n};\nconst RULE_RB_DH: RuleMeta = {\n  id: \"ruby-dh\",\n  title: \"Ruby Diffie-Hellman key exchange\",\n  description: \"OpenSSL::PKey::DH.new\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"DH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Finite-field Diffie-Hellman (Ruby/OpenSSL) is broken by Shor's algorithm (harvest-now-decrypt-later).\",\n};\nconst RULE_RB_RSA_CRYPT: RuleMeta = {\n  id: \"ruby-rsa-crypt\",\n  title: \"Ruby RSA public-key encryption\",\n  description: \"OpenSSL::PKey::RSA#public_encrypt / #private_decrypt\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"RSA public-key encryption/decryption (Ruby/OpenSSL) is harvest-now-decrypt-later exposed.\",\n};\nconst RULE_RB_DH_AGREE: RuleMeta = {\n  id: \"ruby-dh-agree\",\n  title: \"Ruby Diffie-Hellman key agreement\",\n  description: \"OpenSSL DH compute_key shared-secret agreement\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"DH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Finite-field Diffie-Hellman key agreement (Ruby/OpenSSL) is broken by Shor's algorithm (harvest-now-decrypt-later).\",\n};\nconst RULE_RB_PKEY_READ: RuleMeta = {\n  id: \"ruby-pkey-read\",\n  title: \"Ruby PKey loaded from serialized key\",\n  description: \"OpenSSL::PKey.read (type-agnostic key loader)\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"medium\",\n  algorithm: \"unknown\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Loads a classical asymmetric key of unknown type (RSA/EC/DSA/DH) via OpenSSL::PKey.read. Treated conservatively as key-exchange-capable (harvest-now-decrypt-later).\",\n  remediation:\n    \"For key agreement: hybrid X25519MLKEM768 (ML-KEM-768). For signatures: ML-DSA-65 (FIPS 204).\",\n};\nconst RULE_RB_ED25519: RuleMeta = {\n  id: \"ruby-ed25519\",\n  title: \"Ruby Ed25519 key generation\",\n  description: 'OpenSSL::PKey.generate_key(\"ED25519\")',\n  category: \"signature\",\n  severity: \"low\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Generates an Ed25519 signing key (Ruby/OpenSSL) — modern but classical, and forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\",\n};\nconst RULE_RB_ED25519_GEM: RuleMeta = {\n  id: \"ruby-ed25519-gem\",\n  title: \"Ruby Ed25519 signature (ed25519 gem)\",\n  description: \"ed25519 gem Ed25519::SigningKey / Ed25519::VerifyKey\",\n  category: \"signature\",\n  severity: \"low\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Ed25519 signing/verification via the `ed25519` gem — modern but classical, and forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\",\n};\nconst RULE_RB_RBNACL: RuleMeta = {\n  id: \"ruby-rbnacl\",\n  title: \"Ruby X25519 key agreement (rbnacl)\",\n  description: \"rbnacl (libsodium) RbNaCl::PrivateKey / Box / GroupElement\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X25519\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Curve25519/X25519 key agreement via the `rbnacl` gem (libsodium) — modern but classical key agreement, harvest-now-decrypt-later exposed.\",\n};\nconst RULE_RB_TLS_VERIFY_NONE: RuleMeta = {\n  id: \"ruby-tls-verify-none\",\n  title: \"Ruby TLS certificate verification disabled\",\n  description: \"OpenSSL::SSL::VERIFY_NONE\",\n  category: \"tls\",\n  severity: \"high\",\n  confidence: \"high\",\n  hndl: false,\n  cwe: CWE_CERT_VALIDATION,\n  message: \"OpenSSL::SSL::VERIFY_NONE disables TLS peer certificate verification (MITM risk).\",\n  remediation: \"Use OpenSSL::SSL::VERIFY_PEER and verify the certificate chain.\",\n};\n\n/** Detects classical asymmetric crypto in Ruby (OpenSSL::PKey). */\nexport const rubyDetector: Detector = {\n  id: \"ruby-crypto\",\n  description: \"Classical asymmetric crypto in Ruby (OpenSSL::PKey::{RSA,EC,DSA,DH})\",\n  scope: \"source\",\n  language: \"ruby\",\n  rules: [\n    RULE_RB_RSA,\n    RULE_RB_EC,\n    RULE_RB_DSA,\n    RULE_RB_DH,\n    RULE_RB_RSA_CRYPT,\n    RULE_RB_DH_AGREE,\n    RULE_RB_PKEY_READ,\n    RULE_RB_ED25519,\n    RULE_RB_ED25519_GEM,\n    RULE_RB_RBNACL,\n    RULE_RB_TLS_VERIFY_NONE,\n  ],\n  appliesTo: (f) => hasExtension(f, RUBY_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const findings: Finding[] = [];\n    const add = (re: RegExp, rule: RuleMeta) =>\n      eachMatch(re, content, (m) =>\n        findings.push(\n          findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n        ),\n      );\n    add(RE_RB_RSA, RULE_RB_RSA);\n    add(RE_RB_EC, RULE_RB_EC);\n    add(RE_RB_DSA, RULE_RB_DSA);\n    add(RE_RB_DH, RULE_RB_DH);\n    add(RE_RB_RSA_CRYPT, RULE_RB_RSA_CRYPT);\n    add(RE_RB_DH_AGREE, RULE_RB_DH_AGREE);\n    add(RE_RB_PKEY_READ, RULE_RB_PKEY_READ);\n    add(RE_RB_ED25519, RULE_RB_ED25519);\n    add(RE_RB_ED25519_GEM, RULE_RB_ED25519_GEM);\n    add(RE_RB_RBNACL, RULE_RB_RBNACL);\n    add(RE_RB_TLS_VERIFY_NONE, RULE_RB_TLS_VERIFY_NONE);\n    return findings;\n  },\n};\n"]}

package/dist/detectors/rust.d.ts

@@ -1,11 +1,16 @@
 /**
  * Source-code detector for classical asymmetric cryptography in Rust. Covers the
  * common crypto crates: `rsa`, `ring`, the `*-dalek` family (ed25519/x25519),
- * and the RustCrypto elliptic-curve crates (`p256`/`p384`/`k256`). Lexical, same
- * strategy as the other packs; the `::` path syntax makes the signals precise.
+ * the RustCrypto elliptic-curve crates (`p256`/`p384`/`k256`), and the `openssl`
+ * crate bindings. Lexical, same strategy as the other packs; the `::` path
+ * syntax makes the signals precise.
  *
  * HNDL: RSA encryption and (EC/X)DH key agreement are harvest-now-decrypt-later
- * exposed (hndl:true); ECDSA / Ed25519 signatures are hndl:false but forgeable.
+ * exposed (hndl:true); ECDSA / DSA / Ed25519 signatures are hndl:false but
+ * forgeable. `openssl::EcKey` keygen is ambiguous (feeds ECDSA + ECDH),
+ * classified conservatively as key-exchange-capable (hndl:true). Also flags
+ * Rust TLS certificate-validation bypasses (reqwest / rustls) — not quantum but
+ * mirrors the JS tlsDetector's cert-validation category.
  */
 import type { Detector } from "../types.js";
 /** Detects classical asymmetric crypto in Rust (rsa, ring, dalek, p256/k256). */

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

@@ -1 +1 @@
-{"version":3,"file":"rust.d.ts","sourceRoot":"","sources":["../../src/detectors/rust.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA+E/D,iFAAiF;AACjF,eAAO,MAAM,YAAY,EAAE,QAsB1B,CAAC"}
+{"version":3,"file":"rust.d.ts","sourceRoot":"","sources":["../../src/detectors/rust.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAmB,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA+OhF,iFAAiF;AACjF,eAAO,MAAM,YAAY,EAAE,QA6D1B,CAAC"}

package/dist/detectors/rust.js

@@ -1,5 +1,5 @@
 import { RUST_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
-import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+import { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION } from "../cwe.js";
 // `rsa` crate + ring RsaKeyPair. `::` after the type marks an associated-fn call.
 const RE_RUST_RSA = /\b(?:RsaPrivateKey|RsaPublicKey|RsaKeyPair)::/g;
 // ECDSA: RustCrypto `p256::ecdsa::SigningKey` (contains `ecdsa::SigningKey`),
@@ -11,6 +11,31 @@ const RE_RUST_ECDH = /\becdh::EphemeralSecret\b|\bagreement::ECDH_P(?:256|384)\b
 const RE_RUST_ED25519 = /\bed25519_dalek::(?:SigningKey|Keypair|SecretKey)\b|\bEd25519KeyPair::/g;
 // X25519 key agreement (dalek).
 const RE_RUST_X25519 = /\bx25519_dalek::(?:EphemeralSecret|StaticSecret)\b/g;
+// openssl crate bindings — the `Type::generate(` / `Dh::` call forms, distinct
+// from the ring / RustCrypto path syntax above (audit F5/F9 false-negatives).
+const RE_RUST_OPENSSL_RSA = /\bRsa::generate\s*\(/g;
+const RE_RUST_OPENSSL_EC = /\bEcKey::generate\s*\(/g;
+const RE_RUST_OPENSSL_DSA = /\bDsa::generate\s*\(/g;
+const RE_RUST_OPENSSL_DH = /\bDh::/g;
+// ring X25519 agreement (the ECDH_P* forms are handled by RE_RUST_ECDH above).
+const RE_RUST_RING_X25519 = /\bagreement::X25519\b/g;
+// Bare (unqualified) constructors: a braced `use x25519_dalek::{EphemeralSecret}`
+// / `use ed25519_dalek::{SigningKey}` strips the `::` path prefix, defeating the
+// path-qualified rules above. The `(?<![:\w])` lookbehind keeps these from
+// double-matching the qualified forms (e.g. `p256::ecdsa::SigningKey::random`).
+const RE_RUST_BARE_X25519 = /(?<![:\w])EphemeralSecret::new\s*\(/g;
+const RE_RUST_BARE_SIGNINGKEY = /(?<![:\w])SigningKey::(?:generate|random)\s*\(/g;
+// jsonwebtoken crate `Algorithm` enum variants selecting a classical JWT signer:
+// RSASSA-PKCS1 (RS*), RSASSA-PSS (PS*), ECDSA (ES*), and Ed25519 (EdDSA). The
+// `\s*` between `Algorithm` and `::` catches the variant split across lines /
+// routed through a helper (audit token_policy false-negative); the required
+// suffix keeps it off unrelated `Algorithm::` uses (e.g. `HS256` HMAC, which is
+// symmetric and not quantum-vulnerable, or `Algorithm::new`).
+const RE_RUST_JWT_ALG = /\bAlgorithm\s*::(RS|PS|ES)(?:256|384|512)\b|\bAlgorithm\s*::EdDSA\b/g;
+// Rust TLS certificate-validation bypass: reqwest `danger_accept_invalid_certs`
+// and the rustls `.dangerous()` escape hatch. Mirrors the JS tlsDetector.
+const RE_RUST_TLS_ACCEPT_INVALID = /\bdanger_accept_invalid_certs\s*\(\s*true/g;
+const RE_RUST_TLS_DANGEROUS = /\.dangerous\s*\(\s*\)/g;
 const RULE_RUST_RSA = {
     id: "rust-rsa",
     title: "Rust RSA key/usage",
@@ -65,20 +90,161 @@ const RULE_RUST_X25519 = {
     title: "Rust X25519 key agreement",
     description: "x25519-dalek EphemeralSecret/StaticSecret",
     category: "key-exchange",
-    severity: "low",
+    severity: "medium",
     confidence: "high",
     algorithm: "X25519",
     hndl: true,
     cwe: CWE_BROKEN_CRYPTO,
     message: "X25519 (Rust) is modern but still classical key agreement — harvest-now-decrypt-later.",
 };
+const RULE_RUST_OPENSSL_RSA = {
+    id: "rust-openssl-rsa",
+    title: "Rust openssl RSA key generation",
+    description: "openssl crate Rsa::generate",
+    category: "kem",
+    severity: "high",
+    confidence: "high",
+    algorithm: "RSA",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Generates a classical RSA key pair via the Rust `openssl` crate — not quantum-safe and RSA encryption is HNDL-exposed.",
+};
+const RULE_RUST_OPENSSL_EC = {
+    id: "rust-openssl-ec",
+    title: "Rust openssl EC key generation",
+    description: "openssl crate EcKey::generate",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Generates a classical EC key pair via the Rust `openssl` crate. EC keys feed 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).",
+};
+const RULE_RUST_OPENSSL_DSA = {
+    id: "rust-openssl-dsa",
+    title: "Rust openssl DSA key/usage",
+    description: "openssl crate Dsa::generate",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "DSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Classical DSA via the Rust `openssl` crate is deprecated and forgeable by a quantum attacker.",
+    remediation: "Rotate off DSA and migrate to ML-DSA-65 (FIPS 204).",
+};
+const RULE_RUST_OPENSSL_DH = {
+    id: "rust-openssl-dh",
+    title: "Rust openssl Diffie-Hellman key exchange",
+    description: "openssl crate Dh params / key generation",
+    category: "key-exchange",
+    severity: "high",
+    confidence: "high",
+    algorithm: "DH",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Finite-field Diffie-Hellman via the Rust `openssl` crate is broken by Shor's algorithm (harvest-now-decrypt-later).",
+};
+const RULE_RUST_RING_X25519 = {
+    id: "rust-ring-x25519",
+    title: "Rust ring X25519 key agreement",
+    description: "ring agreement::X25519",
+    category: "key-exchange",
+    severity: "medium",
+    confidence: "high",
+    algorithm: "X25519",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "X25519 key agreement via ring (Rust) is modern but still classical — harvest-now-decrypt-later.",
+};
+const RULE_RUST_BARE_X25519 = {
+    id: "rust-x25519-bare",
+    title: "Rust X25519 key agreement (unqualified)",
+    description: "bare EphemeralSecret::new (x25519-dalek imported via `use`)",
+    category: "key-exchange",
+    severity: "medium",
+    confidence: "medium",
+    algorithm: "X25519",
+    hndl: true,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "X25519 key agreement (x25519-dalek, imported unqualified) is modern but still classical — harvest-now-decrypt-later.",
+};
+const RULE_RUST_BARE_SIGNINGKEY = {
+    id: "rust-signingkey-bare",
+    title: "Rust signature key (unqualified)",
+    description: "bare SigningKey::generate/random (ed25519-dalek / k256 via `use`)",
+    category: "signature",
+    severity: "medium",
+    confidence: "medium",
+    algorithm: "unknown",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Classical signature key from an unqualified `SigningKey` (ed25519-dalek Ed25519 / k256 ECDSA) — forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+};
+const RULE_RUST_JWT_ALGORITHM = {
+    id: "rust-jwt-algorithm",
+    title: "Rust jsonwebtoken classical signature algorithm",
+    description: "jsonwebtoken Algorithm::{RS,PS,ES}* / Algorithm::EdDSA enum variant",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    // Representative family; refined per-finding (RS*/PS* → RSA, ES* → ECDSA, EdDSA).
+    algorithm: "RSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "Selects a classical JWT signature algorithm (jsonwebtoken RS*/PS*/ES*/EdDSA), forgeable by a quantum attacker.",
+    remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+};
+const RULE_RUST_TLS_ACCEPT_INVALID = {
+    id: "rust-tls-accept-invalid-certs",
+    title: "Rust TLS certificate verification disabled",
+    description: "reqwest danger_accept_invalid_certs(true)",
+    category: "tls",
+    severity: "high",
+    confidence: "high",
+    hndl: false,
+    cwe: CWE_CERT_VALIDATION,
+    message: "danger_accept_invalid_certs(true) disables TLS certificate verification in reqwest (MITM risk).",
+    remediation: "Remove danger_accept_invalid_certs(true); verify certificates properly.",
+};
+const RULE_RUST_TLS_DANGEROUS = {
+    id: "rust-tls-rustls-dangerous",
+    title: "Rust rustls dangerous certificate config",
+    description: "rustls ClientConfig .dangerous() escape hatch",
+    category: "tls",
+    severity: "high",
+    confidence: "medium",
+    hndl: false,
+    cwe: CWE_CERT_VALIDATION,
+    message: "rustls `.dangerous()` opts into disabling certificate verification (MITM risk).",
+    remediation: "Avoid the dangerous() escape hatch; keep the default certificate verifier.",
+};
 /** Detects classical asymmetric crypto in Rust (rsa, ring, dalek, p256/k256). */
 export const rustDetector = {
     id: "rust-crypto",
     description: "Classical asymmetric crypto in Rust (rsa, ring, *-dalek, p256/k256)",
     scope: "source",
     language: "rust",
-    rules: [RULE_RUST_RSA, RULE_RUST_ECDSA, RULE_RUST_ECDH, RULE_RUST_ED25519, RULE_RUST_X25519],
+    rules: [
+        RULE_RUST_RSA,
+        RULE_RUST_ECDSA,
+        RULE_RUST_ECDH,
+        RULE_RUST_ED25519,
+        RULE_RUST_X25519,
+        RULE_RUST_OPENSSL_RSA,
+        RULE_RUST_OPENSSL_EC,
+        RULE_RUST_OPENSSL_DSA,
+        RULE_RUST_OPENSSL_DH,
+        RULE_RUST_RING_X25519,
+        RULE_RUST_BARE_X25519,
+        RULE_RUST_BARE_SIGNINGKEY,
+        RULE_RUST_JWT_ALGORITHM,
+        RULE_RUST_TLS_ACCEPT_INVALID,
+        RULE_RUST_TLS_DANGEROUS,
+    ],
     appliesTo: (f) => hasExtension(f, RUST_EXTENSIONS),
     detect({ file, content }) {
         const findings = [];
@@ -88,6 +254,22 @@ export const rustDetector = {
         add(RE_RUST_ECDH, RULE_RUST_ECDH);
         add(RE_RUST_ED25519, RULE_RUST_ED25519);
         add(RE_RUST_X25519, RULE_RUST_X25519);
+        add(RE_RUST_OPENSSL_RSA, RULE_RUST_OPENSSL_RSA);
+        add(RE_RUST_OPENSSL_EC, RULE_RUST_OPENSSL_EC);
+        add(RE_RUST_OPENSSL_DSA, RULE_RUST_OPENSSL_DSA);
+        add(RE_RUST_OPENSSL_DH, RULE_RUST_OPENSSL_DH);
+        add(RE_RUST_RING_X25519, RULE_RUST_RING_X25519);
+        add(RE_RUST_BARE_X25519, RULE_RUST_BARE_X25519);
+        add(RE_RUST_BARE_SIGNINGKEY, RULE_RUST_BARE_SIGNINGKEY);
+        // jsonwebtoken Algorithm enum variants — resolve the family per match: the
+        // RS*/PS* variants are RSASSA (RSA), ES* is ECDSA, EdDSA is Ed25519.
+        eachMatch(RE_RUST_JWT_ALG, content, (m) => {
+            const prefix = m[1];
+            const algorithm = prefix === undefined ? "EdDSA" : prefix === "ES" ? "ECDSA" : "RSA";
+            findings.push(findingFromRule(RULE_RUST_JWT_ALGORITHM, { file, content, index: m.index, matchLength: m[0].length }, { algorithm }));
+        });
+        add(RE_RUST_TLS_ACCEPT_INVALID, RULE_RUST_TLS_ACCEPT_INVALID);
+        add(RE_RUST_TLS_DANGEROUS, RULE_RUST_TLS_DANGEROUS);
         return findings;
     },
 };

package/dist/detectors/rust.js.map

@@ -1 +1 @@
-{"version":3,"file":"rust.js","sourceRoot":"","sources":["../../src/detectors/rust.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rust.js","sourceRoot":"","sources":["../../src/detectors/rust.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Source-code detector for classical asymmetric cryptography in Rust. Covers the\n * common crypto crates: `rsa`, `ring`, the `*-dalek` family (ed25519/x25519),\n * the RustCrypto elliptic-curve crates (`p256`/`p384`/`k256`), and the `openssl`\n * crate bindings. Lexical, same strategy as the other packs; the `::` path\n * syntax makes the signals precise.\n *\n * HNDL: RSA encryption and (EC/X)DH key agreement are harvest-now-decrypt-later\n * exposed (hndl:true); ECDSA / DSA / Ed25519 signatures are hndl:false but\n * forgeable. `openssl::EcKey` keygen is ambiguous (feeds ECDSA + ECDH),\n * classified conservatively as key-exchange-capable (hndl:true). Also flags\n * Rust TLS certificate-validation bypasses (reqwest / rustls) — not quantum but\n * mirrors the JS tlsDetector's cert-validation category.\n */\nimport type { AlgorithmFamily, Detector, Finding, RuleMeta } from \"../types.js\";\nimport { RUST_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION } from \"../cwe.js\";\n\n// `rsa` crate + ring RsaKeyPair. `::` after the type marks an associated-fn call.\nconst RE_RUST_RSA = /\\b(?:RsaPrivateKey|RsaPublicKey|RsaKeyPair)::/g;\n// ECDSA: RustCrypto `p256::ecdsa::SigningKey` (contains `ecdsa::SigningKey`),\n// ring `EcdsaKeyPair::`, or a bare `ecdsa::SigningKey`.\nconst RE_RUST_ECDSA = /\\becdsa::SigningKey\\b|\\bEcdsaKeyPair::/g;\n// ECDH: RustCrypto `p256::ecdh::EphemeralSecret`, ring agreement / ECDH_P*.\nconst RE_RUST_ECDH = /\\becdh::EphemeralSecret\\b|\\bagreement::ECDH_P(?:256|384)\\b/g;\n// Ed25519 signatures (dalek + ring).\nconst RE_RUST_ED25519 = /\\bed25519_dalek::(?:SigningKey|Keypair|SecretKey)\\b|\\bEd25519KeyPair::/g;\n// X25519 key agreement (dalek).\nconst RE_RUST_X25519 = /\\bx25519_dalek::(?:EphemeralSecret|StaticSecret)\\b/g;\n// openssl crate bindings — the `Type::generate(` / `Dh::` call forms, distinct\n// from the ring / RustCrypto path syntax above (audit F5/F9 false-negatives).\nconst RE_RUST_OPENSSL_RSA = /\\bRsa::generate\\s*\\(/g;\nconst RE_RUST_OPENSSL_EC = /\\bEcKey::generate\\s*\\(/g;\nconst RE_RUST_OPENSSL_DSA = /\\bDsa::generate\\s*\\(/g;\nconst RE_RUST_OPENSSL_DH = /\\bDh::/g;\n// ring X25519 agreement (the ECDH_P* forms are handled by RE_RUST_ECDH above).\nconst RE_RUST_RING_X25519 = /\\bagreement::X25519\\b/g;\n// Bare (unqualified) constructors: a braced `use x25519_dalek::{EphemeralSecret}`\n// / `use ed25519_dalek::{SigningKey}` strips the `::` path prefix, defeating the\n// path-qualified rules above. The `(?<![:\\w])` lookbehind keeps these from\n// double-matching the qualified forms (e.g. `p256::ecdsa::SigningKey::random`).\nconst RE_RUST_BARE_X25519 = /(?<![:\\w])EphemeralSecret::new\\s*\\(/g;\nconst RE_RUST_BARE_SIGNINGKEY = /(?<![:\\w])SigningKey::(?:generate|random)\\s*\\(/g;\n// jsonwebtoken crate `Algorithm` enum variants selecting a classical JWT signer:\n// RSASSA-PKCS1 (RS*), RSASSA-PSS (PS*), ECDSA (ES*), and Ed25519 (EdDSA). The\n// `\\s*` between `Algorithm` and `::` catches the variant split across lines /\n// routed through a helper (audit token_policy false-negative); the required\n// suffix keeps it off unrelated `Algorithm::` uses (e.g. `HS256` HMAC, which is\n// symmetric and not quantum-vulnerable, or `Algorithm::new`).\nconst RE_RUST_JWT_ALG = /\\bAlgorithm\\s*::(RS|PS|ES)(?:256|384|512)\\b|\\bAlgorithm\\s*::EdDSA\\b/g;\n// Rust TLS certificate-validation bypass: reqwest `danger_accept_invalid_certs`\n// and the rustls `.dangerous()` escape hatch. Mirrors the JS tlsDetector.\nconst RE_RUST_TLS_ACCEPT_INVALID = /\\bdanger_accept_invalid_certs\\s*\\(\\s*true/g;\nconst RE_RUST_TLS_DANGEROUS = /\\.dangerous\\s*\\(\\s*\\)/g;\n\nconst RULE_RUST_RSA: RuleMeta = {\n  id: \"rust-rsa\",\n  title: \"Rust RSA key/usage\",\n  description: \"the `rsa` crate / ring RsaKeyPair\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical RSA (Rust) is not quantum-safe and RSA encryption is HNDL-exposed.\",\n};\nconst RULE_RUST_ECDSA: RuleMeta = {\n  id: \"rust-ecdsa\",\n  title: \"Rust ECDSA signature\",\n  description: \"p256/p384/k256 ecdsa::SigningKey / ring EcdsaKeyPair\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Classical ECDSA signing (Rust) is forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\",\n};\nconst RULE_RUST_ECDH: RuleMeta = {\n  id: \"rust-ecdh\",\n  title: \"Rust ECDH key agreement\",\n  description: \"p256/p384 ecdh::EphemeralSecret / ring agreement\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Elliptic-curve Diffie-Hellman (Rust) is broken by Shor's algorithm (harvest-now-decrypt-later).\",\n};\nconst RULE_RUST_ED25519: RuleMeta = {\n  id: \"rust-ed25519\",\n  title: \"Rust Ed25519 signature\",\n  description: \"ed25519-dalek SigningKey/Keypair / ring Ed25519KeyPair\",\n  category: \"signature\",\n  severity: \"low\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"Ed25519 (Rust) is a modern but still classical signature scheme.\",\n};\nconst RULE_RUST_X25519: RuleMeta = {\n  id: \"rust-x25519\",\n  title: \"Rust X25519 key agreement\",\n  description: \"x25519-dalek EphemeralSecret/StaticSecret\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X25519\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"X25519 (Rust) is modern but still classical key agreement — harvest-now-decrypt-later.\",\n};\nconst RULE_RUST_OPENSSL_RSA: RuleMeta = {\n  id: \"rust-openssl-rsa\",\n  title: \"Rust openssl RSA key generation\",\n  description: \"openssl crate Rsa::generate\",\n  category: \"kem\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"RSA\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Generates a classical RSA key pair via the Rust `openssl` crate — not quantum-safe and RSA encryption is HNDL-exposed.\",\n};\nconst RULE_RUST_OPENSSL_EC: RuleMeta = {\n  id: \"rust-openssl-ec\",\n  title: \"Rust openssl EC key generation\",\n  description: \"openssl crate EcKey::generate\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Generates a classical EC key pair via the Rust `openssl` crate. EC keys feed BOTH ECDSA signatures and ECDH key agreement; the ECDH path is harvest-now-decrypt-later exposed.\",\n  remediation:\n    \"For key agreement: hybrid X25519MLKEM768 (ML-KEM-768). For signatures: ML-DSA-65 (FIPS 204).\",\n};\nconst RULE_RUST_OPENSSL_DSA: RuleMeta = {\n  id: \"rust-openssl-dsa\",\n  title: \"Rust openssl DSA key/usage\",\n  description: \"openssl crate Dsa::generate\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"DSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Classical DSA via the Rust `openssl` crate is deprecated and forgeable by a quantum attacker.\",\n  remediation: \"Rotate off DSA and migrate to ML-DSA-65 (FIPS 204).\",\n};\nconst RULE_RUST_OPENSSL_DH: RuleMeta = {\n  id: \"rust-openssl-dh\",\n  title: \"Rust openssl Diffie-Hellman key exchange\",\n  description: \"openssl crate Dh params / key generation\",\n  category: \"key-exchange\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"DH\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Finite-field Diffie-Hellman via the Rust `openssl` crate is broken by Shor's algorithm (harvest-now-decrypt-later).\",\n};\nconst RULE_RUST_RING_X25519: RuleMeta = {\n  id: \"rust-ring-x25519\",\n  title: \"Rust ring X25519 key agreement\",\n  description: \"ring agreement::X25519\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X25519\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"X25519 key agreement via ring (Rust) is modern but still classical — harvest-now-decrypt-later.\",\n};\nconst RULE_RUST_BARE_X25519: RuleMeta = {\n  id: \"rust-x25519-bare\",\n  title: \"Rust X25519 key agreement (unqualified)\",\n  description: \"bare EphemeralSecret::new (x25519-dalek imported via `use`)\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"medium\",\n  algorithm: \"X25519\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"X25519 key agreement (x25519-dalek, imported unqualified) is modern but still classical — harvest-now-decrypt-later.\",\n};\nconst RULE_RUST_BARE_SIGNINGKEY: RuleMeta = {\n  id: \"rust-signingkey-bare\",\n  title: \"Rust signature key (unqualified)\",\n  description: \"bare SigningKey::generate/random (ed25519-dalek / k256 via `use`)\",\n  category: \"signature\",\n  severity: \"medium\",\n  confidence: \"medium\",\n  algorithm: \"unknown\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Classical signature key from an unqualified `SigningKey` (ed25519-dalek Ed25519 / k256 ECDSA) — forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\",\n};\nconst RULE_RUST_JWT_ALGORITHM: RuleMeta = {\n  id: \"rust-jwt-algorithm\",\n  title: \"Rust jsonwebtoken classical signature algorithm\",\n  description: \"jsonwebtoken Algorithm::{RS,PS,ES}* / Algorithm::EdDSA enum variant\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  // Representative family; refined per-finding (RS*/PS* → RSA, ES* → ECDSA, EdDSA).\n  algorithm: \"RSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"Selects a classical JWT signature algorithm (jsonwebtoken RS*/PS*/ES*/EdDSA), forgeable by a quantum attacker.\",\n  remediation: \"ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)\",\n};\nconst RULE_RUST_TLS_ACCEPT_INVALID: RuleMeta = {\n  id: \"rust-tls-accept-invalid-certs\",\n  title: \"Rust TLS certificate verification disabled\",\n  description: \"reqwest danger_accept_invalid_certs(true)\",\n  category: \"tls\",\n  severity: \"high\",\n  confidence: \"high\",\n  hndl: false,\n  cwe: CWE_CERT_VALIDATION,\n  message:\n    \"danger_accept_invalid_certs(true) disables TLS certificate verification in reqwest (MITM risk).\",\n  remediation: \"Remove danger_accept_invalid_certs(true); verify certificates properly.\",\n};\nconst RULE_RUST_TLS_DANGEROUS: RuleMeta = {\n  id: \"rust-tls-rustls-dangerous\",\n  title: \"Rust rustls dangerous certificate config\",\n  description: \"rustls ClientConfig .dangerous() escape hatch\",\n  category: \"tls\",\n  severity: \"high\",\n  confidence: \"medium\",\n  hndl: false,\n  cwe: CWE_CERT_VALIDATION,\n  message: \"rustls `.dangerous()` opts into disabling certificate verification (MITM risk).\",\n  remediation: \"Avoid the dangerous() escape hatch; keep the default certificate verifier.\",\n};\n\n/** Detects classical asymmetric crypto in Rust (rsa, ring, dalek, p256/k256). */\nexport const rustDetector: Detector = {\n  id: \"rust-crypto\",\n  description: \"Classical asymmetric crypto in Rust (rsa, ring, *-dalek, p256/k256)\",\n  scope: \"source\",\n  language: \"rust\",\n  rules: [\n    RULE_RUST_RSA,\n    RULE_RUST_ECDSA,\n    RULE_RUST_ECDH,\n    RULE_RUST_ED25519,\n    RULE_RUST_X25519,\n    RULE_RUST_OPENSSL_RSA,\n    RULE_RUST_OPENSSL_EC,\n    RULE_RUST_OPENSSL_DSA,\n    RULE_RUST_OPENSSL_DH,\n    RULE_RUST_RING_X25519,\n    RULE_RUST_BARE_X25519,\n    RULE_RUST_BARE_SIGNINGKEY,\n    RULE_RUST_JWT_ALGORITHM,\n    RULE_RUST_TLS_ACCEPT_INVALID,\n    RULE_RUST_TLS_DANGEROUS,\n  ],\n  appliesTo: (f) => hasExtension(f, RUST_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    const findings: Finding[] = [];\n    const add = (re: RegExp, rule: RuleMeta) =>\n      eachMatch(re, content, (m) =>\n        findings.push(\n          findingFromRule(rule, { file, content, index: m.index, matchLength: m[0].length }),\n        ),\n      );\n    add(RE_RUST_RSA, RULE_RUST_RSA);\n    add(RE_RUST_ECDSA, RULE_RUST_ECDSA);\n    add(RE_RUST_ECDH, RULE_RUST_ECDH);\n    add(RE_RUST_ED25519, RULE_RUST_ED25519);\n    add(RE_RUST_X25519, RULE_RUST_X25519);\n    add(RE_RUST_OPENSSL_RSA, RULE_RUST_OPENSSL_RSA);\n    add(RE_RUST_OPENSSL_EC, RULE_RUST_OPENSSL_EC);\n    add(RE_RUST_OPENSSL_DSA, RULE_RUST_OPENSSL_DSA);\n    add(RE_RUST_OPENSSL_DH, RULE_RUST_OPENSSL_DH);\n    add(RE_RUST_RING_X25519, RULE_RUST_RING_X25519);\n    add(RE_RUST_BARE_X25519, RULE_RUST_BARE_X25519);\n    add(RE_RUST_BARE_SIGNINGKEY, RULE_RUST_BARE_SIGNINGKEY);\n    // jsonwebtoken Algorithm enum variants — resolve the family per match: the\n    // RS*/PS* variants are RSASSA (RSA), ES* is ECDSA, EdDSA is Ed25519.\n    eachMatch(RE_RUST_JWT_ALG, content, (m) => {\n      const prefix = m[1];\n      const algorithm: AlgorithmFamily =\n        prefix === undefined ? \"EdDSA\" : prefix === \"ES\" ? \"ECDSA\" : \"RSA\";\n      findings.push(\n        findingFromRule(\n          RULE_RUST_JWT_ALGORITHM,\n          { file, content, index: m.index, matchLength: m[0].length },\n          { algorithm },\n        ),\n      );\n    });\n    add(RE_RUST_TLS_ACCEPT_INVALID, RULE_RUST_TLS_ACCEPT_INVALID);\n    add(RE_RUST_TLS_DANGEROUS, RULE_RUST_TLS_DANGEROUS);\n    return findings;\n  },\n};\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/detectors/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAs2B/D,0DAA0D;AAC1D,eAAO,MAAM,eAAe,EAAE,QAAQ,EAOrC,CAAC"}
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/detectors/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AA4/B/D,0DAA0D;AAC1D,eAAO,MAAM,eAAe,EAAE,QAAQ,EAQrC,CAAC"}