CVE-2025-45768: PyJWT Information Disclosure Vulnerability

CVE-2025-45768 Overview

A weak encryption vulnerability was identified in PyJWT version 2.10.1, a popular Python library for encoding and decoding JSON Web Tokens (JWT). The vulnerability relates to the library's handling of encryption key lengths, which may allow attackers to compromise JWT security when applications use insufficiently strong keys. It is important to note that this CVE is disputed by the supplier, who argues that key length selection is the responsibility of the application developer using the library, though they acknowledge that library users may benefit from minimum value enforcement mechanisms.

Critical Impact

Applications using PyJWT with weak or short encryption keys may be vulnerable to cryptographic attacks, potentially allowing attackers to forge tokens, bypass authentication, or gain unauthorized access to protected resources.

Affected Products

• PyJWT v2.10.1
• Applications implementing PyJWT without enforcing minimum key length requirements
• Systems relying on JWT-based authentication using this library version

Discovery Timeline

• 2025-07-31 - CVE CVE-2025-45768 published to NVD
• 2025-09-12 - Last updated in NVD database

Technical Details for CVE-2025-45768

Vulnerability Analysis

This vulnerability falls under CWE-311 (Missing Encryption of Sensitive Data), relating to weak encryption practices within the PyJWT library. The core issue centers on the library's failure to enforce minimum key length requirements for cryptographic operations. While the library supports strong encryption algorithms, it does not prevent application developers from using weak or insufficiently long keys, which can undermine the security guarantees of JWT tokens.

The attack requires network access and involves high complexity, as successful exploitation depends on the specific key length chosen by the application developer. When applications use weak keys, attackers may be able to perform brute-force attacks or cryptographic analysis to recover the signing key and forge valid JWT tokens.

Root Cause

The root cause of this vulnerability is the absence of mandatory minimum key length enforcement within the PyJWT library. The library delegates key strength decisions entirely to the application developer without providing warnings or rejecting weak keys. This design choice, while providing flexibility, creates a security gap when developers are unaware of or neglect cryptographic best practices.

The supplier disputes this classification, arguing that key selection is an application-level responsibility rather than a library defect. They suggest that implementing opt-in strict enforcement mechanisms may address this concern in future versions.

Attack Vector

The vulnerability is exploitable over the network, requiring no privileges or user interaction. An attacker would target applications using PyJWT with weak encryption keys by attempting to:

1. Capture valid JWT tokens through network interception
2. Perform offline cryptographic analysis against weak keys
3. Brute-force short or weak keys to recover the secret
4. Forge arbitrary JWT tokens once the key is compromised
5. Use forged tokens to bypass authentication and authorization controls

The attack complexity is high because it depends on the specific key length and entropy used by the target application. Applications implementing strong key management practices would not be vulnerable to this attack.

Detection Methods for CVE-2025-45768

Indicators of Compromise

• Unusual authentication patterns with valid-appearing JWT tokens from unknown sources
• Multiple failed token validation attempts followed by successful authentication
• JWT tokens with unexpected claims or modified payloads
• Authentication events from geographic locations inconsistent with user behavior

Detection Strategies

• Audit application code to identify PyJWT v2.10.1 usage and review key length configurations
• Implement monitoring for JWT token anomalies including unexpected claim values
• Deploy runtime application self-protection (RASP) solutions to detect token manipulation attempts
• Review authentication logs for patterns indicating token forgery

Monitoring Recommendations

• Enable detailed logging for all JWT validation operations
• Monitor for spikes in authentication failures that may indicate brute-force attempts
• Implement alerting on JWT tokens with unusual timestamps or extended validity periods
• Track and baseline normal JWT usage patterns to identify anomalies

How to Mitigate CVE-2025-45768

Immediate Actions Required

• Audit all applications using PyJWT to verify they implement strong key management practices
• Ensure all JWT signing keys meet minimum length requirements (256 bits for HMAC, 2048 bits for RSA)
• Rotate any potentially weak keys and invalidate existing tokens
• Review the PyJWT library repository for security guidance and updates

Patch Information

As of the last update on 2025-09-12, this vulnerability remains disputed by the supplier. No official patch has been released as the vendor considers key length selection to be an application-level responsibility. Application developers should implement their own key length validation or await potential opt-in strict enforcement features in future library versions.

Additional technical details can be found in the security research reference.

Workarounds

• Implement application-level validation to reject keys below minimum length thresholds (e.g., 256 bits for symmetric algorithms)
• Use asymmetric algorithms (RS256, ES256) with appropriately sized key pairs
• Consider wrapping PyJWT initialization with custom validation logic to enforce key strength requirements
• Document and enforce key generation policies within development teams

# Configuration example - Key strength validation wrapper
# Implement key length checks before JWT operations
# Example: Validate HMAC key is at least 256 bits (32 bytes)
# python -c "import secrets; print(secrets.token_hex(32))"
# Use generated strong keys for JWT signing operations