Details
Suggested remedy
In preference order:
- Enforce `readTimeout` on the HTTP/3 path in the handler. Traefik already passes the HTTPS server's handler to
http3.Server, so whenRespondingTimeouts.ReadTimeout > 0it can wrapr.Bodyfor HTTP/3 requests in a reader that enforces the deadline. - Add a request-read deadline upstream in quic-go's
http3.Serverand pass it through. - At minimum, document it. See below — the current documentation does not tell an operator this.
A sketch of option 1
Offered as a description of the shape, not as a patch. I have not built or tested this
against Traefik, and I am not going to present untested code as though I had. If a working,
tested patch would be useful, say so and I will prepare one properly and verify it against
the reproducer above.
Where the HTTP/3 handler is wired up — server_entrypoint_tcp_http3.go, around thehttp3.Server construction — the handler passed in could be wrapped so that, whenReadTimeout is configured, an HTTP/3 request body carries the same deadline the TCP path
gets from SetReadDeadline:
// Roughly: for HTTP/3 requests only, and only when the timeout is set.
if readTimeout > 0 && r.ProtoMajor == 3 && r.Body != nil {
r.Body = deadlineBody(r.Body, readTimeout)
}
The part worth knowing, because it is what makes the approach work rather than merely
look tidy: closing the request body cancels the QUIC stream read. In quic-go,http3's body Close() calls str.CancelRead(...), which unblocks a Read that is
already parked waiting on the client. So a timer that closes the body on expiry bounds
both a client that trickles *and* a client that simply stops sending — the latter being
the case a wrapper that only checks the clock on each returning Read would miss
entirely.
Returning os.ErrDeadlineExceeded from the wrapped Read keeps the failure classified as
a timeout rather than a client abort, which matters for whatever status code and logging
you decide is right.
Two design questions I would not want to answer on your behalf: whether HTTP/3 should reuserespondingTimeouts.readTimeout or get its own setting, and whether enforcement belongs in
the handler wrapper or somewhere closer to the entrypoint. Both are your call.
A documentation issue, separately
Two things in the docs are worth correcting regardless of how the code question is
resolved.
1. The `readTimeout` description carries no protocol qualification. It says "the
maximum duration for reading the entire request, including the body", which is exactly
what an operator relies on. The entrypoint page does note that respondingTimeouts have
"no effect for UDP entryPoints", but that does not cover this case: HTTP/3 here is served
on an HTTP entrypoint with an http3: block, not on a Traefik UDP entrypoint,
which is a separate feature for UDP routers. An operator who adds http3: to their
existing HTTPS entrypoint has not created a UDP entrypoint and has no reason to read that
caveat as applying to them.
2. `SECURITY.md`'s supported-versions table is stale. It lists 3.6.x as supported
and < 3.6.x as unsupported, while 3.7.10 is the current release. Anyone checking whether
their version is in scope before reporting gets a confusing answer.
Impact
Each held request occupies one upstream connection for as long as the client chooses, at
negligible cost to the client, and the same client can open many. Backends with bounded
connection pools are the practical pressure point.
I have not measured a concurrency ceiling on Traefik itself, so I am not asserting
one. If that number matters to your assessment, tell me and I will measure it.
LLM ("AI") use disclosure
Not required by your policy, but stated because it is true and you should be able to
weigh it. I am a penetration tester, not a Go developer. The finding, the attack concept
and the decision to measure the upstream leg rather than the client are mine. An LLM
coding assistant (Claude) built the test harness, ran the matrix, and located the two
source citations; I verified those by hand against the v3.7.10 tag and ran the
reproducer myself. I am a human and I will be the one replying in this thread.
Disclosure
Bishop Fox operates a 90-day disclosure policy, starting the day this is submitted, with
extensions where a fix is in progress. Tell me what you would prefer and I will work to
it.
Environment
- Traefik v3.7.10, official
traefik_v3.7.10_linux_amd64.tar.gz, sha25601811bb12d44f17280550f425f5e3128d6c325f2665c09e67a651ca535f490ce - Kali GNU/Linux (WSL2), kernel 6.6.114.1
- curl 8.19.0 with ngtcp2 1.21.0 / nghttp3 1.15.0### Summary
_Short summary of the problem. Make the impact and severity as clear as possible. For example: An unsafe deserialization vulnerability allows any unauthenticated user to execute arbitrary code on the server._
Details
_Give all details on the vulnerability. Pointing to the incriminated source code is very helpful for the maintainer._
PoC
_Complete instructions, including specific configuration details, to reproduce the vulnerability._
Impact
_What kind of vulnerability is it? Who is impacted?_
</details>
---