Summary
A connection-isolation flaw in Traefik's HTTP/3 entrypoint can cause backend connections authenticated for one client to be reused by another client.
When a backend uses connection-bound NTLM or Negotiate authentication with keep-alive enabled, an unrelated client may access victim-specific data or act with the victim's authenticated identity.
Affected context
The issue occurs in Traefik deployments that:
- Enable an HTTP/3 entrypoint
- Proxy requests to a backend using connection-bound NTLM or Negotiate authentication
- Permit backend connection reuse through keep-alive
- Rely on frontend connection context to maintain backend authentication isolation
Deployments without these combined conditions may not be exposed to the same connection-reuse behavior.
Exploit preconditions
- Attack surface: HTTP/3 traffic handled by a Traefik entrypoint
- Required access: The ability to send requests through the affected proxy
- Backend requirement: A service using connection-bound NTLM or Negotiate authentication
- Configuration requirement: Backend keep-alive and reusable authenticated connections
- Trigger point: Reuse of a backend connection across distinct frontend clients
- Why exploitation is possible: The proxy may associate a shared backend transport with requests that should use separate per-connection authentication context
Why this happens
The vulnerability results from failing to attach a dedicated backend transport to each HTTP/3 frontend connection. As a result, the authentication-aware round tripper can use a shared transport rather than preserving isolation between client connections.
Connection-bound authentication protocols such as NTLM and Negotiate associate authorization state with a backend connection. Reusing that connection across unrelated clients can therefore cause one client's authenticated identity to be applied to another client's requests. This behavior maps primarily to CWE-287: Improper Authentication and is also related to CWE-863: Incorrect Authorization.
Potential impact
- An attacker may read data available only to another authenticated user
- An attacker could send requests under a victim's authenticated identity
- Confidential information may be disclosed
- Unauthorized actions could be performed against backend services
- Tenant or user isolation may be weakened
- Compromised backend sessions could enable further application-level abuse
General mitigation guidance
Mitigation focuses on preserving authentication-state isolation across frontend connections and reducing reliance on shared connection-bound transports.
Common defensive patterns include:
- Ensure each frontend connection receives an appropriately scoped backend transport when connection-bound authentication is used
- Avoid sharing authenticated backend connections across unrelated users or tenants
- Prefer authentication mechanisms designed for safe proxying and explicit request-level identity handling where practical
- Disable backend keep-alive when connection reuse cannot be safely isolated
- Apply least-privilege authorization at the backend rather than relying solely on proxy session context
- Use secure-by-default HTTP/3 and authentication configuration templates
- Document and enforce policies for connection reuse with NTLM or Negotiate services
- Test authentication boundaries under concurrent, multi-user traffic
How teams detect issues like this
Organizations can look for this issue through:
- Configuration reviews that identify HTTP/3 routes combined with NTLM or Negotiate backends and keep-alive
- Static and policy analysis for shared transport usage in authentication-aware proxy code
- Code review checks verifying that frontend connection context is propagated to backend transport creation
- Integration tests that send concurrent requests from distinct identities and verify response and authorization isolation
- Runtime monitoring for authenticated backend connections serving requests associated with multiple frontend identities
- Automated security review rules that flag connection reuse where authentication state is connection-bound

