Skip to main content

Eclipse Jetty CVE-2026-76184

| EUVDEUVD-2026-101946 HIGH
Information Exposure (CWE-200)
2026-10-15 eclipse GHSA-j5fg-j6xp-mjwf
8.2
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Deploy malicious app on same domain
  2. Delivery
    Induce credentialed HttpClient request
  3. Exploit
    Return redirect to /secure/../evil
  4. Execution
    HttpClient skips path normalization
  5. Persist
    Authorization header sent to /evil
  6. Impact
    Capture leaked credentials

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V14 - Data Protection Data exposure prevention
MITRE ATT&CK

2 techniques across 2 tactics: Collection, Discovery

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires three concrete conditions stated in the advisory: (1) the target application must use Jetty HttpClient to send credentials via an Authorization header scoped to a path such as /secure and must follow HTTP redirects; (2) the attacker must be able to control or influence the redirect response returned to HttpClient; and (3) the attacker must have a malicious application deployed on the SAME domain as the target so the leaked Authorization header reaches an endpoint they control (e.g. /secure/../evil). LIMITING FACTORS: the same-domain malicious-app requirement and the need to control redirects substantially raise attack complexity (reflected as AC:H), preventing arbitrary cross-domain credential theft; applications that do not follow redirects or do not attach path-scoped credentials are unaffected.

Impact

This is a credential-disclosure flaw (CWE-200) in Eclipse Jetty's HttpClient where a non-normalized redirect path (e.g. /secure/../evil) causes the Authorization header scoped to /secure to be sent to /evil. The provided CVSS 4.0 vector (AV:N/AC:H/AT:N/PR:N/UI:N/VC:H) scores 8.2 (High): network-reachable, no privileges or user interaction, but high attack complexity, with high confidentiality impact and no integrity/availability impact - consistent with pure information disclosure. The high AC is well justified by the description's precondition that the attacker must both control the redirect target and already have a malicious application deployed on the same domain as the target, which materially narrows exploitability. No EPSS score, CISA KEV listing, SSVC decision, or POC was provided in the input, so the signals are not conflicting but are incomplete: the only evidence of real-world risk is the vendor (Eclipse) GHSA advisory. Bottom line - a legitimately High-severity credential leak for applications using Jetty HttpClient with credentialed, redirect-following requests, but the same-domain malicious-app precondition makes opportunistic mass exploitation unlikely; prioritize for environments where Jetty HttpClient handles authenticated outbound requests to attacker-influenceable hosts.

Exploit ScenarioDerived

An application uses Jetty HttpClient to make authenticated requests (sending an Authorization header scoped to /secure) and follows server redirects. An attacker who controls a redirect response and has an app deployed under the same domain returns a redirect to /secure/../evil; HttpClient matches credentials against the literal /secure prefix instead of the normalized /evil and forwards the Authorization header to the attacker-controlled /evil endpoint, disclosing the credentials. No public exploit was identified at time of analysis.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 15, 2026

Path-normalization weakness in Eclipse Jetty's HttpClient causes credential disclosure: when HttpClient receives a redirect whose target contains a non-normalized traversal segment such as /secure/../evil, Jetty matches the stored Authorization credential against the literal /secure prefix rather than resolving the path to /evil, and then follows the redirect - sending the /secure-scoped Authorization header to an endpoint that should never receive it. Per the provided CVSS vector (PR:N) the attacker is unauthenticated, but exploitation carries high attack complexity (AC:H): the attacker must be able to control or influence the redirect response returned to HttpClient, and must already have a malicious application deployed on the SAME domain as the target so the leaked header lands on an endpoint they control. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis.

RemediationAI

No exact fixed version was supplied in the available data, so consult the vendor advisory at https://github.com/jetty/jetty.project/security/advisories/GHSA-qfr2-43g5-g768 for the release that contains the normalization fix, and upgrade Jetty HttpClient to that version as the primary remediation; the Eclipse assignment record at https://gitlab.eclipse.org/security/cve-assignment/-/work_items/236 provides the CVE tracking context. If an immediate upgrade is not possible, the most effective compensating control is to stop HttpClient from following redirects at all - disable automatic redirect handling (e.g. Jetty's HttpRedirector / setFollowRedirects(false)) and re-issue any needed follow-up request yourself after explicitly normalizing the Location path and re-validating that the credential scope still matches; the trade-off is that legitimate redirect-based flows (auth handshakes, load-balancer or CDN hops) will break and must be coded manually. A second option is to avoid attaching path-scoped Authorization credentials to HttpClient requests, or to scope them to the exact final origin rather than a prefix, accepting that this removes the convenience of prefix-scoped credential reuse and may require per-endpoint credential plumbing. As a deployment-level control, ensure that untrusted tenants or applications cannot be hosted on the same domain (and thus same credential scope) as systems receiving path-scoped credentials from Jetty HttpClient, since the advisory states the attacker must have a malicious application deployed on the same domain for the leaked header to reach them; this reduces exposure but does not fix the underlying matching logic and is not a substitute for patching.

Affected VersionsENISA

Eclipse Jetty 12.0.0 ≤12.0.38
Eclipse Jetty 11.0.0 ≤11.0.32
Eclipse Jetty 9.4.0 ≤9.4.64
Eclipse Jetty 10.0.0 ≤10.0.32
Eclipse Jetty 12.1.0 ≤12.1.12

Affected Packages

euvd eclipse_jetty no fix

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 flaw is an instance of CWE-200 (Exposure of Sensitive Information), rooted in how Jetty's HttpClient resolves and authorizes redirect targets. HTTP clients commonly scope credentials to a path prefix and re-evaluate that scope on each redirect hop. Jetty evaluates the raw, un-normalized Location value - so the string '/secure/../evil' still matches the '/secure' scope - instead of first performing RFC 3986 dot-segment removal to arrive at '/evil'. The Authorization header is therefore attached to the request for the traversed path, and because the CPE string cpe:2.3:a:eclipse_foundation:eclipse_jetty:*:*:*:*:*:*:*:* carries no version bounds, all Jetty releases are treated as potentially affected pending advisory guidance. The impact is confidentiality-only (VC:H, VI:N, VA:N) and, in the independent assessment's CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N formulation, scope is unchanged - the leak does not cross domain boundaries on its own. The practical blast radius is bounded by two prerequisites the advisory makes explicit: the attacker must control the redirect response, and the credential-stealing endpoint must live on the same domain (and same security origin/credential scope) as the legitimate target, which is why complexity is rated High rather than Low. Applications that do not follow redirects, or that do not attach path-scoped credentials to HttpClient requests, are not exposed.

Know when Eclipse Jetty gets its next vulnerability

  • 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 (eclipse) PRIMARY 8.2 HIGH
CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
vuln.today AI 5.9 MEDIUM

AC:H because the attacker must control redirects and deploy a same-domain app; PR:N/UI:N per advisory; C:H for Authorization credential leak with no integrity or availability impact.

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

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

Attack Vector
Network
Attack Complexity
High
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

In Eclipse Jetty, HttpClient may receive a redirect of the form:




/secure/../evil


If an attacker is able to control the redirects, then HttpClient matches authentication credentials against /secure rather than normalizing the path to /evil, and will therefore follow the redirect sending the Authorization header for /secure to /evil.

This also mean that the attacker must have an evil application deployed on the same domain as the target.

Technical POC Analysis

CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Eclipse Jetty's HttpClient component contains a path-normalization weakness (CVE-2026-76184, CVSS 8.2, HIGH) that can cause scoped Authorization credentials to be transmitted to an endpoint on the same domain that should never receive them. Any team operating Jetty-based HTTP clients that follow redirects - particularly where credentials are attached to path-scoped requests or where third parties can deploy applications on the same domain - should assume those credentials may be exposed. Because exploitation carries high attack complexity and requires an attacker-controlled redirect plus a same-domain foothold, this is a targeted rather than mass-exploitation risk, but leaked service credentials can enable lateral movement and must be treated as a potential account-takeover path.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: disable automatic redirect following in Jetty HttpClient and resolve/normalize redirect targets manually before re-attaching any Authorization credential; restrict or allowlist permitted redirect destinations; avoid path-scoped credential reuse across trust boundaries and shorten credential lifetimes; isolate clients so third parties cannot deploy applications on the same domain as credential-bearing services; segment outbound network egress; and monitor logs for Authorization headers sent to unexpected endpoints. Re-evaluate immediately when the Eclipse Jetty project publishes a fixed version.

Threat Intelligence Overview

EPSS Score
0.3%
Top 81% exploitable
Prevalence
High
Eclipse Jetty is a widely deployed embedded/enterprise Java web server and client
Social Media
2
Sightings
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment CIRCL GitHub VulDB

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 HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

CVE-2026-2332 CRITICAL
9.1 Apr 14

HTTP request smuggling in Eclipse Jetty's HTTP/1.1 parser lets remote unauthenticated attackers desynchronize front-end/

CVE-2026-18661 HIGH
8.8 Oct 15

Security-constraint bypass in Eclipse Jetty leaves some request URL patterns unprotected when annotation and deployment-

CVE-2026-19204 HIGH
8.7 Sep 07

Unauthenticated remote denial-of-service in Eclipse Jetty's WebSocket implementation allows any network-accessible clien

CVE-2026-12611 HIGH
8.7 Sep 08

HTTP/2 thread-exhaustion denial-of-service in Eclipse Jetty allows unauthenticated remote clients to permanently block a

CVE-2026-19203 HIGH
8.3 Sep 08

HTTP/1.1 request smuggling in Eclipse Jetty allows unauthenticated remote attackers to desynchronize request boundary pa

CVE-2026-77711 HIGH
8.2 Oct 15

Eclipse Jetty's HttpClient can disclose proxy authentication credentials to a malicious server when the server returns a

CVE-2026-5795 HIGH
7.4 Apr 08

Privilege escalation in Eclipse Jetty 9.4.0-12.1.7 allows unauthenticated remote attackers to bypass authentication via

CVE-2026-76182 MEDIUM
6.9 Oct 15

Query-parameter injection in Eclipse Jetty's TryPathsHandler and TryFilesFilter allows unauthenticated remote attackers

CVE-2026-10051 MEDIUM
6.9 Jul 14

HTTP/1.1 trailer leakage in Eclipse Jetty allows a remote unauthenticated attacker to read trailer headers from a previo

CVE-2026-6790 MEDIUM
5.3 Jul 14

Eclipse Jetty fails to enforce RFC 9110/9112's requirement that the HTTP request authority (host and port) match the val

CVE-2026-8384 MEDIUM
5.3 Jul 14

Eclipse Jetty mishandles HTTP URI path parameters containing semicolons combined with traversal sequences, delivering an

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