/

CVE-2026-74893

Severity:

HIGH RISK

(8.8)

Hardcoded Secrets (CWE-798) in openssl_encrypt JWT

CVE-2026-74893

Analyzed

Vulnerability type

Category:

Hardcoded Credentials

CWE:

CWE-798

Impact:

Authentication Bypass and Unauthorized API Access

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Versions of openssl_encrypt before 1.4.0 contain hardcoded default JWT signing secrets in config.py that can pass validation checks. An attacker who obtains the source code may use those secrets to forge valid tokens for arbitrary client_id values and gain authenticated access to keyserver and telemetry APIs.

Affected context

The vulnerability occurs in deployments using affected openssl_encrypt versions where default JWT signing secrets remain embedded in application source code. Risk is increased when source code is accessible to unauthorized users and when the keyserver or telemetry APIs trust tokens signed with those predictable or exposed secrets.

Exploit preconditions

  • Attack surface: JWT-authenticated keyserver and telemetry APIs
  • Required access: Access to the application source code or another location containing the embedded secrets
  • Trigger point: JWT validation using a hardcoded default signing secret
  • Why exploitation is possible: The known secret allows an attacker to create tokens that pass signature and identity checks for arbitrary client_id values

Why this happens

The underlying bug is the inclusion of default cryptographic signing material in application code. This maps to CWE-798: Use of Hard-coded Credentials, because a secret used to authenticate requests is fixed in source code and may be recoverable by anyone who can inspect or obtain the code. Validation of the configuration does not make the secret secure when the accepted value is publicly exposed or shared across deployments.

Potential impact

  • An attacker may forge authenticated JWTs
  • Unauthorized users could access keyserver APIs
  • Telemetry data may be read, altered, or submitted fraudulently
  • Attackers could impersonate arbitrary clients
  • Compromised credentials could enable further access depending on API permissions

General mitigation guidance

Mitigation generally focuses on removing static secrets from source code and reducing trust in shared defaults.

Common defensive patterns include:

  • Supplying signing keys through protected runtime secret management systems
  • Generating unique, high-entropy secrets for each deployment
  • Rejecting default, placeholder, or reused signing keys during startup validation
  • Rotating potentially exposed signing material and invalidating tokens signed with it
  • Restricting API permissions and applying least privilege to client identities
  • Limiting source-code access and preventing secrets from entering repositories or build artifacts
  • Using key identifiers and controlled key rotation mechanisms where appropriate

How teams detect issues like this

Organizations can identify this class of issue through:

  • Static analysis and secret-scanning rules for JWT keys and credential-like constants
  • Code review checks for signing secrets assigned directly in source files
  • Repository history and build-artifact scans for exposed or duplicated secrets
  • Configuration-policy checks that reject known defaults and weak signing material
  • Runtime monitoring for tokens issued for unexpected clients or unusual API activity
  • Automated security review tools that flag hardcoded credentials and insecure authentication configuration

Sources

SourceLink
github.comgithub.com/jahlives/openssl_encrypt/security/advisories/GHSA-qc6h-gfjh-7qqg
vulncheck.comvulncheck.com/advisories/openssl-encrypt-before-jwt-token-forgery-via-hardcoded-secrets

Frequently asked

questions

The vulnerability generally requires access to source code or another location containing the hardcoded secret. Once the secret is obtained, forged tokens may be submitted remotely to exposed APIs.

The key prerequisite is the ability to recover the embedded signing secret. The attacker also needs network reachability to the affected JWT-authenticated APIs.

Remove signing secrets from source code, use protected per-deployment secret management, reject default values, and rotate any key that may have been exposed.

Combine secret scanning, secure configuration policies, least-privilege API authorization, controlled key rotation, and monitoring for anomalous token use.

Find out what's already
exploitable in your codebase.