@quantakrypto/core 0.4.2 → 0.4.3

package/src/comments.ts

@@ -109,6 +109,54 @@ export function commentSpans(content: string, style: CommentStyle): Array<[numbe
   return spans;
 }
 
+/**
+ * Compute Python triple-quoted string spans (`"""…"""` / `'''…'''`). These are
+ * docstrings / prose in practice, so a crypto *name* mentioned inside one
+ * (`:param key_type: eg "ssh-ed25519"`) should not fire a token finding — but a
+ * PEM key pasted into one is still real material, so {@link stripCommentFindings}
+ * exempts `pem-*` rules. Comments and normal strings are skipped so a `"""`
+ * delimiter inside them is not mis-detected.
+ */
+export function pythonDocstringSpans(content: string): Array<[number, number]> {
+  const spans: Array<[number, number]> = [];
+  const n = content.length;
+  let i = 0;
+  while (i < n) {
+    const c = content[i];
+    if (c === "#") {
+      i++;
+      while (i < n && content[i] !== "\n") i++;
+      continue;
+    }
+    if ((c === '"' || c === "'") && content[i + 1] === c && content[i + 2] === c) {
+      const start = i;
+      i += 3;
+      while (i < n && !(content[i] === c && content[i + 1] === c && content[i + 2] === c)) i++;
+      i = Math.min(n, i + 3);
+      spans.push([start, i]);
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const q = c;
+      i++;
+      while (i < n) {
+        if (content[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (content[i] === q) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    i++;
+  }
+  return spans;
+}
+
 /** True if `offset` falls inside one of the (sorted, non-overlapping) spans. */
 export function offsetInSpans(spans: ReadonlyArray<[number, number]>, offset: number): boolean {
   let lo = 0;
@@ -163,7 +211,9 @@ export function stripCommentFindings(
   const style = commentStyleForFile(file);
   if (!style) return findings;
   const spans = commentSpans(content, style);
-  if (spans.length === 0) return findings;
+  // Python docstrings suppress prose *token* rules but keep real PEM material.
+  const docSpans = style === "hash" ? pythonDocstringSpans(content) : [];
+  if (spans.length === 0 && docSpans.length === 0) return findings;
 
   // 1-based line → start offset, to turn a finding's (line, column) back into an
   // absolute offset (column is 1-based: offset = lineStart + column - 1).
@@ -173,6 +223,95 @@ export function stripCommentFindings(
   }
 
   return findings.filter((f) => {
+    const start = lineStarts[f.location.line - 1] ?? 0;
+    const offset = start + ((f.location.column ?? 1) - 1);
+    if (offsetInSpans(spans, offset)) return false;
+    if (docSpans.length > 0 && !f.ruleId.startsWith("pem-") && offsetInSpans(docSpans, offset)) {
+      return false;
+    }
+    return true;
+  });
+}
+
+/**
+ * Compute the string-literal spans (`[start, end)`) of `content`, skipping over
+ * comments so a quote inside a comment is not treated as a string. Used to
+ * suppress findings from IDENTIFIER-only rules (e.g. a Go `SigningMethodRS256`
+ * mentioned inside an error-message string) — the mirror of {@link commentSpans}.
+ */
+export function stringSpans(content: string, style: CommentStyle): Array<[number, number]> {
+  const spans: Array<[number, number]> = [];
+  const n = content.length;
+  let i = 0;
+  while (i < n) {
+    const c = content[i];
+    if (style === "c" && c === "/" && content[i + 1] === "/") {
+      i += 2;
+      while (i < n && content[i] !== "\n") i++;
+      continue;
+    }
+    if (style === "c" && c === "/" && content[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(content[i] === "*" && content[i + 1] === "/")) i++;
+      i = Math.min(n, i + 2);
+      continue;
+    }
+    if (style === "hash" && c === "#") {
+      i++;
+      while (i < n && content[i] !== "\n") i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      const quote = c;
+      const start = i;
+      i++;
+      while (i < n) {
+        if (content[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (content[i] === quote) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      spans.push([start, i]);
+      continue;
+    }
+    i++;
+  }
+  return spans;
+}
+
+/**
+ * Drop findings of "code-only" rules (`ruleIds`) whose match starts inside a
+ * string literal. Some rules — an identifier-form JWT signing method, a Go
+ * `SigningMethodRS256` — are only meaningful as code; when the same token appears
+ * inside a string (a test's `t.Error("SigningMethodPS256 …")`) it is prose, not a
+ * usage. Rules that legitimately match inside strings (quoted `"RS256"` alg
+ * tokens, cipher-suite strings, ssh-key tokens) are NOT in `ruleIds` and pass
+ * through untouched.
+ */
+export function stripStringLiteralFindings(
+  findings: Finding[],
+  content: string,
+  file: string,
+  ruleIds: ReadonlySet<string>,
+): Finding[] {
+  if (findings.length === 0 || !findings.some((f) => ruleIds.has(f.ruleId))) return findings;
+  const style = commentStyleForFile(file);
+  if (!style) return findings;
+  const spans = stringSpans(content, style);
+  if (spans.length === 0) return findings;
+
+  const lineStarts: number[] = [0];
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") lineStarts.push(i + 1);
+  }
+
+  return findings.filter((f) => {
+    if (!ruleIds.has(f.ruleId)) return true;
     const start = lineStarts[f.location.line - 1] ?? 0;
     const offset = start + ((f.location.column ?? 1) - 1);
     return !offsetInSpans(spans, offset);

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
@@ -313,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",
@@ -422,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",
@@ -445,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) ---
   {
@@ -476,6 +543,21 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     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 ---
   {
@@ -486,6 +568,14 @@ export const vulnerableDependencies: VulnerableDependency[] = [
     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",
     ecosystem: "rubygems",
@@ -500,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();
@@ -592,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;
 }
 
@@ -657,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.
   }

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