Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify Traefik-fronted app with ReplacePathRegex
-
DeliverySend GET /api../admin
-
ExploitMiddleware emits un-normalized /../admin
-
ExecutionBackend normalizes to /admin
-
ImpactReach protected route bypassing auth
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the target Traefik deployment has a ReplacePathRegex middleware configured with a regex that captures user-controlled path segments without a mandatory path separator (the advisory's example: regex "^/api(.*)", replacement "/$1"), AND a backend behind it that normalizes paths (resolving /../ sequences) and hosts a protected route reachable via traversal. Given those, exploitation is remote and unauthenticated (PR:N/UI:N) with low complexity - a single crafted GET request. Limiting factors: deployments that do not use ReplacePathRegex, or that use it with a properly anchored separator (e.g. "^/api/(.*)"), are not exploitable, and backends that reject un-normalized paths (return the request untouched or 400 on /../ ) neutralize the bypass; affected only in Traefik <= v2.11.51, v3.6.0-v3.6.22, and v3.7.0-v3.7.6. |
| Impact | The supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N, VC:N/VI:N/VA:N, SC:H/SI:H/SA:N, base 7.8) is internally consistent with an unauthenticated, network-reachable, low-complexity bypass whose damage lands on the subsequent system (the protected backend) rather than on Traefik itself - hence the vulnerable-system impacts are N while subsequent-system confidentiality and integrity are High. Real-world risk hinges on a specific configuration prerequisite: an exploitable ReplacePathRegex rule, so this is not a blanket 'every Traefik is exploitable' issue. No EPSS score, KEV entry, or POC was provided, so exploitation probability cannot be quantified from the input; however, the advisory publishes a working request pattern, meaning weaponization is low-effort for any attacker who identifies a vulnerable rule. Bottom line: for environments that use ReplacePathRegex in front of authenticated backends this is a high-priority patch; for those that do not, exposure is limited despite the high base score. |
| Exploit ScenarioDerived | An attacker fingerprints an application fronted by Traefik and discovers a route rewritten by ReplacePathRegex (e.g. a public /api/* prefix mapped onto a backend). They send GET /api../admin, causing the middleware to emit /../admin, which the backend normalizes to /admin and serves without the authentication that Traefik would have enforced on the real /admin route. No credentials, user interaction, or special access are needed, and the advisory's published example makes the request pattern immediately reproducible. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 22, 2026
Authentication bypass in the Traefik reverse proxy (v2.11.51 and earlier, v3.6.0-v3.6.22, and v3.7.0-v3.7.6) allows unauthenticated remote attackers to reach protected backend routes by abusing the ReplacePathRegex middleware. When the middleware rewrites a path using a capture group lacking a mandatory separator, a crafted request such as GET /api../admin yields an un-normalized path (/../admin) that the middleware forwards without re-validation; a normalizing backend then resolves it to a protected route, skipping any auth middleware bound to that path. No public exploit identified at time of analysis, and no EPSS/KEV data was supplied, but the flaw is trivially reproducible from the advisory's own example.
RemediationAI
Vendor-released patches are available: upgrade to Traefik v2.11.52, v3.6.23, or v3.7.7 depending on your branch, as documented in advisory GHSA-cxjq-mrr5-89rv (https://github.com/traefik/traefik/security/advisories/GHSA-cxjq-mrr5-89rv). If immediate patching is not possible, audit all ReplacePathRegex middleware definitions and rewrite any rule whose capture group can absorb path bytes without a mandatory separator - for example anchor the regex to require a slash ("^/api/(.*)" with replacement "/$1") so ../ cannot be injected into the rewritten segment, accepting that this changes matching for requests to bare /api. As a compensating control, place authorization/authentication enforcement on the backend against the fully normalized path rather than relying on Traefik path-based routing, and/or add a WAF or rule to reject requests containing dot-dot sequences (e.g. ../ or encoded variants) before they reach the rewrite middleware, noting this may break legitimate paths that contain literal dot sequences. These mitigations reduce but do not fully replace the upstream fix.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 4 packages in go, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Traefik is a widely deployed cloud-native edge router / reverse proxy and Kubernetes ingress controller that routes HTTP traffic to backends and applies middleware chains (auth, rate-limiting, path rewriting). The affected component is the ReplacePathRegex middleware, which rewrites request paths using a Go regular expression and replacement template. The root cause is CWE-22 (Improper Limitation of a Pathname to a Restricted Directory / path traversal): the middleware trusts the regex output and forwards the rewritten path without verifying it equals its own normalized form. A capture like regex "^/api(.*)" with replacement "/$1" pulls user-controlled bytes (including ../ sequences) directly into the outbound path. Because path normalization semantics differ between Traefik and the upstream backend, the mismatch is what enables traversal past routing/authorization boundaries defined earlier in the chain.
Know when Traefik gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
Sources disagree (Medium–Critical)CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N
Remote unauthenticated single-request bypass (AV:N/AC:L/PR:N/UI:N); the proxy grants access to a protected backend, a scope change (S:C) with high confidentiality and integrity impact on that backend and no availability effect.
vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
Traefik versions <= v2.11.51, >= v3.6.0 <= v3.6.22, and >= v3.7.0 <= v3.7.6 contain an authentication bypass via path traversal in the ReplacePathRegex middleware. When ReplacePathRegex is configured with a regex that captures user-controlled path segments without a mandatory path separator (e.g. regex "^/api(.*)", replacement "/$1"), the middleware forwards the replaced path to the backend without validating that it matches its normalized form. An unauthenticated remote attacker can send a crafted request (e.g. GET /api../admin) that produces an un-normalized path such as /../admin, which a backend that normalizes paths resolves to a protected route, bypassing authentication middleware. Fixed in v2.11.52, v3.6.23, and v3.7.7.
Executive ViewAI
Traefik reverse proxy versions 2.11.51 and earlier, 3.6.0-3.6.22, and 3.7.0-3.7.6 contain an authentication bypass vulnerability (CVE-2026-65600) that allows unauthenticated attackers to reach protected backend services by exploiting path processing in the ReplacePathRegex middleware. This vulnerability directly undermines the security perimeter for organizations using Traefik as their primary authentication gateway, creating a direct pathway for unauthorized access to sensitive APIs and applications.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) WAF rules blocking path traversal sequences containing '/../'; (2) network firewall rules restricting backend service access to Traefik instances only; (3) application-level authentication checks independent of reverse proxy routing decisions; (4) detailed audit logging on all protected endpoints to flag bypass attempts; (5) consider deploying an additional API gateway layer with independent authentication validation as defense-in-depth.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
Backend connection hijacking in Traefik reverse proxy (2.11.0 through 2.11.56 and 3.0.0 through 3.7.12) lets an unauthen
HTTP/1 request-target parsing in Traefik prior to 2.11.57 and 3.7.13 allows unauthenticated remote attackers to send a r
Route-level authentication bypass in Traefik v3.7.0-v3.7.7 allows unauthenticated remote attackers to reach backend endp
Traefik is an open source HTTP reverse proxy and load balancer. Rated high severity (CVSS 7.5), this vulnerability is re
types/types.go in Containous Traefik 1.7.x through 1.7.11, when the --api flag is used and the API is publicly reachable
Security middleware bypass in Traefik reverse proxy versions 2.11.26-2.11.56 and 3.4.2-3.7.12 allows unauthenticated net
Traefik's header-security defenses (aliasHeadersStrategy, underscoreHeadersStrategy, forwardedHeaders) inspect req.Heade
Path normalization bypass in Traefik allows unauthenticated remote attackers to circumvent the middleware chain on path-
Traefik is an open source HTTP reverse proxy and load balancer. Rated medium severity (CVSS 6.5), this vulnerability is
Traefik is an open source HTTP reverse proxy and load balancer. Rated medium severity (CVSS 6.5), this vulnerability is
Concurrent HTTP requests to Traefik's BasicAuth middleware can reveal whether a username is configured, because absent u
Same weakness CWE-22 – Path Traversal
View allSame technique Authentication Bypass
View allVendor StatusVendor
SUSE
Severity: Moderate| Product | Status |
|---|---|
| SUSE Linux Enterprise Server 16.1 | Affected |
| SUSE Linux Enterprise Server for SAP applications 16.1 | Affected |
EUVD-2026-47644
GHSA-cxjq-mrr5-89rv
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB