CVE-2025-61152: 
Linux Debian vulnerability analysis and mitigation

CVE-2025-61152 is a disputed JWT authentication bypass vulnerability in the python-jose library (versions through 3.3.0) that allows JWT tokens with alg=none to be decoded and accepted without cryptographic signature verification. A malicious actor can craft forged tokens with arbitrary claims (e.g., is_admin=true) to bypass authentication and escalate privileges in applications relying on python-jose for token validation. The CVE was published on October 10, 2025, and carries a CVSS v3.1 base score of 6.5 (Medium) (Red Hat CVE, PoC Advisory). Importantly, all parties — including the python-jose maintainers and SUSE — agree the issue only manifests when developers explicitly pass options={"verify_signature": False}, making this a disputed finding (python-jose Issue #391).

The root cause is classified as CWE-269 (Improper Privilege Management): when jwt.decode() is called with options={"verify_signature": False}, the library skips all cryptographic signature checks and accepts tokens regardless of the alg header value, including alg=none (PoC Advisory). The attack vector is network-based, requires no authentication or user interaction, and has low attack complexity. The affected components include jwt.api_jwt, jwt.api_jws, jwt.algorithms, and jwt.utils. The dispute centers on the fact that the library does not enable this behavior by default — it requires an explicit developer opt-in to disable signature verification, meaning the library itself is not inherently insecure (python-jose Issue #391).

If an application passes verify_signature: False to python-jose's decode function and does not separately reject alg=none tokens, a remote unauthenticated attacker can forge JWT tokens with arbitrary claims, achieving authentication bypass and privilege escalation (e.g., impersonating an administrator). The confidentiality and integrity impacts are rated Low in the CVSS scoring, reflecting that exploitation is conditional on a specific developer misconfiguration rather than a universal library flaw (Red Hat CVE). There is no availability impact assessed for this vulnerability.

1. Identify target: Locate a web application using python-jose (≤ 3.3.0) for JWT validation where the application code calls jwt.decode() with options={"verify_signature": False} and does not separately validate the alg header.
2. Craft a forged JWT: Construct a JWT with alg=none in the header and arbitrary elevated claims in the payload. Example:

import base64, json
header = base64.urlsafe_b64encode(json.dumps({"alg": "none", "typ": "JWT"}).encode()).rstrip(b'=').decode()
payload = base64.urlsafe_b64encode(json.dumps({"user": "admin", "is_admin": True}).encode()).rstrip(b'=').decode()
token = f"{header}.{payload}."

3. Submit the forged token: Send the crafted token in the Authorization: Bearer <token> header to the target application's authenticated endpoint.
4. Achieve privilege escalation: If the application trusts the decoded claims without additional validation, the attacker gains access as an administrator or any other user role specified in the forged payload (PoC Advisory).

• Network: Incoming HTTP requests with Authorization: Bearer tokens where the JWT header decodes to {"alg": "none"} (base64 header segment: eyJhbGciOiAibm9uZSJ9 or similar variants); requests with JWTs that have an empty signature segment (token ends with a trailing .).
• Logs: Application logs showing successful authentication or authorization for users with elevated roles (e.g., is_admin=true) from unexpected sources or at unusual times; JWT decode operations with verify_signature=False in application debug logs.
• Application Behavior: Unexpected administrative actions performed by accounts not previously granted admin privileges; access to admin-only endpoints from accounts with no prior admin activity.

No official patch has been released for python-jose as of the time of publication, and the maintainers dispute the severity given the precondition required (python-jose Issue #391). The primary remediation is to never call jwt.decode() with options={"verify_signature": False} in production code. As an additional defense-in-depth measure, explicitly reject tokens with alg=none before decoding:

header = jwt.get_unverified_header(token)
if header.get("alg", "").lower() == "none":
    raise ValueError("Unsigned JWT tokens are not allowed")

Enforce signature verification using strong algorithms such as HS256 or RS256, and audit all JWT parsing points in the codebase (PoC Advisory).

The python-jose community and SUSE security researchers have disputed the validity of this CVE, noting that the PoC only demonstrates the issue when verify_signature: False is explicitly set by the developer — a configuration that inherently disables all security checks (python-jose Issue #391). The MITRE CVE description itself includes a NOTE acknowledging that "all parties agree that the issue is not relevant because it only occurs in a verify_signature: False situation." Red Hat has tracked the CVE but has not issued a patch advisory, consistent with the disputed classification (Red Hat CVE).