GHSA-f5vf-8pvc-394g
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend CONNECT request with non-empty body via proxy
-
DeliveryBackend returns non-2xx keep-alive response
-
ExploitTrailing body bytes desynchronize pooled connection
-
ExecutionVictim request reuses poisoned idle connection
-
ImpactVictim reads attacker-injected response (cross-user poisoning)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service HTTP request consistency
|
| Exploitation Conditions | Exploitation requires a very specific chain, not a default single-request attack: the affected Go service must act as a reverse proxy (e.g. httputil.ReverseProxy) or otherwise forward HTTP/1 CONNECT requests with a non-empty Request.Body through a Transport whose connections are pooled and shared across callers; the upstream server must reject the CONNECT with a non-2xx keep-alive (connection-reuse) response rather than closing the connection; and a subsequent unrelated caller must reuse the now-desynchronized idle connection. Limiting factors that reduce real-world exposure: it applies to HTTP/1 CONNECT handling only (not HTTP/2), it depends on the proxy forwarding CONNECT bodies and on a pooled/shared Transport, it depends on backend keep-alive-on-rejection behavior, and the cross-user impact hinges on connection-pool reuse timing. Deployments that do not proxy CONNECT, do not share Transports across users, or run patched versions (net/http ≥1.26.9 or ≥1.27.2) are not exposed. |
| Impact | Signals are mixed and point to a moderate, configuration-dependent risk rather than a widespread emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, 7.5) frames this as a network-reachable, unauthenticated, low-complexity confidentiality issue, consistent with the CWE-444 (HTTP Request/Response Smuggling) classification and the cross-user response-poisoning described. However, the exploitation-probability signals are uniformly low: EPSS is 0.17% at the 5th percentile, the CVE is NOT on CISA KEV, and no public proof-of-concept is referenced - so the status is 'no public exploit identified at time of analysis.' There is tension between the CVSS AC:L rating and the described mechanics: successful cross-user poisoning requires a specific chain (proxy forwards a CONNECT with a body, backend returns a non-2xx keep-alive response, and the desynchronized connection is then reused by another caller), which in practice carries a race/timing and configuration dependency that argues for higher attack complexity than AC:L suggests. Net assessment: a genuine, patch-worthy defect in an extremely widely used library, but a narrow exploitable condition and low observed exploitation activity make it a prioritize-and-patch item rather than a drop-everything KEV-grade threat. |
| Exploit ScenarioDerived | An attacker sends an HTTP/1 CONNECT request carrying a non-empty body to a Go-based reverse proxy (e.g. httputil.ReverseProxy) that forwards it through a shared http.Transport to a backend. The backend rejects the CONNECT with a non-2xx keep-alive response, so the proxy returns the connection to the idle pool while the trailing body bytes remain buffered as what looks like a pipelined request; the next unrelated user that reuses that pooled connection then receives the response to the attacker-injected request. No public exploit code is referenced, so this is a demonstrated mechanism rather than an observed in-the-wild campaign. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Oct 09, 2026
HTTP/1 connection desynchronization in Go's net/http Transport allows response poisoning for other users of a shared, pooled connection pool. When an outbound HTTP/1 CONNECT request carries a non-empty Request.Body, Transport writes those bytes to the wire unframed after the request headers; if the upstream server rejects the CONNECT with a non-2xx but connection-reusing (keep-alive) response, Transport returns the still-contaminated socket to the idle pool, and the backend may parse the trailing bytes as a pipelined follow-up request. The primary exposure is reverse proxies (including httputil.ReverseProxy) that forward CONNECT through a shared Transport, where the next caller to reuse the desynchronized connection reads the response to the injected request - an unauthenticated remote scenario per the CVSS vector (PR:N), though exploitation requires a specific chain rather than a default single request. No public exploit identified at time of analysis; EPSS is low at 0.17% (5th percentile).
Earlier versions of this analysis (1)
HTTP/1 connection desynchronization in Go's net/http Transport allows cross-user response poisoning in deployments that proxy CONNECT requests over a shared Transport: when Transport sends an HTTP/1 CONNECT request with a non-empty Request.Body, the body is written to the wire unframed, and if the upstream rejects the CONNECT with a non-2xx keep-alive response, the connection is returned to the idle pool still carrying those unread body bytes. The server can then interpret the trailing bytes as a pipelined HTTP/1.1 request, so the next caller that reuses the pooled connection reads the response to the injected request instead of its own. The issues in this release announcement are fixed in Go 1.27.2 and Go 1.26.9; no public exploit identified at time of analysis, and the input contains no EPSS score, KEV listing, or POC reference. Exposure is limited to reverse proxies (including httputil.ReverseProxy) that forward CONNECT through a shared Transport and talk to upstreams that answer a rejected CONNECT with a non-2xx keep-alive response, per our independent assessment (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:H/A:N).
RemediationAI
The vendor-released patch is Go 1.26.9 (for the 1.26.x line) and Go 1.27.2 (for the 1.27.x line); upgrading the toolchain and rebuilding all Go binaries - including the affected net/http and net/http/httputil code paths - is the only complete fix, since Go compiles the standard library statically into each binary and container base images must also be refreshed. Follow https://pkg.go.dev/vuln/GO-2026-6605 and the upstream fix commit at https://go.dev/cl/847306, with coordination details in https://seclists.org/oss-sec/2026/q4/101 and https://go.dev/issue/81740. If immediate rebuild is not possible, enforceable compensating controls are: (1) never populate Request.Body on outbound CONNECT requests - CONNECT has no defined body, and removing the body eliminates the unframed trailing bytes that seed the desynchronization, at the cost of changing any non-standard forwarding logic that relies on that body; (2) stop sharing one pooled Transport across users in CONNECT-proxying services by using per-user or per-tenant Transports, or set DisableKeepAlives on the CONNECT-forwarding Transport so rejected connections are closed rather than pooled - this removes the cross-user reuse primitive but increases connection churn and TLS/handshake overhead; (3) on the upstream/backend side, ensure servers close the connection (Connection: close) when rejecting a CONNECT with a non-2xx status, which prevents the contaminated socket from ever re-entering the idle pool; and (4) restrict or disable inbound CONNECT proxying at the edge for services that do not require it. Note that these are partial mitigations - the underlying framing bug remains until the patched toolchain is deployed.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 3 packages in go, 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 a classic HTTP request-smuggling/desynchronization class issue (CWE-444, Inconsistent Interpretation of HTTP Requests) inside Go's standard-library HTTP client stack, specifically the packages net/http and net/http/httputil - the libraries that provide http.Transport connection pooling and the ReverseProxy handler. Under HTTP/1.1, a CONNECT request has no body by definition; the origin-form framing rules (Content-Length / Transfer-Encoding) that normally delimit a message body do not apply to a CONNECT tunnel request, so a server receiving trailing bytes after the CONNECT headers will treat them as the start of the next, pipelined HTTP/1.1 request on that same persistent connection. Go's Transport nevertheless serializes any non-empty Request.Body after the headers without framing, and - critically - when the server responds with a non-2xx status but keeps the connection alive, Transport treats the exchange as complete and returns the connection to its idle pool rather than discarding it. Any bytes already written therefore survive into the pooled socket, creating a parser-state mismatch between what Go believes it sent and what the backend believes it received. Because Transport pools and shares connections across callers, a subsequent unrelated request assigned to that socket can receive the response generated by the smuggled request, producing cross-user response poisoning (including cache-poisoning style effects in proxy deployments). The affected version ranges reported by EUVD are net/http 0 to <1.26.9 and net/http 1.27.0-0 to <1.27.2, with the same ranges for net/http/httputil. The issue is confined to HTTP/1 CONNECT handling and does not apply to HTTP/2, which uses a framed multiplexed protocol and has no equivalent pipelining surface.
Know when Golang 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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
Network and unauthenticated (AV:N/PR:N); AC:H because success needs a backend keep-alive rejection plus pooled-connection reuse timing; S:C and C:H/I:H because injected/poisoned responses cross into other users' request streams.
Primary rating from Vendor (CNA).
CVSS VectorVendor
Lifecycle Timeline
2Description PRE-NVD
Executive ViewAI
A defect in Go's standard net/http Transport lets an outbound HTTP/1 CONNECT request with a body leave stray bytes on a pooled socket, which is then returned to the shared pool and can be misread as a follow-up request by the upstream server. The practical exposure sits in reverse proxies such as httputil.ReverseProxy that forward CONNECT over a shared Transport pool, meaning one caller's traffic can contaminate the responses another caller receives, an unauthenticated remote scenario per the CVSS vector. Leadership should care because affected services are typically multi-tenant gateways where response poisoning can cross customer or team boundaries and undermine trust in the proxy layer.
Apply vendor patch.
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
HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
The SSH transport protocol with certain OpenSSH extensions, found in OpenSSH before 9.6 and other products, allows remot
The net/http package in Go through 1.6 does not attempt to address RFC 3875 section 4.1.18 namespace conflicts and there
Erugo file-sharing platform up to version 0.2.14 has a CVSS 10.0 path traversal allowing authenticated users to read any
Critical certificate validation bypass in Go crypto/tls during session resumption. If ClientCAs or RootCAs fields are mu
WAGO PFC200 G2 PLC (firmware affected) allows privilege escalation through cookie manipulation. Users can modify cookie
Authentication bypass in WeGIA charitable institution management system before 3.6.5. The adicionar_tipo_docs_atendido.p
CGI path splitting vulnerability in FrankenPHP before 1.11.2 — Unicode characters bypass path validation during CGI proc
net/url in Go before 1.11.13 and 1.12.x before 1.12.8 mishandles malformed hosts in URLs, leading to an authorization by
Free5gc NRF 1.4.0 has an authorization bypass in access token generation that allows authenticated users to request toke
Algo 8028 Control Panel version 3.3.3 contains a command injection vulnerability in the fm-data.lua endpoint that allows
Denial of service in PocketBase versions prior to 0.22.48 (0.22.x branch) and 0.23.0 through 0.39.6 (0.23.0+ branch) all
EUVD-2026-95421
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB