Fabio : contournement d'authentification par traversée de chemin (CVE-2026-104099)
Fabio avant 1.7.3 choisit la route sur le chemin brut, donc une variante avec segment de point échappe aux ACL et à l'authentification basique (9,1 Critique).
En bref
- Fabio choisissait une route à partir du chemin brut de la requête, donc une variante avec segment de point ou chemin encodé manquait la route protégée et retombait sur une route moins restrictive.
- Les versions de Fabio antérieures à 1.7.3 sont concernées lorsqu'une route utilise
allow=ouauth=et qu'une autre route atteint le même backend. - La fiche CVE lui attribue un score CVSS v3.1 de 9,1 Critique. Aucune exploitation en conditions réelles n'est connue, et la faille n'est pas dans le catalogue KEV de la CISA au 2026-11-20.
- Mettez à niveau vers 1.7.3 ou une version ultérieure, actuellement 1.8.0, et redémarrez le processus. La mise à niveau est le seul correctif publié.
Suis-je concerné ?
Toutes ces conditions doivent être réunies pour qu'un déploiement Fabio soit exposé :
- Fabio est antérieur à 1.7.3.
- Au moins une route utilise l'option
allow=ouauth=pour restreindre l'accès. - Une route moins restrictive, par exemple une route attrape-tout
/, atteint le même backend, afin que le chemin forgé puisse retomber quelque part. - Le backend normalise le chemin et sert la ressource protégée. La plupart des serveurs HTTP le font.
L'avis énonce clairement la condition préalable : sans route de repli vers le même backend, la requête forgée renvoie 404 au lieu de la page protégée. La forme à deux routes est celle que la documentation de contrôle d'accès de Fabio décrit pour un service protégé derrière une route attrape-tout.
| Branche | Versions concernées | Version corrigée |
|---|---|---|
| 1.7.x et antérieures | Antérieures à 1.7.3 | 1.7.3 |
| 1.8.x | Aucune | 1.8.0 |
Le correctif est sorti dans 1.7.3 le 2026-08-06. La version 1.8.0, publiée le 2026-09-09, le contient aussi. La fiche CVE lui attribue un score CVSS v3.1 de 9,1. Le vecteur est CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N, et les faiblesses sont CWE-41, CWE-289 et CWE-863. L'image officielle fabiolb/fabio comptait 17 273 867 téléchargements Docker Hub au 2026-11-20, et le dépôt comptait 7 345 étoiles.
Vérifiez le binaire en cours d'exécution :
# Binary install
fabio -version
# Docker
docker exec <container> fabio -version
# Kubernetes
kubectl exec deploy/fabio -- fabio -version
La sortie est 1.7.3 go1.x ou la version que vous exécutez. Si vous ne pouvez pas lancer la commande, lisez l'étiquette de l'image ou le nom de la version que vous avez déployée.
Comment corriger ?
Mettez à niveau vers 1.7.3 ou une version ultérieure et redémarrez Fabio. Le correctif modifie la sélection de route, il ne prend donc effet qu'au démarrage du nouveau binaire.
- Téléchargez l'image corrigée et recréez le conteneur :
docker pull fabiolb/fabio:1.8.0
docker stop <container>
docker rm <container>
docker run --name <container> ... fabiolb/fabio:1.8.0
- Pour une installation binaire, téléchargez l'archive de version 1.7.3 ou 1.8.0 pour votre plateforme depuis la page des versions de Fabio, remplacez le binaire et redémarrez le service.
- Pour une installation Go, compilez l'étiquette corrigée :
go install github.com/fabiolb/fabio@v1.8.0
- Confirmez la nouvelle version avec
fabio -version.
Fabio ne publie aucun contournement de configuration pour cette faille. Le correctif normalise le chemin avant la sélection de route. Si vous ne pouvez pas mettre à niveau, placez le contrôle d'accès sur le backend ou sur un proxy frontal qui normalise le chemin avant que Fabio ne le voie. Cela modifie le déploiement et non le code vulnérable.
Quelle est la cause racine ?
Fabio ne normalisait jamais le chemin avant de choisir une route, donc la recherche de route et les contrôles d'accès voyaient le chemin brut tandis que le backend voyait un chemin normalisé. Fabio est un routeur HTTP et TCP qui lit des définitions de routes depuis Consul ou un fichier de propriétés. Chaque route porte des options telles que allow= et auth=, et la table de routage choisit une cible pour l'hôte et le chemin de la requête.
La recherche dans la table de routage utilisait directement req.URL.Path à la ligne 481 de route/table.go dans la version 1.7.2 :
if target = t.lookup(h, req.URL.Path, pick, match); target != nil {
Le proxy HTTP appliquait ensuite les deux contrôles à la cible renvoyée par la recherche, aux lignes 111 et 116 de proxy/http_proxy.go :
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
}
Les deux décisions sont des propriétés de la route sélectionnée. Une requête vers /admin/ sélectionne la route protégée et passe les contrôles ACL et d'authentification basique. Une requête vers /./admin/, /%2e/admin/, //admin/ ou /x/../admin/ ne correspond pas à la route protégée. Elle retombe sur la route attrape-tout /, qui ne porte ni ACL ni authentification. Fabio transmet ensuite le chemin brut à la ligne 142 :
targetURL := &url.URL{
Scheme: t.URL.Scheme,
Host: t.URL.Host,
Path: r.URL.Path,
}
Le backend reçoit /./admin/, le normalise en /admin/ et sert la ressource protégée. La décision de contrôle d'accès a été prise sur une chaîne différente de celle utilisée par le backend.
Comment la faille est-elle exploitée ?
Un attaquant non authentifié demande un chemin protégé avec une variante que le routeur de Fabio n'associe pas à la route protégée.
- L'attaquant identifie une route protégée par
allow=ouauth=et une route moins restrictive qui atteint le même backend. - L'attaquant envoie le chemin protégé avec un segment de point, un point encodé, une double barre oblique ou un segment parent, à l'aide d'un client qui ne normalise pas le chemin.
- La recherche de route de Fabio ne correspond pas à la route protégée, elle sélectionne donc la route attrape-tout sans ACL ni authentification.
- Fabio transmet le chemin non normalisé au backend.
- Le backend normalise le chemin et sert la ressource protégée sans identifiants.
La vérification de l'avis a utilisé curl --path-as-is contre un binaire Fabio réel et une origine locale. Sur une route protégée par authentification basique, /admin/ renvoyait 401 sans identifiants et 200 avec. Les quatre variantes forgées renvoyaient 200 avec la page protégée et sans identifiants. Sur une route protégée par ACL, /admin/ renvoyait 403 et les quatre variantes renvoyaient 200.
La variante exacte dépend des règles de normalisation du backend. Un serveur qui décode %2e avant le routage, ou qui réduit les doubles barres obliques, sert la ressource protégée depuis le chemin forgé. Un serveur qui rejette les segments de point renvoie une erreur, et le contournement échoue pour cette route. L'avis cite les quatre formes comme exemples, pas comme une liste exhaustive.
Comment se déroule l'attaque ?
Un chemin forgé sélectionne une route sans les contrôles d'accès, et le backend le normalise à nouveau vers la ressource protégée.
/./admin/"] --> B["Recherche de route Fabio
sur le chemin brut"] B --> C{"Correspond à la route
/admin/ protégée ?"} C -->|"Non"| D["Route attrape-tout
sans ACL ni authentification"] D --> E["Transmission du chemin brut
au backend"] E --> F["Le backend normalise
en /admin/"] F --> G["Page protégée servie
sans identifiants"]
Que peut faire un attaquant ?
Un attaquant peut atteindre toute route que l'opérateur a protégée avec allow= ou auth= lorsqu'une route moins restrictive atteint le même backend. L'impact est l'exposition de cette route protégée, pas une exécution de code en soi.
- Lire ou utiliser des interfaces administratives que l'opérateur a placées derrière l'ACL ou l'authentification basique de Fabio.
- Atteindre des API ou des tableaux de bord internes supposés inaccessibles depuis Internet.
- Utiliser le contournement comme une étape d'une chaîne lorsque la route protégée a ses propres faiblesses.
- Atteindre une route protégée uniquement par des règles d'adresse source, depuis une adresse que la règle devait exclure.
Le contournement n'a besoin ni d'un compte valide, ni d'une session, ni d'un en-tête forgé. Il a besoin du chemin protégé et d'une forme de chemin que le routeur ne normalise pas.
Pourquoi le correctif fonctionne-t-il ?
Le correctif normalise le chemin avant la sélection de route et transmet le chemin normalisé, afin que la recherche et le backend voient la même chaîne.
Le correctif ajoute une fonction normalizePath et l'appelle avant p.Lookup(r) dans proxy/http_proxy.go :
+ // Normalize Paths before routing.
+ r.URL.Path = normalizePath(r.URL.Path)
+
t := p.Lookup(r)
La fonction analyse le chemin pour résoudre l'encodage en pourcentage, applique path.Clean pour résoudre les segments . et .., et restaure une barre oblique finale que path.Clean supprime :
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
}
Avec le chemin normalisé, /./admin/, /%2e/admin/, //admin/ et /x/../admin/ deviennent tous /admin/ avant la recherche. Ils sélectionnent la route protégée, donc les contrôles ACL et d'authentification basique s'exécutent. Le backend reçoit le même chemin normalisé, il ne peut donc pas servir une ressource différente de celle autorisée par Fabio.
Le correctif ferme le contournement de chemin HTTP décrit par cette CVE. L'avis signale séparément que le chemin du proxy gRPC n'appelle pas les contrôles d'autorisation et que X-Forwarded-Prefix est transmis depuis le client. Ce sont des problèmes différents, et ce correctif ne les modifie pas.
Comment vérifier si j'ai été compromis ?
L'avis ne publie aucun indicateur de compromission, et aucune exploitation en conditions réelles n'est connue.
Un contournement réussi ressemble à une requête normale pour le backend. Cherchez dans les journaux d'accès de Fabio les requêtes vers des préfixes protégés avec des segments de point, des points encodés, des doubles barres obliques ou des segments parents. Comparez-les au journal du backend pour le chemin normalisé :
GET /./admin/GET /%2e/admin/GET //admin/GET /x/../admin/
Une correspondance est une piste, pas une preuve. Des clients légitimes peuvent envoyer des chemins inhabituels, et une requête qui a échoué peut ne laisser aucune trace au-delà du journal d'accès. Si le backend a journalisé un 200 pour une ressource protégée au même moment, examinez la session et l'adresse source.
Chronologie
- 2026-08-06 : Fabio 1.7.3 est publié avec le correctif de normalisation du chemin.
- 2026-09-09 : Fabio 1.8.0 est publié et contient aussi le correctif.
- 2026-11-19 : CVE-2026-104099 est publiée.
- 2026-11-20 : l'avis GitHub GHSA-4hrh-34w3-5ww8 est publié avec l'analyse du défaut et la vérification.
FAQ
Tous les déploiements Fabio sont-ils concernés ?
Non. Fabio doit être antérieur à 1.7.3, une route doit utiliser allow= ou auth=, et une route moins restrictive doit atteindre le même backend. Un déploiement sans contrôle d'accès par route, ou sans route de repli, n'expose pas le contournement décrit par cette CVE.
Un attaquant peut-il l'exploiter sans connaître le chemin protégé ?
Oui, si le chemin protégé est découvrable. L'attaquant a besoin du chemin que l'opérateur a protégé. Les chemins d'administration courants et les chemins exposés dans la documentation ou le JavaScript suffisent.
Existe-t-il une preuve de concept publique ?
Aucun outil d'exploitation public n'est lié. L'avis publie les quatre formes de chemin forgé et les résultats de vérification contre un binaire Fabio réel, ce qui suffit à reproduire le contournement.
Le correctif couvre-t-il le proxy gRPC ?
Non. L'avis note que le chemin du proxy gRPC n'appelle aucun des deux contrôles d'autorisation, un problème distinct. Le correctif 1.7.3 normalise le chemin HTTP ; il n'ajoute pas de contrôles au chemin gRPC.
La mise à niveau change-t-elle la façon dont les chemins sont transmis ?
Oui. Fabio transmet désormais le chemin normalisé, pas le chemin brut. Un backend qui dépendait du chemin brut, y compris de ses segments de point ou de ses doubles barres obliques, voit le chemin nettoyé après la mise à niveau. Testez toute route qui repose sur des formes de chemin inhabituelles avant de déployer la mise à niveau.
Le correctif modifie-t-il les redirections ?
Il le peut. Le chemin de redirection est construit à partir du chemin normalisé après le correctif. Une règle de redirection qui comparait le chemin brut au chemin cible peut désormais voir la forme nettoyée. Vérifiez les routes de redirection après la mise à niveau.
Qu'en est-il de l'interface d'administration et de l'API ?
Ce sont des routes comme les autres. Si elles sont protégées par allow= ou auth= et qu'une route attrape-tout atteint le même backend, elles sont concernées. Si elles sont liées à un écouteur ou à un backend séparé sans route de repli, le chemin forgé renvoie 404.
Le correctif normalise-t-il aussi l'hôte et le chemin ?
Non. Le correctif 1.7.3 normalise le chemin de la requête. L'avis suggère séparément de mettre l'hôte en minuscules et de retirer le port et un point final, mais cela ne fait pas partie de ce correctif. Une règle de route basée sur l'hôte peut encore être contournée par une orthographe d'hôte que le routeur ne normalise pas, ce qui est un problème distinct.
Corrigez Fabio avant le prochain changement de route
Mettez à niveau vers 1.7.3 ou une version ultérieure et testez chaque route protégée après le redémarrage. Le correctif normalise le chemin, donc le backend reçoit une chaîne différente.
Références
- GitHub Advisory Database, GHSA-4hrh-34w3-5ww8, « Fabio: Access-control bypass through unnormalized request paths » : https://github.com/advisories/GHSA-4hrh-34w3-5ww8 (vérifié le 20 novembre 2026)
- CVE Program, CVE-2026-104099 : https://www.cve.org/CVERecord?id=CVE-2026-104099 (vérifié le 20 novembre 2026)
- Fabio, commit de correction f00ce1a446a4b7a3bccbefbb7bfe4a5e0e3fd817 : https://github.com/fabiolb/fabio/commit/f00ce1a446a4b7a3bccbefbb7bfe4a5e0e3fd817 (vérifié le 20 novembre 2026)
- Fabio, version v1.7.3 : https://github.com/fabiolb/fabio/releases/tag/v1.7.3 (vérifié le 20 novembre 2026)
- Fabio, version v1.8.0 : https://github.com/fabiolb/fabio/releases/tag/v1.8.0 (vérifié le 20 novembre 2026)
- Fabio, source vulnérable à v1.7.2,
proxy/http_proxy.go: https://github.com/fabiolb/fabio/blob/v1.7.2/proxy/http_proxy.go (vérifié le 20 novembre 2026) - Fabio, source vulnérable à v1.7.2,
route/table.go: https://github.com/fabiolb/fabio/blob/v1.7.2/route/table.go (vérifié le 20 novembre 2026) - Fabio, source corrigée à v1.7.3,
proxy/http_proxy.go: https://github.com/fabiolb/fabio/blob/v1.7.3/proxy/http_proxy.go (vérifié le 20 novembre 2026) - Documentation Fabio, « Access Control » : https://fabiolb.net/feature/access-control/ (vérifié le 20 novembre 2026)
- Dépôt Fabio : https://github.com/fabiolb/fabio (vérifié le 20 novembre 2026)
- Docker Hub,
fabiolb/fabio: https://hub.docker.com/r/fabiolb/fabio (vérifié le 20 novembre 2026) - Catalogue des vulnérabilités exploitées de la CISA : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 20 novembre 2026)