Go net/http CVE-2026-78669
HIGHAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessEstablish HTTP/2 connection to target
-
DeliveryOpen large number of streams
-
ExploitFlood small SETTINGS_INITIAL_WINDOW_SIZE frames
-
ExecutionForce O(n) per-stream window recomputation
-
ImpactExhaust CPU causing denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Asymmetric resource consumption control
|
| Exploitation Conditions | The victim must be running a Go net/http or golang.org/x/net HTTP/2 endpoint (server with HTTP/2 enabled - the default for Go servers over TLS - or a Go HTTP/2 client connecting to an attacker-controlled server), in a version predating the O(1) initial-window-size fix tracked in Go issue 81742. No authentication, no user interaction, and no non-default configuration are required beyond HTTP/2 being active. Exploitation is explicitly tied to HTTP/2's stream multiplexing: an attacker needs the ability to open many streams on one connection and send repeated SETTINGS_INITIAL_WINDOW_SIZE updates. Limiting factors: HTTP/1-only deployments are not affected, the impact is confined to CPU/availability (no data compromise), and patched x/net/Go versions neutralize the issue. |
| Impact | CVE-2026-78669 is an algorithmic-complexity denial-of-service in Go's HTTP/2 implementation (golang.org/x/net and net/http): a malicious HTTP/2 peer opens many streams, then sends repeated small SETTINGS frames carrying SETTINGS_INITIAL_WINDOW_SIZE, forcing the victim to recompute per-stream window state in O(number of streams) each time, which burns CPU. No CVSS vector, EPSS score, KEV entry, or POC was supplied in the input, so quantitative exploitation signals are absent and cannot be compared. On the metrics that ARE derivable from the description, this is a classic unauthenticated, network-reachable, low-complexity availability bug (no confidentiality or integrity impact), which my independent assessment scores as High (7.5). The real-world priority is moderate-to-high for exposed Go HTTP/2 services because the trigger is cheap and needs no credentials, but it is a resource-exhaustion issue only - not RCE or data exposure - so it should be patched promptly on internet-facing services yet does not carry the same urgency as a code-execution flaw. IMPORTANT DATA CAVEAT: the two linked articles (the GitHub Go issue #81857 and RyotaK's site) describe CVE-2026-78659 (the Trailer-header memory-exhaustion bug), NOT CVE-2026-78669; the only directly on-point source for 78669 is the oss-security advisory text and Go issue 81742 (reported by Jakub Ciolek). Treat the linked articles as context for a sibling CVE, not as corroboration of this one. |
| Exploit ScenarioDerived | An attacker establishes an HTTP/2 connection to a vulnerable Go server (or lures a vulnerable Go HTTP/2 client to connect to an attacker-controlled server), opens a large number of concurrent streams, and then floods many small SETTINGS frames that change SETTINGS_INITIAL_WINDOW_SIZE. Each change forces the peer to walk every open stream to adjust flow-control windows, driving CPU toward saturation and degrading or denying service. No public exploit code is identified at time of analysis, though the technique is simple and well-described in the advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 08, 2026
Denial of service through CPU exhaustion in Go's HTTP/2 implementation (net/http and golang.org/x/net) lets an unauthenticated remote HTTP/2 peer open many streams and then repeatedly send small SETTINGS frames carrying SETTINGS_INITIAL_WINDOW_SIZE, forcing the victim to recompute per-stream flow-control window state at O(number of streams) for each frame (assessed CVSS 3.1: 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H). Impact is confined to availability - there is no confidentiality or integrity loss - and exposure is limited to Go programs with HTTP/2 active: servers over TLS (the Go default) and Go HTTP/2 clients connecting to an attacker-controlled peer, in versions predating the O(1) initial-window-size fix tracked in Go issue 81742. No public exploit code identified at time of analysis and no confirmed active exploitation (not in CISA KEV); HTTP/1-only deployments are unaffected.
RemediationAI
Apply the upstream fix for Go issue 81742, which converts initial-window-size updates to O(1); upstream fix available (PR/commit), released patched version not independently confirmed, so verify with go list -m all and rebuild against a Go toolchain and golang.org/x/net module version that contain the change, then re-scan dependencies to confirm the vulnerable http2 code is gone. If an immediate upgrade is not possible, disable HTTP/2 on the affected server (GODEBUG=http2server=0, or set Server.TLSNextProto to a non-nil empty map to suppress automatic HTTP/2) - this fully removes exposure but forfeits HTTP/2 multiplexing and its latency benefits, and for Go clients talking to untrusted servers force an HTTP/1.1-only transport. As a partial compensating control, cap concurrent connections and concurrent streams per client and rate-limit or drop excessive SETTINGS frames at an edge proxy or load balancer; this reduces the stream count an attacker can accumulate on a single connection but does not eliminate the per-frame O(n) recomputation, so it is a stopgap only. Because the same HTTP/2 code path carries the related CVE-2026-78659 trailer-header issue and the unassigned double-refund flow-control bug, ensure the adopted Go/x/net release addresses all three (see https://go.dev/issue/81742 and https://seclists.org/oss-sec/2026/q4/102).
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in go
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
HTTP/2 multiplexes many concurrent streams over a single connection and relies on per-stream and connection-level flow-control windows. The SETTINGS_INITIAL_WINDOW_SIZE setting applies to every open stream at once, so any change to it forces the implementation to revisit and adjust window accounting for each existing stream; an attacker who first opens a large number of streams and then sends many small SETTINGS frames with changing initial-window values turns every cheap-looking frame into O(number of streams) work, an algorithmic-complexity amplification that consumes CPU with minimal bandwidth. The fix makes initial-window-size updates O(1) instead of O(streams). The root cause is therefore an uncontrolled-resource-consumption / algorithmic-complexity defect; no CWE identifier was assigned in the provided source data (the record lists CWE: N/A). This CVE is one of three net/http HTTP/2 issues disclosed together in the same oss-security thread and must not be conflated with the others: CVE-2026-78659 covers Trailer-header memory exhaustion that bypasses Server.MaxHeaderValueCount and Server.MaxHeaderBytes, and a third unassigned issue covers a double connection-level flow-control refund on streams that are reset by the client. Each has a distinct root cause, so remediation must cover the full set, including the golang.org/x/net module where the HTTP/2 code also lives.
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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Remotely reachable over HTTP/2 with no credentials or interaction (AV:N/AC:L/PR:N/UI:N); purely a CPU-exhaustion DoS, so C:N/I:N but A:H.
Primary rating from Vendor (CNA).
CVSS VectorVendor
Lifecycle Timeline
2Description PRE-NVD
Technical POC Analysis
Evidence caveat: the supplied source is a gist containing a solve.mjs / hive-mind PR draft log, not the Go patch, advisory, or PoC.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Latest POC
1 public PoC link from github
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
Go's HTTP/2 implementation in net/http and golang.org/x/net can be driven into CPU exhaustion by an unauthenticated remote peer, degrading or knocking offline any Go-built service that speaks HTTP/2 - which by default includes Go servers over TLS and Go clients connecting to untrusted endpoints. Because the flaw sits in the language's standard library and no vendor-released patch exists yet, exposure spans both customer-facing and internal Go applications, and HTTP/2 being enabled by default means many teams are affected without knowing it. Leadership should treat this as a service-availability risk that warrants immediate interim mitigations and a firm commitment to upgrade as soon as a fixed Go release ships.
No vendor-released patch identified at time of analysis. Interim mitigations: front Go HTTP/2 services with a proxy or load balancer that enforces MaxConcurrentStreams and rate-limits SETTINGS frames; disable HTTP/2 (SetTLSNextProto) where it is not required; cap concurrent streams and per-connection resource consumption; apply edge connection and request rate limits; restrict Go HTTP/2 clients to trusted peers; monitor for CPU saturation and stream fan-out; track Go issue 81742 for the O(1) initial-window-size fix and upgrade as soon as a fixed release is available.
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.
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB