@quantakrypto/core 0.4.3 → 0.5.0

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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","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"]}
+{"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// X448 key agreement (`x448` crate). The qualified `x448::Secret` path — covers the\n// plain `use x448::Secret;` / fully-qualified form the alias mechanism (which only\n// fires on a RENAMED `use … as`) misses.\nconst RE_RUST_X448 = /\\bx448::Secret\\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_X448: RuleMeta = {\n  id: \"rust-x448\",\n  title: \"Rust X448 key agreement\",\n  description: \"the `x448` crate Secret key agreement\",\n  category: \"key-exchange\",\n  severity: \"medium\",\n  confidence: \"high\",\n  algorithm: \"X448\",\n  hndl: true,\n  cwe: CWE_BROKEN_CRYPTO,\n  message: \"X448 (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/**\n * Aliasable Rust crypto types (`<crate>::<OrigType>` → rule). A renamed `use`\n * (`use x25519_dalek::{EphemeralSecret as MontgomerySecret}`) binds the alias to a\n * classical-key type; a later `MontgomerySecret::<ctor>(` is that key's\n * construction. The `::`-qualified and braced rules above miss this because the\n * call site uses the renamed identifier, not the original path.\n */\nconst RUST_ALIASABLE: Record<string, RuleMeta> = {\n  \"x25519_dalek::EphemeralSecret\": RULE_RUST_X25519,\n  \"x25519_dalek::StaticSecret\": RULE_RUST_X25519,\n  \"x448::Secret\": RULE_RUST_X448,\n  \"ed25519_dalek::SigningKey\": RULE_RUST_ED25519,\n  \"ed25519_dalek::Keypair\": RULE_RUST_ED25519,\n  \"ed25519_dalek::SecretKey\": RULE_RUST_ED25519,\n};\n\n/** Escape a string for interpolation into a dynamically-built RegExp. */\nfunction escapeRustRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Collect `use <crate>::<OrigType> as <Alias>` bindings (braced or single) that\n * rename an aliasable crypto type, returning {alias, rule} pairs. An alias equal\n * to its own type name is skipped (the qualified/bare rules already catch it).\n */\nfunction collectRustTypeAliases(content: string): Array<{ alias: string; rule: RuleMeta }> {\n  const out: Array<{ alias: string; rule: RuleMeta }> = [];\n  const push = (crate: string, orig: string, alias: string): void => {\n    if (!alias || alias === orig) return;\n    const rule = RUST_ALIASABLE[`${crate}::${orig}`];\n    if (rule) out.push({ alias, rule });\n  };\n  // Braced: `use <crate>::{ Orig as Alias, ... }`.\n  const braced = /\\buse\\s+([\\w:]+)::\\{([^}]*)\\}/g;\n  for (let m = braced.exec(content); m; m = braced.exec(content)) {\n    const specRe = /([A-Za-z_]\\w*)\\s+as\\s+([A-Za-z_]\\w*)/g;\n    for (let s = specRe.exec(m[2]); s; s = specRe.exec(m[2])) push(m[1], s[1], s[2]);\n  }\n  // Single: `use <crate>::Orig as Alias;`.\n  const single = /\\buse\\s+([\\w:]+)::([A-Za-z_]\\w*)\\s+as\\s+([A-Za-z_]\\w*)/g;\n  for (let m = single.exec(content); m; m = single.exec(content)) push(m[1], m[2], m[3]);\n  return out;\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_X448,\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_X448, RULE_RUST_X448);\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\n    // Type-alias resolution: `use x25519_dalek::{EphemeralSecret as MontgomerySecret}`\n    // then `MontgomerySecret::random_from_rng(` — the braced+renamed `use` defeats\n    // the `::`-qualified rules. Match the aliased type's construction calls; runs\n    // on the ORIGINAL content so locations stay exact, and fires only for an alias\n    // explicitly bound to a known crypto type (precision-safe).\n    for (const { alias, rule } of collectRustTypeAliases(content)) {\n      const a = escapeRustRe(alias);\n      add(\n        new RegExp(`\\\\b${a}::(?:new|random|random_from_rng|generate|from_bytes)\\\\s*\\\\(`, \"g\"),\n        rule,\n      );\n    }\n    return findings;\n  },\n};\n"]}

package/dist/detectors/secrets.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Config detector: secrets encrypted at rest with classical asymmetric key
+ * wrapping. This is the purest "harvest now, decrypt later" surface — the
+ * ciphertext is often committed to a git repository, which means it is already
+ * replicated, effectively immortal, and retroactively un-fixable (you can
+ * re-encrypt HEAD, not history). Every recipient key here is classical.
+ *
+ * Covered:
+ *  - Mozilla SOPS / age recipients: `age1…` bech32 public keys (X25519 key
+ *    agreement wrapping the data key).
+ *  - Bitnami Sealed Secrets: `kind: SealedSecret` (controller wraps with RSA-OAEP).
+ *
+ * Armored PGP blocks (`-----BEGIN PGP MESSAGE-----` and PGP private keys) are owned
+ * by the PEM detector (`pem-pgp-message` / `pem-pgp-private-key`), so they are not
+ * duplicated here.
+ *
+ * Symmetric-only schemes (ansible-vault AES, age with a scrypt passphrase) are
+ * intentionally NOT flagged: a strong symmetric key is only Grover-weakened, not
+ * broken, so it is out of scope for a *classical-asymmetric* readiness signal.
+ */
+import type { Detector } from "../types.js";
+/** Detects secrets encrypted at rest with classical asymmetric key wrapping. */
+export declare const secretsDetector: Detector;
+//# sourceMappingURL=secrets.d.ts.map

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

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

package/dist/detectors/secrets.js

@@ -0,0 +1,63 @@
+import { DOC_EXTENSIONS, eachMatch, findingFromRule, hasExtension, maskCommentLines, } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+const SECRET_RULES = [
+    {
+        // age/SOPS recipient: `age1` + 58 bech32 chars. Distinctive enough for any file.
+        re: /\bage1[0-9a-z]{58}\b/g,
+        meta: {
+            id: "secrets-age-recipient",
+            title: "age / SOPS recipient (X25519)",
+            description: "An age (SOPS) recipient public key wraps secrets with classical X25519",
+            category: "key-exchange",
+            severity: "high",
+            confidence: "high",
+            algorithm: "X25519",
+            hndl: true,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: "Secrets are wrapped to an age/SOPS X25519 recipient (classical key agreement); harvest-now-decrypt-later exposed, and if committed to git the ciphertext is retroactively un-fixable.",
+            remediation: "Track a post-quantum age recipient / KMS (ML-KEM) and re-encrypt; rotate any secret whose ciphertext has left your control.",
+        },
+    },
+    {
+        re: /\bkind:\s*["']?SealedSecret\b/g,
+        meta: {
+            id: "secrets-sealed-secret",
+            title: "Bitnami Sealed Secret (RSA-OAEP)",
+            description: "A SealedSecret is wrapped by the controller's classical RSA-OAEP key",
+            category: "kem",
+            severity: "high",
+            confidence: "high",
+            algorithm: "RSA",
+            hndl: true,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: "A Bitnami SealedSecret is wrapped with the controller's classical RSA-OAEP key; harvest-now-decrypt-later exposed, and typically committed to git.",
+            remediation: "Plan migration as sealed-secrets adds PQC support; rotate the sealing key and secrets when it does.",
+        },
+    },
+];
+/** Detects secrets encrypted at rest with classical asymmetric key wrapping. */
+export const secretsDetector = {
+    id: "secrets-at-rest",
+    description: "Secrets wrapped at rest with classical asymmetric crypto (SOPS/age, PGP, Sealed Secrets)",
+    scope: "config",
+    language: "any",
+    rules: SECRET_RULES.map((r) => r.meta),
+    // Skip prose/docs: a tutorial showing an example age recipient is not a secret store.
+    appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS),
+    detect({ file, content }) {
+        // Fast reject: none of the distinctive markers present.
+        if (!content.includes("age1") && !content.includes("SealedSecret")) {
+            return [];
+        }
+        // A commented `# kind: SealedSecret` / `# age1…` is not an active setting.
+        const scan = maskCommentLines(content, ["#"]);
+        const findings = [];
+        for (const rule of SECRET_RULES) {
+            eachMatch(rule.re, scan, (m) => {
+                findings.push(findingFromRule(rule.meta, { file, content, index: m.index, matchLength: m[0].length }));
+            });
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=secrets.js.map

package/dist/detectors/secrets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.js","sourceRoot":"","sources":["../../src/detectors/secrets.ts"],"names":[],"mappings":"AAqBA,OAAO,EACL,cAAc,EACd,SAAS,EACT,eAAe,EACf,YAAY,EACZ,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAO9C,MAAM,YAAY,GAAiB;IACjC;QACE,iFAAiF;QACjF,EAAE,EAAE,uBAAuB;QAC3B,IAAI,EAAE;YACJ,EAAE,EAAE,uBAAuB;YAC3B,KAAK,EAAE,+BAA+B;YACtC,WAAW,EAAE,wEAAwE;YACrF,QAAQ,EAAE,cAAc;YACxB,QAAQ,EAAE,MAAM;YAChB,UAAU,EAAE,MAAM;YAClB,SAAS,EAAE,QAAQ;YACnB,IAAI,EAAE,IAAI;YACV,GAAG,EAAE,iBAAiB;YACtB,OAAO,EACL,uLAAuL;YACzL,WAAW,EACT,6HAA6H;SAChI;KACF;IACD;QACE,EAAE,EAAE,gCAAgC;QACpC,IAAI,EAAE;YACJ,EAAE,EAAE,uBAAuB;YAC3B,KAAK,EAAE,kCAAkC;YACzC,WAAW,EAAE,sEAAsE;YACnF,QAAQ,EAAE,KAAK;YACf,QAAQ,EAAE,MAAM;YAChB,UAAU,EAAE,MAAM;YAClB,SAAS,EAAE,KAAK;YAChB,IAAI,EAAE,IAAI;YACV,GAAG,EAAE,iBAAiB;YACtB,OAAO,EACL,oJAAoJ;YACtJ,WAAW,EACT,qGAAqG;SACxG;KACF;CACF,CAAC;AAEF,gFAAgF;AAChF,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,EAAE,EAAE,iBAAiB;IACrB,WAAW,EACT,0FAA0F;IAC5F,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE,KAAK;IACf,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACtC,sFAAsF;IACtF,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc,CAAC;IAClD,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;QACtB,wDAAwD;QACxD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YACnE,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,2EAA2E;QAC3E,MAAM,IAAI,GAAG,gBAAgB,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC9C,MAAM,QAAQ,GAAc,EAAE,CAAC;QAC/B,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;YAChC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE;gBAC7B,QAAQ,CAAC,IAAI,CACX,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CACxF,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC","sourcesContent":["/**\n * Config detector: secrets encrypted at rest with classical asymmetric key\n * wrapping. This is the purest \"harvest now, decrypt later\" surface — the\n * ciphertext is often committed to a git repository, which means it is already\n * replicated, effectively immortal, and retroactively un-fixable (you can\n * re-encrypt HEAD, not history). Every recipient key here is classical.\n *\n * Covered:\n *  - Mozilla SOPS / age recipients: `age1…` bech32 public keys (X25519 key\n *    agreement wrapping the data key).\n *  - Bitnami Sealed Secrets: `kind: SealedSecret` (controller wraps with RSA-OAEP).\n *\n * Armored PGP blocks (`-----BEGIN PGP MESSAGE-----` and PGP private keys) are owned\n * by the PEM detector (`pem-pgp-message` / `pem-pgp-private-key`), so they are not\n * duplicated here.\n *\n * Symmetric-only schemes (ansible-vault AES, age with a scrypt passphrase) are\n * intentionally NOT flagged: a strong symmetric key is only Grover-weakened, not\n * broken, so it is out of scope for a *classical-asymmetric* readiness signal.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport {\n  DOC_EXTENSIONS,\n  eachMatch,\n  findingFromRule,\n  hasExtension,\n  maskCommentLines,\n} from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO } from \"../cwe.js\";\n\ninterface SecretRule {\n  re: RegExp;\n  meta: RuleMeta;\n}\n\nconst SECRET_RULES: SecretRule[] = [\n  {\n    // age/SOPS recipient: `age1` + 58 bech32 chars. Distinctive enough for any file.\n    re: /\\bage1[0-9a-z]{58}\\b/g,\n    meta: {\n      id: \"secrets-age-recipient\",\n      title: \"age / SOPS recipient (X25519)\",\n      description: \"An age (SOPS) recipient public key wraps secrets with classical X25519\",\n      category: \"key-exchange\",\n      severity: \"high\",\n      confidence: \"high\",\n      algorithm: \"X25519\",\n      hndl: true,\n      cwe: CWE_BROKEN_CRYPTO,\n      message:\n        \"Secrets are wrapped to an age/SOPS X25519 recipient (classical key agreement); harvest-now-decrypt-later exposed, and if committed to git the ciphertext is retroactively un-fixable.\",\n      remediation:\n        \"Track a post-quantum age recipient / KMS (ML-KEM) and re-encrypt; rotate any secret whose ciphertext has left your control.\",\n    },\n  },\n  {\n    re: /\\bkind:\\s*[\"']?SealedSecret\\b/g,\n    meta: {\n      id: \"secrets-sealed-secret\",\n      title: \"Bitnami Sealed Secret (RSA-OAEP)\",\n      description: \"A SealedSecret is wrapped by the controller's classical RSA-OAEP key\",\n      category: \"kem\",\n      severity: \"high\",\n      confidence: \"high\",\n      algorithm: \"RSA\",\n      hndl: true,\n      cwe: CWE_BROKEN_CRYPTO,\n      message:\n        \"A Bitnami SealedSecret is wrapped with the controller's classical RSA-OAEP key; harvest-now-decrypt-later exposed, and typically committed to git.\",\n      remediation:\n        \"Plan migration as sealed-secrets adds PQC support; rotate the sealing key and secrets when it does.\",\n    },\n  },\n];\n\n/** Detects secrets encrypted at rest with classical asymmetric key wrapping. */\nexport const secretsDetector: Detector = {\n  id: \"secrets-at-rest\",\n  description:\n    \"Secrets wrapped at rest with classical asymmetric crypto (SOPS/age, PGP, Sealed Secrets)\",\n  scope: \"config\",\n  language: \"any\",\n  rules: SECRET_RULES.map((r) => r.meta),\n  // Skip prose/docs: a tutorial showing an example age recipient is not a secret store.\n  appliesTo: (f) => !hasExtension(f, DOC_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    // Fast reject: none of the distinctive markers present.\n    if (!content.includes(\"age1\") && !content.includes(\"SealedSecret\")) {\n      return [];\n    }\n    // A commented `# kind: SealedSecret` / `# age1…` is not an active setting.\n    const scan = maskCommentLines(content, [\"#\"]);\n    const findings: Finding[] = [];\n    for (const rule of SECRET_RULES) {\n      eachMatch(rule.re, scan, (m) => {\n        findings.push(\n          findingFromRule(rule.meta, { file, content, index: m.index, matchLength: m[0].length }),\n        );\n      });\n    }\n    return findings;\n  },\n};\n"]}

package/dist/detectors/solidity.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Source detector for classical asymmetric cryptography in smart-contract /
+ * blockchain source languages: Solidity (`.sol`), Move (`.move`), and Cairo
+ * (`.cairo`). On-chain signature verification is pure classical elliptic-curve
+ * cryptography — secp256k1 ECDSA on the EVM, Ed25519 / secp256k1 on Sui & Aptos
+ * (Move), and STARK-curve ECDSA on Starknet (Cairo). A cryptographically-relevant
+ * quantum computer (CRQC) could forge any of these on-chain authorizations.
+ *
+ * HNDL: unlike a KEM or key-agreement finding, an on-chain signature check has no
+ * confidentiality to harvest — there is nothing to decrypt later — so every rule
+ * here is `hndl: false`. The exposure is nonetheless SEVERE: on-chain keys often
+ * ARE the custody of the asset (an account's authorization to move funds), so a
+ * forged signature is a direct loss, not a downgraded confidentiality guarantee.
+ * That is why the findings are `severity: high` despite `hndl: false`.
+ *
+ * There is no `secp256k1` value in {@link AlgorithmFamily}; secp256k1 usage is
+ * mapped to `ECDSA` (the scheme), and the specific curve is named in the message.
+ * The STARK-curve check is likewise `ECDSA` (ECDSA over the STARK-friendly curve).
+ *
+ * Patterns (verified against OpenZeppelin, Solady, Sui/Aptos Move, Starknet docs):
+ *  - Solidity / EVM (secp256k1 ECDSA → `sol-ecrecover`):
+ *      `ecrecover(` (the secp256k1 precompile), OpenZeppelin/Solady
+ *      `ECDSA.recover(` / `ECDSA.tryRecover(`,
+ *      `SignatureChecker.isValidSignatureNow(`, and imports of the
+ *      `.../cryptography/ECDSA.sol` / `SignatureChecker.sol` (OZ) or Solady
+ *      `utils/ECDSA.sol` libraries. Consolidated under one rule; each distinct
+ *      token/import is its own finding (evidence), but they cannot double-fire on
+ *      the same span.
+ *  - Move / Sui & Aptos:
+ *      `ed25519::signature_verify_strict(` / `ed25519_verify(` → EdDSA
+ *      (`sol-ed25519`); `ecdsa_k1::secp256k1_verify(` /
+ *      `ecdsa_k1::secp256k1_ecrecover(` → ECDSA secp256k1
+ *      (`sol-secp256k1-verify`).
+ *  - Cairo / Starknet:
+ *      `check_ecdsa_signature(` (also the `ecdsa::check_ecdsa_signature(`
+ *      qualified form) → ECDSA over the STARK curve (`cairo-ecdsa`).
+ *
+ * Comment suppression is done in-detector (Solidity/Move/Cairo all use C-style
+ * `//` line comments and `/* … *\/` block comments), so a commented-out
+ * verification call cannot fire. Offsets are preserved by the maskers, so finding
+ * line/column stay exact.
+ */
+import type { Detector } from "../types.js";
+/**
+ * Detects classical (quantum-vulnerable) on-chain signature verification in
+ * smart-contract source: Solidity/EVM secp256k1 ECDSA, Move Ed25519 & secp256k1,
+ * and Cairo/Starknet STARK-curve ECDSA.
+ */
+export declare const solidityDetector: Detector;
+//# sourceMappingURL=solidity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solidity.d.ts","sourceRoot":"","sources":["../../src/detectors/solidity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,aAAa,CAAC;AAqG/D;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,QA2B9B,CAAC"}

package/dist/detectors/solidity.js

@@ -0,0 +1,108 @@
+import { eachMatch, findingFromRule, hasExtension, maskBlockComments, maskCommentLines, SMART_CONTRACT_EXTENSIONS, } from "../detect-utils.js";
+import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+// Shared remediation: no PQC on-chain signature scheme is standardized on these
+// chains yet, so the actionable step today is to inventory the exposure and track
+// each chain's roadmap for an alternative (quantum-safe) signature scheme.
+const REMEDIATION_ONCHAIN = "No PQC on-chain signature scheme is standardized on these chains yet; inventory this on-chain " +
+    "signature verification now and track chain roadmaps (e.g. account abstraction enabling " +
+    "alternative signature schemes) for a quantum-safe migration path.";
+// --- Solidity / EVM: secp256k1 ECDSA. ---
+// The secp256k1 recovery precompile. `\b` before `ecrecover` keeps it off the
+// Move `secp256k1_ecrecover` token (preceded by `_`, a word char → no boundary).
+const RE_SOL_ECRECOVER = /\becrecover\s*\(/g;
+// OpenZeppelin / Solady library calls: `ECDSA.recover(` / `ECDSA.tryRecover(`
+// and `SignatureChecker.isValidSignatureNow(`.
+const RE_SOL_ECDSA_LIB = /\bECDSA\.(?:recover|tryRecover)\s*\(|\bSignatureChecker\.isValidSignatureNow\s*\(/g;
+// Import of the classical-signature libraries: OZ `.../cryptography/ECDSA.sol` /
+// `.../cryptography/SignatureChecker.sol`, and Solady `.../utils/ECDSA.sol`.
+const RE_SOL_ECDSA_IMPORT = /(?:cryptography|utils)\/(?:ECDSA|SignatureChecker)\.sol\b/g;
+// --- Move / Sui & Aptos. ---
+// Ed25519 verification: Aptos `ed25519::signature_verify_strict(`, Sui
+// `ed25519::ed25519_verify(` (matched via the bare `ed25519_verify(` token).
+const RE_MOVE_ED25519 = /\bed25519::signature_verify_strict\s*\(|\bed25519_verify\s*\(/g;
+// secp256k1 ECDSA verification / recovery via the Sui `ecdsa_k1` module.
+const RE_MOVE_SECP256K1 = /\becdsa_k1::secp256k1_(?:verify|ecrecover)\s*\(/g;
+// --- Cairo / Starknet: STARK-curve ECDSA. ---
+// `check_ecdsa_signature(` — also matches the qualified `ecdsa::check_ecdsa_signature(`
+// (the preceding `:` is a non-word char, so the `\b` boundary still holds).
+const RE_CAIRO_ECDSA = /\bcheck_ecdsa_signature\s*\(/g;
+const RULE_SOL_ECRECOVER = {
+    id: "sol-ecrecover",
+    title: "EVM on-chain ECDSA signature verification (secp256k1)",
+    description: "Solidity ecrecover / OpenZeppelin-Solady ECDSA.recover / SignatureChecker (secp256k1)",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "On-chain ECDSA over secp256k1 (Solidity/EVM: ecrecover, OpenZeppelin/Solady ECDSA / SignatureChecker) is forgeable by a quantum attacker; on-chain keys often ARE asset custody.",
+    remediation: REMEDIATION_ONCHAIN,
+};
+const RULE_MOVE_ED25519 = {
+    id: "sol-ed25519",
+    title: "Move on-chain Ed25519 signature verification",
+    description: "Move (Sui/Aptos) ed25519::signature_verify_strict / ed25519_verify",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "EdDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "On-chain Ed25519 signature verification (Move / Sui / Aptos) is classical and forgeable by a quantum attacker; on-chain keys often ARE asset custody.",
+    remediation: REMEDIATION_ONCHAIN,
+};
+const RULE_MOVE_SECP256K1 = {
+    id: "sol-secp256k1-verify",
+    title: "Move on-chain ECDSA signature verification (secp256k1)",
+    description: "Move (Sui) ecdsa_k1::secp256k1_verify / secp256k1_ecrecover",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "On-chain ECDSA over secp256k1 (Move / Sui ecdsa_k1) is forgeable by a quantum attacker; on-chain keys often ARE asset custody.",
+    remediation: REMEDIATION_ONCHAIN,
+};
+const RULE_CAIRO_ECDSA = {
+    id: "cairo-ecdsa",
+    title: "Cairo/Starknet on-chain ECDSA signature verification (STARK curve)",
+    description: "Cairo check_ecdsa_signature (STARK-curve ECDSA)",
+    category: "signature",
+    severity: "high",
+    confidence: "high",
+    algorithm: "ECDSA",
+    hndl: false,
+    cwe: CWE_BROKEN_CRYPTO,
+    message: "On-chain ECDSA over the STARK curve (Cairo/Starknet check_ecdsa_signature) is forgeable by a quantum attacker; on-chain keys often ARE asset custody.",
+    remediation: REMEDIATION_ONCHAIN,
+};
+/**
+ * Detects classical (quantum-vulnerable) on-chain signature verification in
+ * smart-contract source: Solidity/EVM secp256k1 ECDSA, Move Ed25519 & secp256k1,
+ * and Cairo/Starknet STARK-curve ECDSA.
+ */
+export const solidityDetector = {
+    id: "solidity-crypto",
+    description: "Classical on-chain signature verification in smart-contract source (Solidity, Move, Cairo)",
+    scope: "source",
+    language: "solidity",
+    rules: [RULE_SOL_ECRECOVER, RULE_MOVE_ED25519, RULE_MOVE_SECP256K1, RULE_CAIRO_ECDSA],
+    appliesTo: (f) => hasExtension(f, SMART_CONTRACT_EXTENSIONS),
+    detect({ file, content }) {
+        // Mask C-style comments (line `//` + block `/* */`) so commented-out
+        // verification calls can't fire; the maskers preserve byte offsets.
+        const scan = maskCommentLines(maskBlockComments(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_SOL_ECRECOVER, RULE_SOL_ECRECOVER);
+        add(RE_SOL_ECDSA_LIB, RULE_SOL_ECRECOVER);
+        add(RE_SOL_ECDSA_IMPORT, RULE_SOL_ECRECOVER);
+        add(RE_MOVE_ED25519, RULE_MOVE_ED25519);
+        add(RE_MOVE_SECP256K1, RULE_MOVE_SECP256K1);
+        add(RE_CAIRO_ECDSA, RULE_CAIRO_ECDSA);
+        return findings;
+    },
+};
+//# sourceMappingURL=solidity.js.map

package/dist/detectors/solidity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solidity.js","sourceRoot":"","sources":["../../src/detectors/solidity.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Source detector for classical asymmetric cryptography in smart-contract /\n * blockchain source languages: Solidity (`.sol`), Move (`.move`), and Cairo\n * (`.cairo`). On-chain signature verification is pure classical elliptic-curve\n * cryptography — secp256k1 ECDSA on the EVM, Ed25519 / secp256k1 on Sui & Aptos\n * (Move), and STARK-curve ECDSA on Starknet (Cairo). A cryptographically-relevant\n * quantum computer (CRQC) could forge any of these on-chain authorizations.\n *\n * HNDL: unlike a KEM or key-agreement finding, an on-chain signature check has no\n * confidentiality to harvest — there is nothing to decrypt later — so every rule\n * here is `hndl: false`. The exposure is nonetheless SEVERE: on-chain keys often\n * ARE the custody of the asset (an account's authorization to move funds), so a\n * forged signature is a direct loss, not a downgraded confidentiality guarantee.\n * That is why the findings are `severity: high` despite `hndl: false`.\n *\n * There is no `secp256k1` value in {@link AlgorithmFamily}; secp256k1 usage is\n * mapped to `ECDSA` (the scheme), and the specific curve is named in the message.\n * The STARK-curve check is likewise `ECDSA` (ECDSA over the STARK-friendly curve).\n *\n * Patterns (verified against OpenZeppelin, Solady, Sui/Aptos Move, Starknet docs):\n *  - Solidity / EVM (secp256k1 ECDSA → `sol-ecrecover`):\n *      `ecrecover(` (the secp256k1 precompile), OpenZeppelin/Solady\n *      `ECDSA.recover(` / `ECDSA.tryRecover(`,\n *      `SignatureChecker.isValidSignatureNow(`, and imports of the\n *      `.../cryptography/ECDSA.sol` / `SignatureChecker.sol` (OZ) or Solady\n *      `utils/ECDSA.sol` libraries. Consolidated under one rule; each distinct\n *      token/import is its own finding (evidence), but they cannot double-fire on\n *      the same span.\n *  - Move / Sui & Aptos:\n *      `ed25519::signature_verify_strict(` / `ed25519_verify(` → EdDSA\n *      (`sol-ed25519`); `ecdsa_k1::secp256k1_verify(` /\n *      `ecdsa_k1::secp256k1_ecrecover(` → ECDSA secp256k1\n *      (`sol-secp256k1-verify`).\n *  - Cairo / Starknet:\n *      `check_ecdsa_signature(` (also the `ecdsa::check_ecdsa_signature(`\n *      qualified form) → ECDSA over the STARK curve (`cairo-ecdsa`).\n *\n * Comment suppression is done in-detector (Solidity/Move/Cairo all use C-style\n * `//` line comments and `/* … *\\/` block comments), so a commented-out\n * verification call cannot fire. Offsets are preserved by the maskers, so finding\n * line/column stay exact.\n */\nimport type { Detector, Finding, RuleMeta } from \"../types.js\";\nimport {\n  eachMatch,\n  findingFromRule,\n  hasExtension,\n  maskBlockComments,\n  maskCommentLines,\n  SMART_CONTRACT_EXTENSIONS,\n} from \"../detect-utils.js\";\nimport { CWE_BROKEN_CRYPTO } from \"../cwe.js\";\n\n// Shared remediation: no PQC on-chain signature scheme is standardized on these\n// chains yet, so the actionable step today is to inventory the exposure and track\n// each chain's roadmap for an alternative (quantum-safe) signature scheme.\nconst REMEDIATION_ONCHAIN =\n  \"No PQC on-chain signature scheme is standardized on these chains yet; inventory this on-chain \" +\n  \"signature verification now and track chain roadmaps (e.g. account abstraction enabling \" +\n  \"alternative signature schemes) for a quantum-safe migration path.\";\n\n// --- Solidity / EVM: secp256k1 ECDSA. ---\n// The secp256k1 recovery precompile. `\\b` before `ecrecover` keeps it off the\n// Move `secp256k1_ecrecover` token (preceded by `_`, a word char → no boundary).\nconst RE_SOL_ECRECOVER = /\\becrecover\\s*\\(/g;\n// OpenZeppelin / Solady library calls: `ECDSA.recover(` / `ECDSA.tryRecover(`\n// and `SignatureChecker.isValidSignatureNow(`.\nconst RE_SOL_ECDSA_LIB =\n  /\\bECDSA\\.(?:recover|tryRecover)\\s*\\(|\\bSignatureChecker\\.isValidSignatureNow\\s*\\(/g;\n// Import of the classical-signature libraries: OZ `.../cryptography/ECDSA.sol` /\n// `.../cryptography/SignatureChecker.sol`, and Solady `.../utils/ECDSA.sol`.\nconst RE_SOL_ECDSA_IMPORT = /(?:cryptography|utils)\\/(?:ECDSA|SignatureChecker)\\.sol\\b/g;\n\n// --- Move / Sui & Aptos. ---\n// Ed25519 verification: Aptos `ed25519::signature_verify_strict(`, Sui\n// `ed25519::ed25519_verify(` (matched via the bare `ed25519_verify(` token).\nconst RE_MOVE_ED25519 = /\\bed25519::signature_verify_strict\\s*\\(|\\bed25519_verify\\s*\\(/g;\n// secp256k1 ECDSA verification / recovery via the Sui `ecdsa_k1` module.\nconst RE_MOVE_SECP256K1 = /\\becdsa_k1::secp256k1_(?:verify|ecrecover)\\s*\\(/g;\n\n// --- Cairo / Starknet: STARK-curve ECDSA. ---\n// `check_ecdsa_signature(` — also matches the qualified `ecdsa::check_ecdsa_signature(`\n// (the preceding `:` is a non-word char, so the `\\b` boundary still holds).\nconst RE_CAIRO_ECDSA = /\\bcheck_ecdsa_signature\\s*\\(/g;\n\nconst RULE_SOL_ECRECOVER: RuleMeta = {\n  id: \"sol-ecrecover\",\n  title: \"EVM on-chain ECDSA signature verification (secp256k1)\",\n  description:\n    \"Solidity ecrecover / OpenZeppelin-Solady ECDSA.recover / SignatureChecker (secp256k1)\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"On-chain ECDSA over secp256k1 (Solidity/EVM: ecrecover, OpenZeppelin/Solady ECDSA / SignatureChecker) is forgeable by a quantum attacker; on-chain keys often ARE asset custody.\",\n  remediation: REMEDIATION_ONCHAIN,\n};\nconst RULE_MOVE_ED25519: RuleMeta = {\n  id: \"sol-ed25519\",\n  title: \"Move on-chain Ed25519 signature verification\",\n  description: \"Move (Sui/Aptos) ed25519::signature_verify_strict / ed25519_verify\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"EdDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"On-chain Ed25519 signature verification (Move / Sui / Aptos) is classical and forgeable by a quantum attacker; on-chain keys often ARE asset custody.\",\n  remediation: REMEDIATION_ONCHAIN,\n};\nconst RULE_MOVE_SECP256K1: RuleMeta = {\n  id: \"sol-secp256k1-verify\",\n  title: \"Move on-chain ECDSA signature verification (secp256k1)\",\n  description: \"Move (Sui) ecdsa_k1::secp256k1_verify / secp256k1_ecrecover\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"On-chain ECDSA over secp256k1 (Move / Sui ecdsa_k1) is forgeable by a quantum attacker; on-chain keys often ARE asset custody.\",\n  remediation: REMEDIATION_ONCHAIN,\n};\nconst RULE_CAIRO_ECDSA: RuleMeta = {\n  id: \"cairo-ecdsa\",\n  title: \"Cairo/Starknet on-chain ECDSA signature verification (STARK curve)\",\n  description: \"Cairo check_ecdsa_signature (STARK-curve ECDSA)\",\n  category: \"signature\",\n  severity: \"high\",\n  confidence: \"high\",\n  algorithm: \"ECDSA\",\n  hndl: false,\n  cwe: CWE_BROKEN_CRYPTO,\n  message:\n    \"On-chain ECDSA over the STARK curve (Cairo/Starknet check_ecdsa_signature) is forgeable by a quantum attacker; on-chain keys often ARE asset custody.\",\n  remediation: REMEDIATION_ONCHAIN,\n};\n\n/**\n * Detects classical (quantum-vulnerable) on-chain signature verification in\n * smart-contract source: Solidity/EVM secp256k1 ECDSA, Move Ed25519 & secp256k1,\n * and Cairo/Starknet STARK-curve ECDSA.\n */\nexport const solidityDetector: Detector = {\n  id: \"solidity-crypto\",\n  description:\n    \"Classical on-chain signature verification in smart-contract source (Solidity, Move, Cairo)\",\n  scope: \"source\",\n  language: \"solidity\",\n  rules: [RULE_SOL_ECRECOVER, RULE_MOVE_ED25519, RULE_MOVE_SECP256K1, RULE_CAIRO_ECDSA],\n  appliesTo: (f) => hasExtension(f, SMART_CONTRACT_EXTENSIONS),\n  detect({ file, content }): Finding[] {\n    // Mask C-style comments (line `//` + block `/* */`) so commented-out\n    // verification calls can't fire; the maskers preserve byte offsets.\n    const scan = maskCommentLines(maskBlockComments(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_SOL_ECRECOVER, RULE_SOL_ECRECOVER);\n    add(RE_SOL_ECDSA_LIB, RULE_SOL_ECRECOVER);\n    add(RE_SOL_ECDSA_IMPORT, RULE_SOL_ECRECOVER);\n    add(RE_MOVE_ED25519, RULE_MOVE_ED25519);\n    add(RE_MOVE_SECP256K1, RULE_MOVE_SECP256K1);\n    add(RE_CAIRO_ECDSA, RULE_CAIRO_ECDSA);\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;AA4/B/D,0DAA0D;AAC1D,eAAO,MAAM,eAAe,EAAE,QAAQ,EAQrC,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;AA8sC/D,0DAA0D;AAC1D,eAAO,MAAM,eAAe,EAAE,QAAQ,EAQrC,CAAC"}