Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeploy malicious app on same domain
-
DeliveryInduce credentialed HttpClient request
-
ExploitReturn redirect to /secure/../evil
-
ExecutionHttpClient skips path normalization
-
PersistAuthorization header sent to /evil
-
ImpactCapture 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
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
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
More in Eclipse Jetty
View allHTTP request smuggling in Eclipse Jetty's HTTP/1.1 parser lets remote unauthenticated attackers desynchronize front-end/
Security-constraint bypass in Eclipse Jetty leaves some request URL patterns unprotected when annotation and deployment-
Unauthenticated remote denial-of-service in Eclipse Jetty's WebSocket implementation allows any network-accessible clien
HTTP/2 thread-exhaustion denial-of-service in Eclipse Jetty allows unauthenticated remote clients to permanently block a
HTTP/1.1 request smuggling in Eclipse Jetty allows unauthenticated remote attackers to desynchronize request boundary pa
Eclipse Jetty's HttpClient can disclose proxy authentication credentials to a malicious server when the server returns a
Privilege escalation in Eclipse Jetty 9.4.0-12.1.7 allows unauthenticated remote attackers to bypass authentication via
Query-parameter injection in Eclipse Jetty's TryPathsHandler and TryFilesFilter allows unauthenticated remote attackers
HTTP/1.1 trailer leakage in Eclipse Jetty allows a remote unauthenticated attacker to read trailer headers from a previo
Eclipse Jetty fails to enforce RFC 9110/9112's requirement that the HTTP request authority (host and port) match the val
Eclipse Jetty mishandles HTTP URI path parameters containing semicolons combined with traversal sequences, delivering an
EUVD-2026-101946
GHSA-j5fg-j6xp-mjwf
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB