HTTP/2 Rapid Reset: cancelling requests faster than the limit counts them

HTTP/2 Rapid Reset, tracked as CVE-2023-44487, abuses a legitimate feature: a client may cancel a request it has just made. Send the request, cancel it at once, repeat. The cancelled stream no longer counts against the server's limit on concurrent streams, but the server may already have spent effort on it.

Section Attacks Updated Primary source RFC 9113

Quick facts

Identifier
CVE-2023-44487, record published 10 October 2023 (CVE Program record)
Protocol
HTTP/2, specified in RFC 9113; the weakness is in how implementations handle a valid feature, not in a malformed message
Layer
Application (7), consuming server work per stream
Vector
Streams opened and cancelled with RST_STREAM in quick succession
Severity score
CVSS 3.1 base score 7.5, High, vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, as recorded by CISA-ADP in the CVE record
Does a WAF stop it?
Not by itself. The abuse happens in stream frames, below the request content a filter inspects. The fix lives in the HTTP/2 implementation and its configuration

The CVE record describes the issue in one sentence: the HTTP/2 protocol allows a denial of service (server resource consumption) because request cancellation can reset many streams quickly, as exploited in the wild in August through October 2023. The rest of this page unpacks that sentence. Background on the identifier itself is on the CVE glossary page.

Streams and the concurrency limit

HTTP/1.1 carries one request at a time on a connection, so a server limits load mostly by limiting connections. HTTP/2 multiplexes many requests over one connection. Each request and its response travel on a separate stream, and the client can have many streams going at once.

To stop one connection from taking over a server, each side can advertise how many streams its peer may have in flight. The setting is SETTINGS_MAX_CONCURRENT_STREAMS. RFC 9113, section 5.1.2, says a peer can limit the number of concurrently active streams with it, and that streams in the "open" state or in either "half-closed" state count toward the maximum. Streams in the "reserved" states do not.

That wording matters for what follows. The limit counts streams that are active. It is a ceiling on how much is in progress at the same moment, which is a reasonable thing to limit when each in-progress request costs memory and a handler.

What a reset changes

A client sometimes changes its mind: the user navigated away, or a script no longer needs the response. HTTP/2 has a frame for that. RST_STREAM, described in section 6.4, is sent to request cancellation of a stream or to indicate an error. Section 6.4 states that it fully terminates the referenced stream and puts it in the "closed" state, and section 5.1 allows either endpoint to send it from the "open" state.

Put the two sections together. A stream that has been reset is closed, and closed streams are not among those counted toward the concurrency limit. A client that opens a stream and resets it immediately never has more than a handful in progress, so the limit never refuses anything. Yet it can keep opening new ones for as long as the connection lasts, at whatever rate the network and the server's reading speed allow.

WHAT THE LIMIT SEES, AND WHAT IT DOES NOT NORMAL CLIENT OPEN AT ONCE STARTED OVERALL RAPID RESET OPEN AT ONCE STARTED OVERALL // bar lengths are schematic, not measurements
// the limit measures what is open, the cost follows what is started

Where the cost lands

A cancelled request is not necessarily a free one. By the time the reset arrives, the server may have decoded the headers, allocated state for the stream, matched a route, and handed the request to application code or to a backend. Cancelling does not unwind that work for you; each implementation decides how much it can skip.

The vendor write-ups describe the effect in their own terms. The Go release announcement says rapid stream resets can cause excessive work in net/http. The Apache Tomcat security page says its HTTP/2 implementation was vulnerable to the rapid reset attack and that the denial of service typically manifested as an OutOfMemoryError. Different servers, different failure: one burns processing, the other runs out of memory.

The shape is the same as other asymmetric attacks. A cancel is a few bytes on the wire, while the work set in motion can be much larger. The sender needs the connection and little else, which is why a modest number of connections is enough and why volume graphs can understate it. Nothing sent is malformed; each frame is something the specification allows.

Disclosure and vendor responses

The CVE Program record was published on 10 October 2023, and several implementers published fixes or statements the same day. The record itself notes exploitation in the wild from August through October 2023.

  • Go. The 10 October 2023 release announcement for Go 1.21.3 and 1.20.10 lists the fix under CVE-2023-39325 and also names CVE-2023-44487. The server now limits the handlers running at once to the stream concurrency limit, queues requests beyond it, and closes the connection if the queue grows too large. The same fix is in golang.org/x/net/http2 v0.17.0.
  • Apache Tomcat. The security page lists the issue as fixed in 10.1.14, dated 10 October 2023, affecting 10.1.0-M1 to 10.1.13 in that branch. Other branches have their own pages.
  • nginx. In a message to the development list on 10 October 2023, a maintainer said nginx is not affected, citing its existing keepalive_requests limit, the concurrent streams limit, and limit_req. The accompanying patch added further limits: new streams per event-loop pass are capped at twice max_concurrent_streams, and refused streams are capped at the larger of that value and 100, so that flooding is detected and the connection dropped sooner.

Those three show the range of responses. One server changed its scheduling, one shipped a version fix, and one said its existing limits held and tightened them anyway. Which applies to you depends on the server and version you actually run, and the advisory for that product is the authority, not this page.

Defences

RFC 9113 does not name this attack, but its denial-of-service section, 10.5, is the general guidance. It says an HTTP/2 connection can demand a greater commitment of resources than an HTTP/1.1 connection, that implementations should track the use of such features and set limits on their use, and that an endpoint can treat suspicious activity as a connection error with the code ENHANCE_YOUR_CALM. The practical measures follow from that, most effective first.

  1. Update the HTTP/2 implementation. The fixes above are version-specific. Check the changelog or advisory of every component that terminates HTTP/2: web server, proxy, language runtime, load balancer, gateway.
  2. Limit the reset rate per connection. Count RST_STREAM frames a client sends within a window, and treat a rate no honest client produces as abuse. The threshold is a judgment call: browsers do reset streams legitimately, so a ceiling set too low drops real users.
  3. Close the connection when the limit is exceeded. Refusing individual streams is not enough if the next one is as cheap to send. Ending the connection removes the sender's channel, and the Go fix does exactly this when its queue grows.
  4. Bound the work an unfinished stream can start. Where the implementation lets you, cap how many handlers or backend calls a single connection can have running, whether or not the streams that started them were cancelled.
  5. Limit requests per connection. Closing a connection after a fixed number of requests, as the keepalive_requests directive does in nginx, caps how long any one sender can keep going.

Cutting off an offending connection raises the cost of the attack from one handshake to a new one, which is the same economic logic described for Slowloris and its relatives on the low and slow page. The overall approach to absorbing application-layer floods is on the DDoS mitigation page.

Where a WAF helps and where it does not

A web application firewall inspects requests: method, path, headers, parameters, body. Rapid Reset is carried in stream-level frames before there is much of a request to inspect, and a stream that is cancelled may never become one the filter sees as a whole. A rule that matches request content has nothing distinctive to match, because the requests being opened can be ordinary ones.

Two things follow, and they are easy to run together.

  • What a filter does not see. Frame-level behaviour on the connection: how many resets arrive per second, how the stream count moves. That is what the defences above act on, and it belongs to whatever speaks HTTP/2 to the client. The activity log records filter decisions on requests, so it will not show reset counts.
  • What a filter can still do. If cancelled requests aim at one expensive path, or at an endpoint that should be rate limited anyway, request-level controls apply to the ones that complete. A rate limit bounds the volume accepted for the domain, and a flood of completed requests is the case covered under HTTP flood. Those controls work on requests that finish, so they are a complement, not an answer to the reset pattern.

This page does not claim that any particular deployment is affected or protected. That depends on which software terminates HTTP/2 for your traffic and what version it runs. If you operate such software, read its advisory first, then use the filter for what it does see.

The three modes apply as everywhere: off inspects nothing, monitor records matches without refusing, block refuses. Start in monitor mode for any new rule so you see what it would have done before it refuses anyone. See what the platform offers at Bridge CDN.

Questions

What is HTTP/2 Rapid Reset?

A denial-of-service technique tracked as CVE-2023-44487. A client opens HTTP/2 streams and cancels them with RST_STREAM straight away, so the server's limit on concurrent streams is never reached while the server may still do work for each request.

Why does the concurrent streams limit not stop it?

RFC 9113 counts streams in the open and half-closed states toward SETTINGS_MAX_CONCURRENT_STREAMS. A stream that has been reset is closed, so it no longer counts, and the client can start another immediately.

When was it disclosed?

The CVE record was published on 10 October 2023, and Go, Apache Tomcat and nginx all published fixes or statements dated that day. The record notes exploitation in the wild from August through October 2023.

How do I defend against it?

Update every component that terminates HTTP/2, limit how many stream resets a connection may send, and close the connection when the limit is exceeded. Capping the work one connection can start and the number of requests per connection also helps. Check the advisory for your own server, since fixes differ.

Can a WAF block Rapid Reset?

Not on its own. A WAF inspects requests, while the abuse is in stream-level frames on the connection. Request-level controls such as rate limits can complement the fix on the HTTP/2 server, but they do not replace it.