Fabio Path Traversal Auth Bypass, Fixed in 1.7.3 (CVE-2026-104099)
Fabio before 1.7.3 routes on the raw request path, so dot-segment and encoded variants skip per-route ACLs and basic auth (Critical 9.1).
TL;DR
- Fabio selected a route from the raw request path, so a dot-segment or encoded variant of a protected path missed the protected route and fell through to a less restrictive one.
- Fabio releases before 1.7.3 are affected when a route uses
allow=orauth=and another route reaches the same backend. - The CVE record scores it CVSS v3.1 9.1 Critical. No exploitation in the wild is known, and it is not in CISA KEV as of 2026-11-20.
- Upgrade to 1.7.3 or later, currently 1.8.0, and restart the process. The upgrade is the only published fix.
Am I affected?
All of these conditions must hold for a Fabio deployment to be exposed:
- Fabio is earlier than 1.7.3.
- At least one route uses the per-route
allow=orauth=option to restrict access. - A less restrictive route, such as a catch-all
/route, reaches the same backend, so the crafted path has somewhere to fall through. - The backend normalizes the path and serves the protected resource. Most HTTP servers do.
The advisory states the precondition plainly: without a fallback route that reaches the same backend, the crafted request returns 404 instead of the protected page. The two-route shape is the one Fabio's own access-control documentation describes for a protected service behind a catch-all.
| Branch | Affected versions | Fixed version |
|---|---|---|
| 1.7.x and earlier | Earlier than 1.7.3 | 1.7.3 |
| 1.8.x | None | 1.8.0 |
The fix shipped in 1.7.3 on 2026-08-06. The 1.8.0 release on 2026-09-09 also carries it. The CVE record scores it CVSS v3.1 9.1. The vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N, and the weaknesses are CWE-41, CWE-289 and CWE-863.
The official fabiolb/fabio image had 17,273,867 Docker Hub pulls on 2026-11-20, and the repository had 7,345 stars.
Check the running binary:
# Binary install
fabio -version
# Docker
docker exec <container> fabio -version
# Kubernetes
kubectl exec deploy/fabio -- fabio -version
The output is 1.7.3 go1.x or the release you run. If you cannot run the command, read the image tag or the release name you deployed.
How do I fix it?
Upgrade to 1.7.3 or later and restart Fabio. The fix changes route selection, so it takes effect only after the new binary starts.
- Pull the fixed image and recreate the container:
docker pull fabiolb/fabio:1.8.0
docker stop <container>
docker rm <container>
docker run --name <container> ... fabiolb/fabio:1.8.0
- For a binary install, download the 1.7.3 or 1.8.0 release asset for your platform from the Fabio releases page, replace the binary and restart the service.
- For a Go install, build the fixed tag:
go install github.com/fabiolb/fabio@v1.8.0
- Confirm the new version with
fabio -version.
Fabio publishes no configuration workaround for this flaw. The patch normalizes the path before route selection. If you cannot upgrade, put the access control on the backend or on a front proxy that normalizes the path before Fabio sees it. That changes the deployment rather than the vulnerable code.
What is the root cause?
Fabio never normalized the request path before choosing a route, so the route lookup and the access-control gates saw the raw path while the backend saw a normalized one. Fabio is an HTTP and TCP router that reads route definitions from Consul or a properties file. Each route carries options such as allow= and auth=, and the route table picks a target for the request host and path.
The route table lookup used req.URL.Path directly at route/table.go line 481 in v1.7.2:
if target = t.lookup(h, req.URL.Path, pick, match); target != nil {
The HTTP proxy then applied both gates to the target that lookup returned, at proxy/http_proxy.go lines 111 and 116:
if t.AccessDeniedHTTP(r) {
http.Error(w, "access denied", http.StatusForbidden)
return
}
if !t.Authorized(r, w, p.AuthSchemes) {
http.Error(w, "authorization failed", http.StatusUnauthorized)
return
}
Both decisions are properties of the selected route. A request for /admin/ selects the protected route and gets the ACL and basic-auth checks. A request for /./admin/, /%2e/admin/, //admin/ or /x/../admin/ does not match the protected route. It falls through to the catch-all / route, which carries no ACL and no auth. Fabio then forwards the raw path at line 142:
targetURL := &url.URL{
Scheme: t.URL.Scheme,
Host: t.URL.Host,
Path: r.URL.Path,
}
The backend receives /./admin/, normalizes it to /admin/, and serves the protected resource. The access-control decision was made on a different string from the one the backend used.
How is it exploited?
An unauthenticated attacker requests a protected path with a variant that Fabio's router does not match to the protected route.
- The attacker identifies a route protected by
allow=orauth=and a less restrictive route that reaches the same backend. - The attacker sends the protected path with a dot segment, an encoded dot, a double slash or a parent segment, using a client that does not normalize the path.
- Fabio's route lookup does not match the protected route, so it selects the catch-all route with no ACL and no auth.
- Fabio forwards the un-normalized path to the backend.
- The backend normalizes the path and serves the protected resource without credentials.
The advisory's verification used curl --path-as-is against a live Fabio binary and a local origin. On a basic-auth route, /admin/ returned 401 without credentials and 200 with them. All four crafted variants returned 200 with the protected page and no credentials. On an ACL route, /admin/ returned 403 and the four variants returned 200.
The exact variant depends on the backend's normalization rules. A server that decodes %2e before routing, or that collapses double slashes, serves the protected resource from the crafted path. A server that rejects dot segments returns an error, and the bypass fails for that route. The advisory lists the four forms as examples, not as an exhaustive list.
How does the attack flow?
A crafted path selects a route without the access-control gates, and the backend normalizes it back to the protected resource.
/./admin/"] --> B["Fabio route lookup
on raw path"] B --> C{"Matches protected
/admin/ route?"} C -->|"No"| D["Catch-all route
no ACL, no auth"] D --> E["Forward raw path
to backend"] E --> F["Backend normalizes
to /admin/"] F --> G["Protected page served
without credentials"]
What can an attacker do?
An attacker can reach any route that the operator protected with allow= or auth= when a less restrictive route reaches the same backend. The impact is the exposure of that protected route, not code execution by itself.
- Read or operate administrative interfaces that the operator placed behind Fabio's ACL or basic auth.
- Reach internal APIs or dashboards that were assumed to be unreachable from the internet.
- Use the bypass as one step in a chain when the protected route has its own weaknesses.
- Reach a route that is protected only by source-address rules, from an address the rule was meant to exclude.
The bypass does not need a valid account, a session or a forged header. It needs the protected path and a path form that the router does not normalize.
The advisory demonstrates access to the protected page without credentials. It does not demonstrate code execution, data modification or a complete takeover of Fabio. The impact depends on what the protected route exposes and on whether the backend normalizes the crafted path.
Why does the fix work?
The fix normalizes the path before route selection and forwards the normalized path, so the lookup and the backend see the same string.
The patch adds a normalizePath helper and calls it before p.Lookup(r) in proxy/http_proxy.go:
+ // Normalize Paths before routing.
+ r.URL.Path = normalizePath(r.URL.Path)
+
t := p.Lookup(r)
The helper parses the path to resolve percent-encoding, applies path.Clean to resolve . and .. segments, and restores a trailing slash that path.Clean removes:
func normalizePath(urlPath string) string {
normalizedPath := urlPath
hasTrailingSlash := len(normalizedPath) > 1 && normalizedPath[len(normalizedPath)-1] == '/'
if u, err := url.Parse(urlPath); err == nil {
normalizedPath = u.Path
}
normalizedPath = path.Clean(normalizedPath)
if hasTrailingSlash && normalizedPath != "/" {
normalizedPath += "/"
}
return normalizedPath
}
With the normalized path, /./admin/, /%2e/admin/, //admin/ and /x/../admin/ all become /admin/ before the lookup. They select the protected route, so the ACL and basic-auth gates run. The backend receives the same normalized path, so it cannot serve a different resource from the one Fabio authorized.
The patch closes the HTTP path bypass this CVE describes. The advisory separately notes that the gRPC proxy path does not call the authorization gates and that X-Forwarded-Prefix is passed through from the client. Those are different issues, and this patch does not change them.
How do I check if I was compromised?
The advisory publishes no indicators of compromise, and no exploitation in the wild is known.
A successful bypass looks like a normal request to the backend. Check Fabio's access logs for requests to protected prefixes with dot segments, encoded dots, double slashes or parent segments. Compare them with the backend's log for the normalized path:
GET /./admin/GET /%2e/admin/GET //admin/GET /x/../admin/
A hit is a lead, not proof. Legitimate clients can send unusual paths, and a request that failed may leave no trace beyond the access log. If the backend logged a 200 for a protected resource at the same time, investigate the session and the source address.
Timeline
- 2026-08-06: Fabio 1.7.3 is released with the path normalization fix.
- 2026-09-09: Fabio 1.8.0 is released and also carries the fix.
- 2026-11-19: CVE-2026-104099 is published.
- 2026-11-20: the GitHub advisory GHSA-4hrh-34w3-5ww8 is published with the defect analysis and verification.
FAQ
Does this affect every Fabio deployment?
No. Fabio must be earlier than 1.7.3, a route must use allow= or auth=, and a less restrictive route must reach the same backend. A deployment with no per-route access control, or with no fallback route, does not expose the bypass this CVE describes.
Can an attacker exploit it without knowing the protected path?
Yes, if the protected path is discoverable. The attacker needs the path that the operator protected. Common admin paths and paths exposed in documentation or JavaScript are enough.
Is there a public proof of concept?
No public exploit tool is linked. The advisory publishes the four crafted path forms and the verification results against a live Fabio binary, which is enough to reproduce the bypass.
Does the fix cover the gRPC proxy?
No. The advisory notes that the gRPC proxy path does not call either authorization gate, a separate issue. The 1.7.3 patch normalizes the HTTP path; it does not add gates to the gRPC path.
Does upgrading change how paths are forwarded?
Yes. Fabio now forwards the normalized path, not the raw one. A backend that depended on the raw path, including its dot segments or double slashes, sees the cleaned path after the upgrade. Test any route that relies on unusual path forms before rolling the upgrade out.
Does the fix change redirects?
It can. The redirect path is built from the normalized request path after the fix. A redirect rule that compared the raw path with the target path may now see the cleaned form. Check redirect routes after the upgrade.
What about the admin UI and the API?
They are routes like any other. If they are protected with allow= or auth= and a catch-all route reaches the same backend, they are in scope. If they are bound to a separate listener or backend with no fallback route, the crafted path returns 404.
Does the fix normalize the host as well as the path?
No. The 1.7.3 patch normalizes the request path. The advisory separately suggests lowercasing the host and stripping the port and a trailing dot, but that is not part of this patch. A host-based route rule can still be bypassed by a host spelling the router does not normalize, which is a separate issue.
Patch Fabio before the next route change
Upgrade to 1.7.3 or later and test every protected route after the restart. The fix normalizes the path, so the backend receives a different string from before.
References
- GitHub Advisory Database, GHSA-4hrh-34w3-5ww8, "Fabio: Access-control bypass through unnormalized request paths": https://github.com/advisories/GHSA-4hrh-34w3-5ww8 (checked November 20, 2026)
- CVE Program, CVE-2026-104099: https://www.cve.org/CVERecord?id=CVE-2026-104099 (checked November 20, 2026)
- Fabio, fix commit f00ce1a446a4b7a3bccbefbb7bfe4a5e0e3fd817: https://github.com/fabiolb/fabio/commit/f00ce1a446a4b7a3bccbefbb7bfe4a5e0e3fd817 (checked November 20, 2026)
- Fabio, release v1.7.3: https://github.com/fabiolb/fabio/releases/tag/v1.7.3 (checked November 20, 2026)
- Fabio, release v1.8.0: https://github.com/fabiolb/fabio/releases/tag/v1.8.0 (checked November 20, 2026)
- Fabio, vulnerable source at v1.7.2,
proxy/http_proxy.go: https://github.com/fabiolb/fabio/blob/v1.7.2/proxy/http_proxy.go (checked November 20, 2026) - Fabio, vulnerable source at v1.7.2,
route/table.go: https://github.com/fabiolb/fabio/blob/v1.7.2/route/table.go (checked November 20, 2026) - Fabio, fixed source at v1.7.3,
proxy/http_proxy.go: https://github.com/fabiolb/fabio/blob/v1.7.3/proxy/http_proxy.go (checked November 20, 2026) - Fabio documentation, "Access Control": https://fabiolb.net/feature/access-control/ (checked November 20, 2026)
- Fabio repository: https://github.com/fabiolb/fabio (checked November 20, 2026)
- Docker Hub,
fabiolb/fabio: https://hub.docker.com/r/fabiolb/fabio (checked November 20, 2026) - CISA Known Exploited Vulnerabilities catalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (checked November 20, 2026)