Automated Threat Modeling

Overview of CVE-2026-130732: Traefik NTLM and Negotiate Header Backend Transport Leak

A brief summary of CVE-2026-130732, a resource leak in Traefik 2.11 and 3.7 where unauthenticated NTLM or Negotiate Authorization headers cause the proxy to create dedicated backend transports that it never releases. Includes a short review of the upstream patch and the fixed versions.

CVE Analysis

7 min read

Gaurav Sarraf
Gaurav Sarraf

2026-11-18

Overview of CVE-2026-130732: Traefik NTLM and Negotiate Header Backend Transport Leak

Introduction

In recent Traefik 2.11 and 3.7 releases, a single Authorization header using the NTLM or Negotiate scheme was enough to make the proxy set aside a dedicated backend transport that it never cleaned up. Repeated across many short-lived connections, that leak lets an unauthenticated client steadily drain proxy memory, file descriptors and backend connections, even on deployments that have no NTLM or Kerberos backends at all.

Traefik Proxy is an open-source, MIT-licensed HTTP reverse proxy and load balancer. It integrates dynamically with infrastructure and service registries and handles routing, load balancing, authentication and certificate management. Traefik Labs reports more than 3.5 billion downloads, more than 65,000 GitHub stars and more than 1,000 contributors (vendor-published figures). Traefik commonly sits at the edge of container and cloud-native platforms, so an availability flaw in it affects every service routed behind it.

The vendor advisory GHSA-xv5x-242w-7hf7 rates the issue CVSS 3.1 7.5: network attack vector, low complexity, no privileges, no user interaction, high availability impact, and no confidentiality or integrity impact. The identifiers do not fully line up. The GHSA page states "No known CVE", while VulDB and Rapid7 publish the issue as CVE-2026-130732. The CVE description also mentions only the 2.11 range, whereas the advisory and the Traefik release notes cover the 3.7 line as well.

The sources we reviewed do not report exploitation in the wild, and Rapid7 notes the CVE is not in the CISA KEV catalog.

Technical information

Why NTLM and Negotiate need pinned connections

NTLM and Negotiate (Kerberos) authenticate the TCP connection, not the individual HTTP request. A reverse proxy forwarding these schemes therefore has to pin each client connection to one dedicated backend connection, or the authenticated state would be lost between requests. Traefik does this by storing a stickyRoundTrippers holder in the client connection context through AddTransportOnContext.

Root cause

Since 2.11.58 and 3.7.14, Traefik fills that holder as soon as it sees an Authorization: NTLM ... or Authorization: Negotiate ... header. It does not check whether the header carries a valid credential, and it does not wait for a backend challenge. The holder was never emptied. Per the advisory, the dedicated transport, its idle backend connection and its associated goroutines "are not released when the client connection closes."

Two details amplify the leak:

  • Each dedicated pool has its own limits, so the global maxIdleConnsPerHost setting does not cap them. Backend sockets pile up until the idle timeout eventually closes them.
  • The behavior does not depend on configuration. The advisory states it applies whether or not NTLM or Kerberos backends are configured.

The same flaw exists in FastProxy, the alternative proxy engine in Traefik v3, which keeps its own per-connection stickyConnPools. Hijacked connections were a second path. A connection taken over by a WebSocket-style upgrade never reports StateClosed, so it would leak in the same way.

The advisory maps the issue to CWE 400 (Uncontrolled Resource Consumption) and CWE 772 (Missing Release of Resource after Effective Lifetime). The Traefik release announcement describes the immediate consequence as memory exhaustion.

Attack flow

Based on the advisory, the attack looks like this:

  1. The attacker identifies any Traefik entrypoint running an affected version. No credentials, valid NTLM tokens or Kerberos infrastructure are needed.
  2. The attacker opens a client connection and sends a request with an Authorization header using the NTLM or Negotiate scheme. The value does not need to be valid.
  3. Traefik allocates a dedicated backend transport for that client connection and opens a backend connection through it.
  4. The attacker closes the client connection. The dedicated transport, the idle backend connection and the goroutines remain allocated.
  5. Repeating steps 2 through 4 with many short-lived connections accumulates leaked resources outside the normal maxIdleConnsPerHost limit, exhausting Traefik memory, file descriptors and backend connections.

The regression tests in the fix use exactly this kind of unauthenticated header:

Authorization: NTLM TlRMTVNTUAAB

Patch information

Traefik fixed the issue in v2.11.61 and v3.7.17, both published on October 30, 2026. Both release notes list the advisory under "CVE fixed". Julien Salleyron (@juliens) wrote the fix, and it landed as two pull requests:

The patch does not remove the eager allocation. Instead, it ties the lifetime of the dedicated transport to the client connection, in three parts.

1. A release method that closes idle backend connections

In pkg/server/service/roundtripper.go, stickyRoundTrippers gains a release() method plus an exported helper:

func (s *stickyRoundTrippers) release() { s.mu.Lock() defer s.mu.Unlock() for _, roundTripper := range s.roundTrippers { if closer, ok := roundTripper.(interface{ CloseIdleConnections() }); ok { closer.CloseIdleConnections() } } s.roundTrippers = nil } func ReleaseTransportOnContext(ctx context.Context) { if connRoundTrippers, ok := ctx.Value(transportKey).(*stickyRoundTrippers); ok { connRoundTrippers.release() } }

That type assertion would have silently done nothing for Traefik's smartRoundTripper, which selects between HTTP/1.1, HTTP/2 and h2c, because it lacked the method. smart_roundtripper.go therefore gains one that forwards the call to all three inner transports:

func (m *smartRoundTripper) CloseIdleConnections() { m.http2.CloseIdleConnections() m.http.CloseIdleConnections() m.h2c.CloseIdleConnections() }

2. Tracking each connection context

Go's http.Server.ConnState hook only receives the net.Conn, but pinned transports are only reachable through the connection context. A new connContexts type in pkg/server/conncontext.go maps net.Conn to context.Context behind a mutex. Its remove() method returns and deletes the entry in one step, so resources for a given connection are released only once.

3. Releasing from the connection lifecycle hooks

In server_entrypoint_tcp.go, the ConnContext callback records every new connection with transportConnContexts.add(ctx, c). The ConnState hook previously existed only when connection debugging was enabled. It is now always installed and releases the transport on a terminal state:

connState := func(c net.Conn, state http.ConnState) { // A hijacked connection never reports the closed state, and serves no further request. if state == http.StateClosed || state == http.StateHijacked { if ctx, ok := transportConnContexts.remove(c); ok { service.ReleaseTransportOnContext(ctx) } }

Handling StateHijacked closes the upgrade path described earlier. HTTP/3 (QUIC) connections do not go through ConnState, so server_entrypoint_tcp_http3.go uses context.AfterFunc(c.Context(), …) to run the release when the QUIC connection context is canceled.

FastProxy (v3.7.17 only)

PR #14158 repeats the design in pkg/proxy/fast/connpool.go. It adds stickyConnPools.release(), the exported ReleaseConnPoolsOnContext(), and a closeIdleConns() method on connPool that drains idle connections, marks each one broken and closes it. A closed connection is put back into the pool rather than discarded. Per the code comment, a concurrent AcquireConn may be waiting for the connection it just dialed, and if it receives the closed one it sees the connection is stale and dials again. Both lifecycle hooks then make one extra call:

kerberos.ReleaseTransportOnContext(ctx) + fast.ReleaseConnPoolsOnContext(ctx)

In the v3 code the round tripper helper lives in a kerberos package. In v2.11 it is service.ReleaseTransportOnContext.

Tests and known limits

The regression tests count open backend sockets through the backend's own ConnState hook, send Authorization: NTLM TlRMTVNTUAAB, and check that the backend connection count returns to zero after the client connection is closed or hijacked. They run with and without FastProxy, and with HTTP/2 enabled and disabled. They also verify that releasing a context with no pinned transport does not panic.

The patch has two documented limits:

  • A request with an NTLM or Negotiate header still gets a dedicated transport. The fix guarantees the transport is freed when the client goes away, but it does not prevent its creation.
  • PR #14158 notes that if a backend connection is still in use when the client disconnects, it returns to the pool after the release and is only closed at the idle timeout.

The advisory provides no temporary workaround beyond the patched releases, so we cannot point to an equivalent configuration change or filtering rule.

Affected systems and versions

  • Traefik 2.11.58 through 2.11.60 (fixed in 2.11.61)
  • Traefik 3.7.14 through 3.7.16 (fixed in 3.7.17), including the FastProxy engine
  • Traefik 3.6 and earlier are not affected by this advisory

Any request carrying an Authorization header with the NTLM or Negotiate scheme triggers the vulnerable behavior, whether or not NTLM or Kerberos backends are configured.

References

Detect & fix
what others miss

Works with
  • GitHub
  • GitLab
  • Bitbucket
  • Azure DevOps Services
  • Gerrit
  • CVS
  • Jira
  • Linear
  • Slack
  • Security Compass
Explore integrations
Security magnifying glass visualization