Why a backend login cannot shield an HTTP/2 proxy
Learn how HTTP/2 frames reach a reverse proxy before request authentication and which listener settings determine exposure.
An HTTP/2 reverse proxy has to interpret a client’s protocol data before it can apply authentication based on an HTTP request. That makes its connection, frame and stream handling part of the exposed surface: a backend login cannot prevent the proxy from processing traffic that arrives before the login check.
For operators, the important boundary is the listener that accepts the client connection, not just the application behind it. A proxy can accept HTTP/2 from a client and forward HTTP/1.1 to a backend; changing the backend protocol does not by itself remove the proxy’s inbound HTTP/2 processing.
This article explains protocol behavior and a hypothetical implementation flaw, not a verified path to code execution in a particular product.
What does a proxy process before authentication?
A reverse proxy accepts connections on behalf of one or more services. Depending on its configuration, it can terminate TLS, authenticate requests, select a route and forward requests to a backend. The connection to the client and the connection to the backend are separate hops.
The proxy needs enough information from a request to evaluate a request-level policy. For example, a policy checking an Authorization header must first obtain that header. A backend-enforced login is farther downstream: the proxy has to interpret enough of the client’s traffic to forward the request before the backend can reject it.
A conceptual path is:
Client
|
| HTTP/2 connection and frames
v
Reverse proxy: protocol processing -> request fields -> policy and routing
|
v
Backend service
This is a dependency, not a claim that every proxy uses separate modules in precisely this order. A proxy can begin processing a request before its body has finished arriving, and authentication mechanisms can sit at different points in the path.
Some access controls act earlier. A network rule can restrict which hosts reach a listener, and a correctly enforced client-certificate requirement can restrict who completes a TLS handshake. Those boundaries change who can reach the HTTP handler; an ordinary application login does not serve the same function.
How do frames and streams become a request?
HTTP/2, specified in RFC 9113, represents communication as binary frames. A stream is a sequence of frames within a connection; multiple streams can be open concurrently, with their frames interleaved. Stream identifiers tell the receiver which stream a frame belongs to.
Consider a browser requesting /account and /style.css over the same HTTP/2 connection. The proxy associates frames for each exchange with the appropriate stream. It also maintains connection-level state shared across the exchanges. The two requests need not wait for separate client connections, but the receiver must keep their processing distinct.
A request’s fields are carried in a compressed field block. A HEADERS frame can carry the block; if the block is split, CONTINUATION frames carry the remaining fragments. The receiver reassembles and decompresses the block to obtain fields such as the request method, path and authorization data. DATA frames can carry the request body.
Compression introduces state beyond an individual request. RFC 9113 specifies an HPACK encoder and decoder context for field blocks on a connection. It also requires a receiver to process field blocks even when their frames are to be discarded, to keep compression state consistent. The HTTP/2 overview at http.dev describes the frame types, multiplexing and HPACK in more detail.
Stream lifetime is another distinction. Either endpoint can close a stream, and a stream error can be signaled with RST_STREAM without necessarily ending other streams. A connection error is broader: the endpoint terminates the connection. Implementations therefore have to handle both per-stream changes and shared connection state.
Why does that matter for a flaw?
The protocol specifies how an endpoint should handle data; software implements those rules. A defect in that software could cause it to handle a frame, a stream transition or shared state incorrectly. If the relevant code runs before request authentication, rejecting the eventual request is too late to prevent that code from having processed the incoming data.
For a hypothetical example, imagine an implementation that mishandles a stream’s state when the peer closes it. Whether that mistake merely rejects a stream, disrupts the connection or has a more serious effect depends on the actual defect and implementation. HTTP/2 framing alone does not establish the consequences of a particular bug.
This distinction also matters for developers reviewing a proxy. The code that forwards a request is only one part of the path: connection setup, field decompression, stream lifecycle and error handling all process input from the peer. A review or fix tied to a specific defect needs to cover the affected implementation and its reachable call paths, rather than assuming that an application-layer rejection is sufficient.
Which configuration choices determine exposure?
Map every hop between the client and the service. The relevant question is where untrusted traffic reaches the affected implementation, if an advisory identifies one.
| Check | Why it matters |
|---|---|
| Which listeners accept HTTP/2? | A client-facing listener and an internal listener can have different protocol settings and different reachable users. |
| Who can connect? | Public access, network restrictions and required client authentication determine who can reach the listener. An internal listener can still be reachable by other workloads. |
| Where is TLS terminated? | The endpoint terminating TLS receives the decrypted HTTP traffic. If another proxy sits in front, inspect the protocol and access controls on the next hop too. |
| What protocol is used on each hop? | HTTP/2 from client to proxy can coexist with HTTP/1.1 from proxy to backend. A backend-only change does not disable the inbound listener’s HTTP/2 handling. |
| Which implementation handles the connection? | Product version, bundled components, distribution backports and managed-service deployments can affect whether a particular advisory applies. |
To check a reachable HTTPS endpoint, the http.dev guide documents this curl command:
curl --http2 -sS -o /dev/null -D- https://example.re
With a curl build that supports HTTP/2, the response status line indicates whether that request used HTTP/2. The option requests HTTP/2 but can fall back to HTTP/1.1, so inspect the output rather than treating a successful request as proof of HTTP/2. This checks the endpoint reached by that request; it does not identify every internal listener or backend hop.
For a specific vulnerability, use the affected vendor’s advisory to identify fixed builds and supported mitigations. Restricting access or disabling a protocol on a listener can change the exposure, but whether either measure addresses the affected code path is an implementation-specific question. Disabling HTTP/2 also changes client behavior and performance; it is not a repair to the underlying software.
Is this the same as request smuggling or denial of service?
No. Request smuggling concerns disagreement between HTTP components about how to interpret or delimit requests. A proxy translating between HTTP versions is a possible boundary for such disagreements, but that is a different failure mode from a defect in an HTTP/2 stream or frame handler.
Denial-of-service attacks instead exhaust resources or otherwise prevent service. For example, the HTTP/2 overview describes Rapid Reset as repeatedly opening and canceling streams to create server-side overhead. A resource-exhaustion issue does not by itself establish code execution.
The response follows the failure mode: rate or resource controls may be relevant to exhaustion, while translation bugs require attention to how intermediaries interpret requests. For any reported defect, first identify the affected component and reachable listener, then apply the vendor-confirmed fix or mitigation.
Comments ()