Skip to main content

Auth0 java-jwt EUVDEUVD-2026-100486

| CVE-2026-85473 MEDIUM
Improper Input Validation (CWE-20)
2026-10-13 psirt@okta.com
5.3
CVSS 3.1 · Vendor: okta
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Send crafted JWT with out-of-range timestamp
  2. Delivery
    Trigger parsing fault before signature check
  3. Exploit
    Terminate processing thread
  4. Execution
    Repeat requests at volume
  5. Impact
    Degrade service availability

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
Exploitation Conditions

The affected service must use auth0/java-jwt 4.0.0 through versions before 4.6.2 to parse JWTs supplied by the attacker (e.g., tokens accepted from HTTP requests at an authentication or API endpoint). Because the out-of-range timestamp-claim (exp/nbf/iat) fault occurs during parsing PRIOR to signature verification, no valid signature, credentials, or authentication are required (PR:N) and no user interaction is needed. Limiting factors: impact is bounded to single-thread termination per malformed token, so sustained, repeated requests are needed to produce meaningful availability degradation, and the endpoint must actually invoke the vulnerable parsing path on untrusted input; services that do not expose java-jwt parsing to unauthenticated/attacker-controlled tokens are not meaningfully exposed.

Impact

This is a moderate, availability-only issue (CVSS 5.3, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) with no confidentiality or integrity impact. The network vector, low complexity, and lack of required privileges or user interaction mean the trigger is easy to reach remotely and pre-authentication, since the fault occurs during token parsing BEFORE signature verification - an attacker does not need a valid signed token. However, the real-world severity is capped: the CVSS A:L reflects that a single malformed JWT terminates one thread rather than crashing the whole service, and the description itself notes that meaningful impact requires 'repeated requests' to achieve degraded availability. No EPSS score was provided, the CVE is not on CISA KEV, and no public exploit was supplied, so there is no evidence of active or widespread exploitation. The provided 'Information Disclosure' tag directly conflicts with the vector and description (C:N, pure availability flaw) and appears to be a mislabel - treat it as a denial-of-service/availability issue, not disclosure. Overall this is a legitimate but non-urgent patch-on-cycle issue rather than a high-priority emergency; prioritize for services that parse untrusted, attacker-supplied JWTs at scale.

Exploit ScenarioDerived

An attacker sends HTTP requests carrying crafted JWTs whose exp, nbf, or iat claims contain out-of-range timestamp values to an endpoint backed by a vulnerable java-jwt version. Because the flaw triggers during parsing before signature verification, no valid signature or authentication is required; each malformed token terminates a processing thread, and sustained request volume progressively degrades service availability. No public exploit code was identified at time of analysis.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 14, 2026

Thread termination in Auth0 java-jwt versions 4.0.0 through 4.6.1 allows remote unauthenticated attackers to degrade service availability by sending JWTs with out-of-range timestamp claims (exp, nbf, iat). The fault occurs during token parsing before signature verification, so no valid credentials are needed. Repeated requests can exhaust service threads, causing a denial-of-service condition; no public exploit code or active exploitation has been identified at time of analysis. A patch is available in version 4.6.2.

RemediationAI

Vendor-released patch: upgrade to Auth0 java-jwt version 4.6.2 or later. This is the only complete fix. If immediate upgrade is not possible, consider compensating controls such as restricting JWT parsing endpoints to trusted clients or networks, although this may not be feasible for public-facing authentication services. Additionally, implementing rate limiting on endpoints that parse JWTs can reduce the impact of repeated malicious requests, but it does not eliminate the thread termination vulnerability because each malformed token still causes a thread to die. Another temporary measure is to front-end the service with a proxy or gateway that rejects tokens with clearly invalid timestamp claims before they reach the vulnerable library, though crafting such a filter requires parsing the JWT without the vulnerable library and may be error-prone. Disabling timestamp validation in the library is not recommended as it would introduce other security risks. See the vendor advisories for further details: GitHub Security Advisory GHSA-cg7w-5cc2-f2xm and Okta Trust advisory. Patching is strongly recommended as the most reliable remediation.

Affected VersionsENISA

java-jwt 4.0.0 <4.6.2

Affected Packages

euvd java_jwt fix: 4.6.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The vulnerability resides in the Auth0 java-jwt library, a Java implementation for creating and verifying JSON Web Tokens (JWTs). JWTs contain registered claims such as exp (expiration time), nbf (not before), and iat (issued at), which are NumericDate values representing seconds since the epoch. CWE-20 (Improper Input Validation) is the root cause: the library fails to validate that these timestamp values fall within an acceptable range before processing them. When an out-of-range value is encountered during parsing, the resulting error is not handled in a way that preserves the thread, leading to thread termination. This occurs prior to signature verification, meaning an attacker does not need a valid signature or any authentication to trigger the condition. The affected component is the JWT parsing routine that extracts and validates claims. Applications that expose JWT parsing to untrusted input (e.g., API authentication endpoints) are susceptible to repeated requests that each terminate a thread, cumulatively degrading availability. The library is used in Java-based services, and the issue affects versions 4.0.0 up to but not including 4.6.2, as noted in the EUVD entry and vendor advisory.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (okta) PRIMARY 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
vuln.today AI 5.3 MEDIUM

Remotely reachable pre-authentication parsing fault (AV:N/AC:L/PR:N/UI:N); no confidentiality or integrity impact and only partial, repetition-dependent availability loss gives A:L.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (okta).

CVSS VectorVendor: okta

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
Low

Lifecycle Timeline

2
Patch available
Oct 13, 2026 - 21:50 EUVD
CVE Published
Oct 13, 2026 - 21:19 cve.org
MEDIUM 5.3

DescriptionCVE.org

The auth0/java-jwt library may terminate a thread if it receives a JWT with a timestamp claim (exp, nbf, iat) containing an out-of-range value. The condition occurs during token parsing, prior to signature verification. Repeated requests of this nature may lead to degraded availability of the affected service.

Threat Intelligence Overview

EPSS Score
0.3%
Top 77% exploitable
Prevalence
High
widely-used JWT library across Java backend and API services
Data Quality
5 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy