@quantakrypto/core 0.4.2 → 0.4.4

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,44 @@ 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); also ships PQC (ML-KEM/ML-DSA + hybrids), so migrate the classical *usage*, not the package.",
+    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 +544,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 +569,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 +591,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 +716,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 +783,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

@@ -223,7 +223,10 @@ export const PYTHON_EXTENSIONS: readonly string[] = [".py", ".pyi", ".pyw"];
 export const GO_EXTENSIONS: readonly string[] = [".go"];
 
 /** Java / Kotlin source extensions handled by the JCA detector. */
-export const JAVA_EXTENSIONS: readonly string[] = [".java", ".kt", ".kts"];
+// The JVM detector also covers Kotlin (`.kt`/`.kts`) and Scala (`.scala`/`.sc`):
+// all three compile against the same JCA (`KeyPairGenerator`, `Signature`,
+// `KeyAgreement`) and BouncyCastle APIs the Java rules match.
+export const JAVA_EXTENSIONS: readonly string[] = [".java", ".kt", ".kts", ".scala", ".sc"];
 
 /** C# source extensions handled by the .NET detector. */
 export const CSHARP_EXTENSIONS: readonly string[] = [".cs"];
@@ -234,17 +237,52 @@ export const RUST_EXTENSIONS: readonly string[] = [".rs"];
 /** Ruby source extensions handled by the Ruby detector. */
 export const RUBY_EXTENSIONS: readonly string[] = [".rb"];
 
+/** Elixir source extensions handled by the Elixir detector. */
+export const ELIXIR_EXTENSIONS: readonly string[] = [".ex", ".exs"];
+
+/** PHP source extensions handled by the PHP detector. */
+export const PHP_EXTENSIONS: readonly string[] = [".php", ".phtml", ".php3", ".php4", ".php5"];
+
 /** 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
@@ -262,6 +300,8 @@ export const ANALYZABLE_SOURCE_EXTENSIONS: readonly string[] = [
   ...CSHARP_EXTENSIONS,
   ...RUST_EXTENSIONS,
   ...RUBY_EXTENSIONS,
+  ...PHP_EXTENSIONS,
+  ...ELIXIR_EXTENSIONS,
   ...C_EXTENSIONS,
 ];
 
@@ -270,7 +310,8 @@ export const ANALYZABLE_SOURCE_EXTENSIONS: readonly string[] = [
  * crypto, shown in coverage output. Kept next to {@link
  * ANALYZABLE_SOURCE_EXTENSIONS} so a new language pack updates one place.
  */
-export const ANALYZABLE_LANGUAGES_LABEL = "JS/TS, Python, Go, Java, C#, Rust, Ruby, C/C++";
+export const ANALYZABLE_LANGUAGES_LABEL =
+  "JS/TS, Python, Go, Java/Kotlin/Scala, C#, Rust, Ruby, PHP, Elixir, C/C++";
 
 /** True when a path is in a source language the scanner can analyze for crypto. */
 export function isAnalyzableSource(filePath: string): boolean {