Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB
CVE-2026-78660 Overview
CVE-2026-78660 is an HTTP request smuggling vulnerability [CWE-444] in the Go standard library's HTTP/2 implementation. The Go net/http package historically tolerated malformed framing-related headers in HTTP/2 responses because such headers cannot interfere with HTTP/2 framing itself. When a Go server acts as a reverse proxy, however, it can forward those malformed headers to an HTTP/1 downstream client. A lenient HTTP/1 client can then misinterpret the response boundaries, enabling response smuggling attacks. The issue is tracked upstream as Go issue #81115 and advisory GO-2026-6610.
Critical Impact
An attacker controlling an HTTP/2 origin behind a Go-based reverse proxy can inject crafted headers that cause an HTTP/1 client to desynchronize, leading to cache poisoning, credential theft, or request routing manipulation.
Affected Products
- Go standard library net/http and golang.org/x/net/http2 packages
- Applications using Go as an HTTP/2-to-HTTP/1 reverse proxy
- Services downstream of such proxies that implement lenient HTTP/1 parsing
Discovery Timeline
- 2026-10-08 - CVE-2026-78660 published to NVD
- 2026-10-09 - Last updated in NVD database
Technical Details for CVE-2026-78660
Vulnerability Analysis
The vulnerability resides in how Go's HTTP/2 server and client code validate response headers before passing them to an HTTP/1 peer. HTTP/2 uses length-prefixed binary frames, so framing-related headers like Content-Length or Transfer-Encoding are not required for message boundary determination at the HTTP/2 layer. Go's implementation therefore accepted malformed values in these headers without rejection.
When the same Go process acts as a reverse proxy, it translates the HTTP/2 response into HTTP/1 wire format for downstream delivery. Malformed framing headers passed through to the HTTP/1 client cause the client's parser to compute message boundaries differently than the proxy intended. The result is response smuggling, where attacker-supplied bytes bleed into the next response on the connection.
Root Cause
The root cause is insufficient validation of framing-related headers in the HTTP/2 response path, categorized as inconsistent interpretation of HTTP requests [CWE-444]. The code trusted that HTTP/2 framing semantics made header validation unnecessary, without accounting for cross-protocol forwarding scenarios.
Attack Vector
An attacker must control or compromise an HTTP/2 origin server positioned behind a Go-based reverse proxy that fronts HTTP/1 clients. The attacker returns responses containing malformed Content-Length, Transfer-Encoding, or related headers. The Go proxy forwards these headers unchanged to the HTTP/1 client, which parses them permissively and misaligns response boundaries on the shared connection.
No authentication or user interaction is required at the proxy itself. Refer to the Go.dev Issue #81115 and Go.dev Vulnerability Report GO-2026-6610 for upstream technical analysis.
Detection Methods for CVE-2026-78660
Indicators of Compromise
- HTTP/2 responses from upstream origins containing non-conforming Content-Length or Transfer-Encoding header values
- Unexpected response bodies appearing on HTTP/1 connections to downstream clients
- Cache entries containing content that does not match the requested URL
- Reverse proxy logs showing mismatched request and response pairing on keep-alive connections
Detection Strategies
- Enable strict HTTP header validation logging on reverse proxies that bridge HTTP/2 and HTTP/1 traffic
- Compare upstream response byte counts against downstream delivered byte counts to detect boundary drift
- Monitor web application firewall telemetry for responses carrying duplicate or conflicting framing headers
- Audit Go binaries in the environment for use of vulnerable net/http versions referenced in advisory GO-2026-6610
Monitoring Recommendations
- Alert on HTTP/1 downstream connections that receive out-of-order or orphaned response data
- Track Go runtime versions across deployed services and flag versions prior to the fixed releases
- Correlate reverse proxy access logs with origin server logs to identify response desynchronization
How to Mitigate CVE-2026-78660
Immediate Actions Required
- Inventory all Go services acting as HTTP/2 reverse proxies and identify their runtime versions
- Upgrade Go to the fixed release that incorporates the patches from Go.dev Change Log #835145 and Go.dev Change Log #836385
- Rebuild and redeploy all affected binaries, since Go applications statically link the standard library
- Validate that upstream HTTP/2 origins cannot be influenced by untrusted actors
Patch Information
The Go team released fixes referenced in Go changelists 835145 and 836385. Consult the Golang Announce Update for the specific Go release versions containing the fix, and the Go.dev Vulnerability Report GO-2026-6610 for the authoritative vulnerable version ranges.
Workarounds
- Place a strict HTTP/1 parser or hardened reverse proxy between the Go proxy and downstream clients to normalize framing headers
- Terminate HTTP/2 upstream connections to origins you do not fully trust and sanitize response headers before re-emission
- Disable connection reuse (keep-alive) on affected downstream HTTP/1 paths to limit smuggling impact until patching completes
# Verify installed Go toolchain version against the fixed release
go version
# Rebuild and redeploy services after upgrading Go
go build -trimpath -o service ./cmd/service
Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB

