@quantakrypto/core 0.4.1 → 0.4.3

package/src/dependencies.ts

@@ -1,9 +1,10 @@
 /**
  * Curated database of packages that primarily expose classical asymmetric
  * cryptography (and are therefore quantum-vulnerable), across multiple
- * ecosystems (npm, PyPI, crates.io, Go modules, Maven, RubyGems), plus a
+ * ecosystems (npm, PyPI, crates.io, Go modules, Maven, RubyGems, NuGet), plus a
  * manifest scanner that flags any of them found in the corresponding manifest
- * (package.json, requirements.txt, Cargo.toml, go.mod, pom.xml, Gemfile, …).
+ * (package.json, requirements.txt, Cargo.toml, go.mod, pom.xml, Gemfile,
+ * packages.config / *.csproj, …).
  *
  * The list is intentionally focused on libraries whose *purpose* is classical
  * public-key crypto. General-purpose packages that merely call the language's
@@ -101,6 +102,7 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     reason: "JWTs commonly signed with RS256/ES256 (classical RSA/ECDSA).",
     algorithms: ["RSA", "ECDSA"],
     severity: "high",
+    hndl: false,
   },
   {
     name: "jose",
@@ -115,6 +117,7 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     reason: "JSON Web Signatures using classical RS/ES algorithms.",
     algorithms: ["RSA", "ECDSA"],
     severity: "high",
+    hndl: false,
   },
   {
     name: "eccrypto",
@@ -171,6 +174,7 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     reason: "PASETO public tokens signed with classical Ed25519 (v2/v4) or RSA.",
     algorithms: ["EdDSA", "RSA"],
     severity: "medium",
+    hndl: false,
   },
   {
     name: "bcrypto",
@@ -241,6 +245,7 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     reason: "JSON Web Algorithms: RSA (RS/PS) and EC (ES) signatures.",
     algorithms: ["RSA", "ECDSA"],
     severity: "medium",
+    hndl: false,
   },
   {
     name: "jwk-to-pem",
@@ -255,6 +260,7 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     reason: "JWT signing/verification with classical RS/PS/ES algorithms.",
     algorithms: ["RSA", "ECDSA"],
     severity: "medium",
+    hndl: false,
   },
   {
     name: "ssh2",
@@ -283,6 +289,7 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     reason: "HTTP request signing with classical RSA/ECDSA keys.",
     algorithms: ["RSA", "ECDSA"],
     severity: "medium",
+    hndl: false,
   },
   {
     name: "libsodium-wrappers",
@@ -307,6 +314,28 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     algorithms: ["RSA", "ECDSA", "DSA"],
     severity: "high",
   },
+  {
+    name: "pycrypto",
+    ecosystem: "pypi",
+    reason: "Abandoned/unmaintained crypto library — classical RSA/DSA/ElGamal.",
+    algorithms: ["RSA", "DSA"],
+    severity: "high",
+  },
+  {
+    name: "jwcrypto",
+    ecosystem: "pypi",
+    reason: "JWK / JWS / JWE with classical RS*/ES* and ECDH-ES key agreement.",
+    algorithms: ["RSA", "ECDSA", "ECDH"],
+    severity: "medium",
+  },
+  {
+    name: "authlib",
+    ecosystem: "pypi",
+    reason: "OAuth / OIDC / JOSE stack using classical RS*/ES* JWT signing.",
+    algorithms: ["RSA", "ECDSA"],
+    severity: "medium",
+    hndl: false,
+  },
   {
     name: "pycryptodomex",
     ecosystem: "pypi",
@@ -341,6 +370,7 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     reason: "JWT signing with classical RS*/ES* algorithms.",
     algorithms: ["RSA", "ECDSA"],
     severity: "medium",
+    hndl: false,
   },
   {
     name: "python-jose",
@@ -415,6 +445,13 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     algorithms: ["ECDSA", "ECDH"],
     severity: "high",
   },
+  {
+    name: "secp256k1",
+    ecosystem: "cargo",
+    reason: "libsecp256k1 bindings (blockchain) — classical ECDSA + ECDH.",
+    algorithms: ["ECDSA", "ECDH"],
+    severity: "high",
+  },
   {
     name: "ed25519-dalek",
     ecosystem: "cargo",
@@ -438,6 +475,43 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     algorithms: ["RSA", "ECDSA", "EdDSA", "ECDH"],
     severity: "medium",
   },
+  {
+    name: "github.com/golang-jwt/jwt/v5",
+    ecosystem: "go",
+    reason: "golang-jwt — classical RS*/PS*/ES* JWT algorithms.",
+    algorithms: ["RSA", "ECDSA"],
+    severity: "medium",
+    hndl: false,
+  },
+  {
+    name: "github.com/golang-jwt/jwt/v4",
+    ecosystem: "go",
+    reason: "golang-jwt (v4) — classical RS*/PS*/ES* JWT algorithms.",
+    algorithms: ["RSA", "ECDSA"],
+    severity: "medium",
+    hndl: false,
+  },
+  {
+    name: "github.com/go-jose/go-jose/v4",
+    ecosystem: "go",
+    reason: "go-jose — classical JOSE (RSA/ECDSA signatures, ECDH-ES key agreement).",
+    algorithms: ["RSA", "ECDSA", "ECDH"],
+    severity: "medium",
+  },
+  {
+    name: "github.com/cloudflare/circl",
+    ecosystem: "go",
+    reason: "Cloudflare CIRCL — classical ECDH/EdDSA curves (X25519, X448, Ed25519, P-256).",
+    algorithms: ["ECDH", "EdDSA"],
+    severity: "medium",
+  },
+  {
+    name: "github.com/decred/dcrd/dcrec/secp256k1/v4",
+    ecosystem: "go",
+    reason: "decred secp256k1 — classical ECDSA/ECDH on the secp256k1 curve (blockchain keys).",
+    algorithms: ["ECDSA", "ECDH"],
+    severity: "medium",
+  },
 
   // --- Maven (Java) ---
   {
@@ -467,6 +541,22 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     reason: "Auth0 JWT with classical RS*/ES* algorithms.",
     algorithms: ["RSA", "ECDSA"],
     severity: "medium",
+    hndl: false,
+  },
+  {
+    name: "nimbus-jose-jwt",
+    ecosystem: "maven",
+    reason: "Nimbus JOSE+JWT — classical RS*/PS*/ES* JWS and RSA/ECDH-ES JWE.",
+    algorithms: ["RSA", "ECDSA", "ECDH"],
+    severity: "medium",
+  },
+  {
+    name: "jjwt-api",
+    ecosystem: "maven",
+    reason: "JJWT (io.jsonwebtoken) — classical RS*/ES* JWT signing.",
+    algorithms: ["RSA", "ECDSA"],
+    severity: "medium",
+    hndl: false,
   },
 
   // --- RubyGems ---
@@ -476,6 +566,15 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     reason: "Ruby JWT with classical RS*/ES* algorithms.",
     algorithms: ["RSA", "ECDSA"],
     severity: "medium",
+    hndl: false,
+  },
+  {
+    name: "net-ssh",
+    ecosystem: "rubygems",
+    reason:
+      "Ruby SSH client — classical host/user keys (RSA/ECDSA/Ed25519) and ECDH/DH key exchange.",
+    algorithms: ["RSA", "ECDSA", "ECDH"],
+    severity: "medium",
   },
   {
     name: "rbnacl",
@@ -491,13 +590,46 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     algorithms: ["EdDSA"],
     severity: "low",
   },
+
+  // --- NuGet (.NET) ---
+  {
+    name: "BouncyCastle.Cryptography",
+    ecosystem: "nuget",
+    reason: "BouncyCastle for .NET — full classical RSA/ECDSA/ECDH/DSA suite.",
+    algorithms: ["RSA", "ECDSA", "ECDH", "DSA"],
+    severity: "high",
+  },
+  {
+    name: "Portable.BouncyCastle",
+    ecosystem: "nuget",
+    reason: "Portable BouncyCastle for .NET — classical RSA/ECDSA/ECDH/DSA.",
+    algorithms: ["RSA", "ECDSA", "ECDH", "DSA"],
+    severity: "high",
+  },
+  {
+    name: "System.IdentityModel.Tokens.Jwt",
+    ecosystem: "nuget",
+    reason: "Microsoft JWT handler — classical RS*/ES* (RSA/ECDSA) signatures.",
+    algorithms: ["RSA", "ECDSA"],
+    severity: "medium",
+    hndl: false,
+  },
+  {
+    name: "Microsoft.IdentityModel.Tokens",
+    ecosystem: "nuget",
+    reason: "Microsoft IdentityModel token crypto — classical RSA/ECDSA keys.",
+    algorithms: ["RSA", "ECDSA"],
+    severity: "medium",
+    hndl: false,
+  },
 ];
 
 /**
  * Normalise a package name for matching within its ecosystem. PyPI is
  * case-insensitive and folds runs of `-_.` to a single `-` (PEP 503); cargo /
- * maven / rubygems are effectively lower-case; npm and go module paths are
- * matched verbatim (npm scopes and go paths are case-sensitive).
+ * maven / rubygems / nuget are effectively lower-case (NuGet ids are matched
+ * case-insensitively); npm and go module paths are matched verbatim (npm scopes
+ * and go paths are case-sensitive).
  */
 function normalizeName(ecosystem: DependencyEcosystem, name: string): string {
   const n = name.trim();
@@ -583,6 +715,8 @@ export function manifestEcosystem(file: string): DependencyEcosystem | null {
   if (base === "go.mod") return "go";
   if (base === "pom.xml" || base === "build.gradle" || base === "build.gradle.kts") return "maven";
   if (base === "gemfile" || base.endsWith(".gemspec")) return "rubygems";
+  if (base === "packages.config" || base === "directory.packages.props" || base.endsWith(".csproj"))
+    return "nuget";
   return null;
 }
 
@@ -648,6 +782,20 @@ function candidateNames(ecosystem: DependencyEcosystem, content: string): string
       }
       break;
     }
+    case "nuget": {
+      // NuGet manifests are XML. `.csproj` / `Directory.Packages.props` declare
+      // `<PackageReference Include="Name" … />`; `packages.config` uses
+      // `<package id="Name" … />`. Pull the Include= / id= attribute value from
+      // each. The `[^>]` guard keeps every match inside a single tag, so the
+      // scan is linear (no nested quantifiers → no catastrophic backtracking).
+      for (const m of content.matchAll(/<PackageReference\b[^>]*\bInclude\s*=\s*"([^"]+)"/gi)) {
+        names.push(m[1]);
+      }
+      for (const m of content.matchAll(/<package\b[^>]*\bid\s*=\s*"([^"]+)"/gi)) {
+        names.push(m[1]);
+      }
+      break;
+    }
     case "npm":
       break; // npm uses the JSON path, not this extractor.
   }
@@ -682,8 +830,10 @@ function dependencyFinding(
     severity: dep.severity,
     confidence: "high",
     algorithm,
-    // Confidentiality libs are HNDL-exposed; signature-only ones are not.
-    hndl: dep.algorithms.some(isConfidentialityFamily),
+    // Confidentiality libs are HNDL-exposed; signature-only ones are not. An
+    // explicit `dep.hndl` wins (some packages list RSA/EC as a family but only
+    // ever sign — e.g. JWS/JWT libs — and signatures are not HNDL-exposed).
+    hndl: dep.hndl ?? dep.algorithms.some(isConfidentialityFamily),
     cwe: CWE_BROKEN_CRYPTO,
     message: `${dep.name} — ${dep.reason}`,
     remediation: multiFamilyRemediation(dep.algorithms),

package/src/detect-utils.ts

@@ -237,14 +237,43 @@ export const RUBY_EXTENSIONS: readonly string[] = [".rb"];
 /** C / C++ source extensions handled by the OpenSSL detector. */
 export const C_EXTENSIONS: readonly string[] = [".c", ".h", ".cc", ".cpp", ".cxx", ".hpp", ".hh"];
 
+/**
+ * Prose/documentation extensions. The language-agnostic *token* detectors (SSH
+ * public keys, TLS cipher suites, certificate signature algorithms) must not run
+ * on these: a changelog or README that mentions `ssh-rsa` or `ECDHE-RSA` in a
+ * sentence is prose, not crypto config. (PEM/`-----BEGIN` material stays in scope
+ * everywhere, so a key pasted into docs is still caught.)
+ */
+export const DOC_EXTENSIONS: readonly string[] = [
+  ".md",
+  ".markdown",
+  ".mdown",
+  ".mkd",
+  ".rst",
+  ".adoc",
+  ".asciidoc",
+  ".textile",
+  ".org",
+  ".rdoc",
+  ".pod",
+];
+
 /**
  * File-literal surfaces where a JWT/JOSE algorithm string (`"RS256"`, `"ES256"`)
  * is the same evidence regardless of language. Used to un-gate the JWT detector
- * from JS-only. Kept to JS/TS + Python for now (both quote the alg token, so the
- * regex stays precise); YAML/JSON config carry unquoted tokens and higher FP
- * risk, so they wait for a config-aware pass.
+ * from JS-only. Covers the languages whose JWT libraries pass the alg as a quoted
+ * token — JS/TS, Python, Go (`jwt.GetSigningMethod("RS256")`) and Ruby
+ * (`JWT.encode(payload, key, 'RS256')`) — so the regex stays precise (`HS*` HMAC
+ * tokens are excluded by `RE_JWT_ALG`). Java/C# pass the alg as an *identifier*
+ * (`SignatureAlgorithm.RS256`), which needs its own pattern — a later pass.
+ * YAML/JSON config carry unquoted tokens and higher FP risk, so they wait too.
  */
-export const JWT_HOST_EXTENSIONS: readonly string[] = [...JS_TS_EXTENSIONS, ...PYTHON_EXTENSIONS];
+export const JWT_HOST_EXTENSIONS: readonly string[] = [
+  ...JS_TS_EXTENSIONS,
+  ...PYTHON_EXTENSIONS,
+  ...GO_EXTENSIONS,
+  ...RUBY_EXTENSIONS,
+];
 
 /**
  * Extensions the scanner can actually analyze for inline crypto usage today

package/src/detectors/c.ts

@@ -16,7 +16,7 @@
  */
 import type { Detector, Finding, RuleMeta } from "../types.js";
 import { C_EXTENSIONS, eachMatch, findingFromRule, hasExtension } from "../detect-utils.js";
-import { CWE_BROKEN_CRYPTO } from "../cwe.js";
+import { CWE_BROKEN_CRYPTO, CWE_CERT_VALIDATION, CWE_WEAK_STRENGTH } from "../cwe.js";
 
 const RE_C_RSA = /\bRSA_generate_key(?:_ex)?\s*\(|\bEVP_RSA_gen\s*\(/g;
 const RE_C_EC = /\bEC_KEY_generate_key\s*\(|\bEC_KEY_new_by_curve_name\s*\(/g;
@@ -24,6 +24,30 @@ const RE_C_ECDSA = /\bECDSA_do_sign\s*\(|\bECDSA_sign\s*\(/g;
 const RE_C_ECDH = /\bECDH_compute_key\s*\(/g;
 const RE_C_DSA = /\bDSA_generate_key\s*\(|\bDSA_generate_parameters(?:_ex)?\s*\(/g;
 const RE_C_DH = /\bDH_generate_key\s*\(|\bDH_generate_parameters(?:_ex)?\s*\(/g;
+// Modern OpenSSL 3.x EVP API (the legacy *_generate_key forms above are
+// deprecated) + libsodium — the biggest C false-negative surface (audit F1).
+const RE_C_EVP_KEYGEN = /\bEVP_PKEY_(?:Q_)?keygen\s*\(|\bEVP_PKEY_paramgen\s*\(/g;
+const RE_C_EVP_DERIVE = /\bEVP_PKEY_derive\s*\(/g;
+const RE_C_EVP_CRYPT = /\bEVP_PKEY_(?:encrypt|decrypt)\s*\(/g;
+const RE_C_EVP_SIGN = /\bEVP_DigestSign(?:Init)?\s*\(|\bEVP_DigestVerify(?:Init)?\s*\(/g;
+// X25519: crypto_box / crypto_kx key pairs (incl. the fully-qualified
+// curve25519xsalsa20poly1305 form) plus the low-level crypto_scalarmult
+// primitive — all classical Curve25519 key agreement (audit recall gap).
+const RE_C_SODIUM_BOX =
+  /\bcrypto_box_(?:curve25519xsalsa20poly1305_)?(?:seed_)?keypair\s*\(|\bcrypto_kx_keypair\s*\(|\bcrypto_scalarmult_(?:curve25519|base)\s*\(/g;
+// EdDSA: crypto_sign key pairs, including the explicit _ed25519 forms and the
+// deterministic seed_keypair variants (audit recall gap: _ed25519_keypair).
+const RE_C_SODIUM_SIGN = /\bcrypto_sign_(?:ed25519_)?(?:seed_)?keypair\s*\(/g;
+// Legacy verify / decrypt counterparts to the *_sign / *_encrypt rules above
+// (audit F4-c): the classic OpenSSL RSA/ECDSA verification and RSA raw
+// decryption call forms that the modern EVP + legacy keygen rules don't cover.
+const RE_C_ECDSA_VERIFY = /\bECDSA_verify\s*\(/g;
+const RE_C_RSA_VERIFY = /\bRSA_verify\s*\(/g;
+const RE_C_RSA_CRYPT = /\bRSA_public_encrypt\s*\(|\bRSA_private_decrypt\s*\(/g;
+// C/OpenSSL legacy TLS configuration (mirrors source.ts tlsDetector): forcing a
+// deprecated protocol version or disabling certificate verification.
+const RE_C_TLS_VERSION = /\bTLSv1_method\b|\bSSLv3_method\b/g;
+const RE_C_TLS_VERIFY_NONE = /\bSSL_VERIFY_NONE\b/g;
 
 const RULE_C_RSA: RuleMeta = {
   id: "c-rsa-keygen",
@@ -104,6 +128,153 @@ const RULE_C_DH: RuleMeta = {
   message:
     "Finite-field Diffie-Hellman (C/OpenSSL) is broken by Shor's algorithm (harvest-now-decrypt-later).",
 };
+const RULE_C_EVP_KEYGEN: RuleMeta = {
+  id: "c-evp-keygen",
+  title: "C/OpenSSL EVP key generation",
+  description: "OpenSSL 3.x EVP_PKEY_keygen / EVP_PKEY_Q_keygen / paramgen",
+  category: "key-exchange",
+  severity: "high",
+  confidence: "high",
+  algorithm: "unknown",
+  hndl: true,
+  cwe: CWE_BROKEN_CRYPTO,
+  message:
+    "Generates an asymmetric key via the OpenSSL 3.x EVP API (the key type — RSA/EC/DH/X25519 — is set on the CTX). 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_C_EVP_DERIVE: RuleMeta = {
+  id: "c-evp-derive",
+  title: "C/OpenSSL EVP key agreement",
+  description: "OpenSSL 3.x EVP_PKEY_derive (ECDH / DH shared secret)",
+  category: "key-exchange",
+  severity: "high",
+  confidence: "high",
+  algorithm: "ECDH",
+  hndl: true,
+  cwe: CWE_BROKEN_CRYPTO,
+  message:
+    "Derives an (EC)DH shared secret via the OpenSSL EVP API — broken by Shor's algorithm (harvest-now-decrypt-later).",
+};
+const RULE_C_EVP_CRYPT: RuleMeta = {
+  id: "c-evp-pkey-crypt",
+  title: "C/OpenSSL EVP public-key encryption",
+  description: "OpenSSL 3.x EVP_PKEY_encrypt / EVP_PKEY_decrypt (RSA)",
+  category: "kem",
+  severity: "high",
+  confidence: "high",
+  algorithm: "RSA",
+  hndl: true,
+  cwe: CWE_BROKEN_CRYPTO,
+  message:
+    "RSA public-key encryption/decryption via the OpenSSL EVP API is harvest-now-decrypt-later exposed.",
+};
+const RULE_C_EVP_SIGN: RuleMeta = {
+  id: "c-evp-sign",
+  title: "C/OpenSSL EVP signing",
+  description: "OpenSSL 3.x EVP_DigestSign* / EVP_DigestVerify*",
+  category: "signature",
+  severity: "high",
+  confidence: "high",
+  algorithm: "unknown",
+  hndl: false,
+  cwe: CWE_BROKEN_CRYPTO,
+  message:
+    "Classical signature via the OpenSSL EVP API (RSA/ECDSA/EdDSA) is forgeable by a quantum attacker.",
+  remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+};
+const RULE_C_SODIUM_BOX: RuleMeta = {
+  id: "c-libsodium-box",
+  title: "libsodium X25519 key pair",
+  description:
+    "libsodium crypto_box / crypto_kx keypair + crypto_scalarmult (X25519 key agreement)",
+  category: "key-exchange",
+  severity: "medium",
+  confidence: "high",
+  algorithm: "X25519",
+  hndl: true,
+  cwe: CWE_BROKEN_CRYPTO,
+  message:
+    "libsodium crypto_box uses X25519 key agreement — modern but classical, and harvest-now-decrypt-later exposed.",
+};
+const RULE_C_SODIUM_SIGN: RuleMeta = {
+  id: "c-libsodium-sign",
+  title: "libsodium Ed25519 key pair",
+  description: "libsodium crypto_sign(_ed25519)(_seed)_keypair (Ed25519 signatures)",
+  category: "signature",
+  severity: "low",
+  confidence: "high",
+  algorithm: "EdDSA",
+  hndl: false,
+  cwe: CWE_BROKEN_CRYPTO,
+  message:
+    "libsodium crypto_sign uses Ed25519 signatures — classical and forgeable by a quantum attacker.",
+};
+const RULE_C_ECDSA_VERIFY: RuleMeta = {
+  id: "c-ecdsa-verify",
+  title: "C/OpenSSL ECDSA signature verification",
+  description: "OpenSSL ECDSA_verify",
+  category: "signature",
+  severity: "high",
+  confidence: "high",
+  algorithm: "ECDSA",
+  hndl: false,
+  cwe: CWE_BROKEN_CRYPTO,
+  message:
+    "Classical ECDSA verification (C/OpenSSL) trusts signatures forgeable by a quantum attacker.",
+  remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+};
+const RULE_C_RSA_VERIFY: RuleMeta = {
+  id: "c-rsa-verify",
+  title: "C/OpenSSL RSA signature verification",
+  description: "OpenSSL RSA_verify",
+  category: "signature",
+  severity: "high",
+  confidence: "high",
+  algorithm: "RSA",
+  hndl: false,
+  cwe: CWE_BROKEN_CRYPTO,
+  message:
+    "Classical RSA signature verification (C/OpenSSL) trusts signatures forgeable by a quantum attacker.",
+  remediation: "ML-DSA-65 (FIPS 204) or SLH-DSA (FIPS 205)",
+};
+const RULE_C_RSA_CRYPT: RuleMeta = {
+  id: "c-rsa-crypt",
+  title: "C/OpenSSL RSA public-key encryption",
+  description: "OpenSSL RSA_public_encrypt / RSA_private_decrypt",
+  category: "kem",
+  severity: "high",
+  confidence: "high",
+  algorithm: "RSA",
+  hndl: true,
+  cwe: CWE_BROKEN_CRYPTO,
+  message:
+    "Legacy RSA public-key encryption/decryption (C/OpenSSL) is harvest-now-decrypt-later exposed.",
+};
+const RULE_C_TLS_VERSION: RuleMeta = {
+  id: "c-tls-legacy-version",
+  title: "Legacy TLS/SSL version pinned (C/OpenSSL)",
+  description: "OpenSSL TLSv1_method / SSLv3_method",
+  category: "tls",
+  severity: "medium",
+  confidence: "high",
+  hndl: false,
+  cwe: CWE_WEAK_STRENGTH,
+  message: "TLS 1.0 / SSLv3 are deprecated and insecure; require TLS 1.3.",
+  remediation: "Use TLS_method() with a minimum of TLS 1.3 and prefer PQC-hybrid key exchange.",
+};
+const RULE_C_TLS_VERIFY_NONE: RuleMeta = {
+  id: "c-tls-verify-none",
+  title: "TLS certificate verification disabled (C/OpenSSL)",
+  description: "OpenSSL SSL_VERIFY_NONE",
+  category: "tls",
+  severity: "high",
+  confidence: "high",
+  hndl: false,
+  cwe: CWE_CERT_VALIDATION,
+  message: "SSL_VERIFY_NONE disables TLS certificate verification (MITM risk).",
+  remediation: "Use SSL_VERIFY_PEER and verify certificates properly.",
+};
 
 /** Detects classical asymmetric crypto in C/C++ (OpenSSL). */
 export const cDetector: Detector = {
@@ -111,7 +282,25 @@ export const cDetector: Detector = {
   description: "Classical asymmetric crypto in C/C++ (OpenSSL)",
   scope: "source",
   language: "c",
-  rules: [RULE_C_RSA, RULE_C_EC, RULE_C_ECDSA, RULE_C_ECDH, RULE_C_DSA, RULE_C_DH],
+  rules: [
+    RULE_C_RSA,
+    RULE_C_EC,
+    RULE_C_ECDSA,
+    RULE_C_ECDH,
+    RULE_C_DSA,
+    RULE_C_DH,
+    RULE_C_EVP_KEYGEN,
+    RULE_C_EVP_DERIVE,
+    RULE_C_EVP_CRYPT,
+    RULE_C_EVP_SIGN,
+    RULE_C_SODIUM_BOX,
+    RULE_C_SODIUM_SIGN,
+    RULE_C_ECDSA_VERIFY,
+    RULE_C_RSA_VERIFY,
+    RULE_C_RSA_CRYPT,
+    RULE_C_TLS_VERSION,
+    RULE_C_TLS_VERIFY_NONE,
+  ],
   appliesTo: (f) => hasExtension(f, C_EXTENSIONS),
   detect({ file, content }): Finding[] {
     const findings: Finding[] = [];
@@ -127,6 +316,17 @@ export const cDetector: Detector = {
     add(RE_C_ECDH, RULE_C_ECDH);
     add(RE_C_DSA, RULE_C_DSA);
     add(RE_C_DH, RULE_C_DH);
+    add(RE_C_EVP_KEYGEN, RULE_C_EVP_KEYGEN);
+    add(RE_C_EVP_DERIVE, RULE_C_EVP_DERIVE);
+    add(RE_C_EVP_CRYPT, RULE_C_EVP_CRYPT);
+    add(RE_C_EVP_SIGN, RULE_C_EVP_SIGN);
+    add(RE_C_SODIUM_BOX, RULE_C_SODIUM_BOX);
+    add(RE_C_SODIUM_SIGN, RULE_C_SODIUM_SIGN);
+    add(RE_C_ECDSA_VERIFY, RULE_C_ECDSA_VERIFY);
+    add(RE_C_RSA_VERIFY, RULE_C_RSA_VERIFY);
+    add(RE_C_RSA_CRYPT, RULE_C_RSA_CRYPT);
+    add(RE_C_TLS_VERSION, RULE_C_TLS_VERSION);
+    add(RE_C_TLS_VERIFY_NONE, RULE_C_TLS_VERIFY_NONE);
     return findings;
   },
 };