Firecracker : fuite de secrets MMDS via le contournement de la rédaction des journaux de l'API
Firecracker ne masque les corps MMDS que pour le chemin exact /mmds ; /mmds/ et //mmds atteignent le gestionnaire et écrivent les secrets dans le journal.
En bref
- Firecracker écrit en clair le corps des écritures MMDS lorsque le chemin de la requête n'est pas exactement
/mmds. Une barre oblique finale ou une double barre oblique atteint le gestionnaire MMDS et contourne la rédaction. - Les versions concernées vont de v0.20.0 à v1.18.0. Le correctif est sur main depuis le 10 novembre 2026, mais aucune version étiquetée ne le contient au 17 novembre.
- L'audit d'Ostorlab classe l'exposition comme élevée. Aucune CVE n'est attribuée, aucune attaque n'est signalée et la faille n'est pas dans le KEV de la CISA au 17 novembre 2026.
- Compilez depuis main au commit
21bf99a, ou démarrez Firecracker avecumask 077et un répertoire de journaux privé, puis renouvelez tout secret écrit dans MMDS. Voir « Comment corriger ? ».
Suis-je concerné ?
Vous êtes exposé lorsque toutes ces conditions sont réunies :
- Vous exécutez une version auto-hébergée de Firecracker de v0.20.0 à v1.18.0. Ostorlab a vérifié la rédaction à correspondance exacte aux versions v0.20.0, v0.25.0, v1.0.0, v1.5.0, v1.10.0, v1.12.0, v1.14.0, v1.15.0, v1.16.0, v1.17.0 et v1.18.0.
- Un agent hôte ou un opérateur écrit des secrets dans MMDS avec
PUT /mmdsouPATCH /mmds, et au moins une écriture utilise une cible non canonique comme/mmds/,//mmdsouPATCH /mmds/. - Firecracker écrit son journal d'API dans un fichier qu'un autre principal local peut lire. Le fichier est créé avec le mode
0666moins l'umask du processus, donc l'umask 022courant donne0644. - Cet autre principal ne peut pas se connecter à la socket de l'API. La socket est liée avec le mode
0777moins l'umask, soit0755avecumask 022, et la connexion exige la permission d'écriture.
Si MMDS ne contient que des données publiques, la fuite n'expose rien de sensible. S'il contient des identifiants, des jetons d'amorçage ou d'autres secrets, le lecteur obtient les mêmes valeurs que l'invité. La faille n'est pas distante et ne franchit pas la frontière de l'invité. C'est une lecture locale sur l'hôte d'un journal écrit par l'hôte.
| Ligne de version | Versions concernées | Version corrigée |
|---|---|---|
| Dernière | v1.18.0 | Aucune étiquetée ; main après le commit 21bf99a (2026-11-10) |
| Antérieures | v0.20.0 à v1.17.0, vérifiées en v0.20.0, v0.25.0, v1.0.0, v1.5.0, v1.10.0, v1.12.0, v1.14.0, v1.15.0, v1.16.0 et v1.17.0 | Aucune étiquetée |
| Héritées | Avant v0.20.0 | Non testées |
Vérifiez la version qui tourne sur l'hôte :
firecracker --version
Vérifiez les modes du journal et de la socket. Remplacez les chemins par ceux de votre fichier d'unité ou de votre lanceur :
FC_LOG=/var/log/firecracker/firecracker.log
FC_SOCK=/run/firecracker/firecracker.sock
stat -c '%a %U:%G %n' "$FC_LOG" "$FC_SOCK"
Un mode de journal 644 ou 664 signifie que des utilisateurs locaux autres que le propriétaire de Firecracker peuvent le lire. Un mode de socket 755 signifie qu'ils ne peuvent pas se connecter. Vérifiez chaque répertoire du chemin du journal avec namei -l "$FC_LOG".
Cherchez les écritures MMDS dans l'agent hôte ou le code d'orchestration :
grep -R "mmds" /path/to/host-agent /etc/systemd/system 2>/dev/null
Comment corriger ?
Aucune version étiquetée ne contient le correctif au 17 novembre 2026. Firecracker a fusionné le correctif dans main le 10 novembre 2026, au commit 21bf99a, via la demande de fusion #6406. Compilez depuis ce commit, ou attendez la prochaine version et vérifiez que son journal des modifications cite la demande #6406.
-
Compilez Firecracker depuis le commit du correctif. La compilation exige libseccomp 2.6 ou ultérieur.
git clone https://github.com/firecracker-microvm/firecracker.git cd firecracker git checkout 21bf99a31c0c1b81b0c634c676bdccafba8712fa cargo build --release -p firecracker -
Si vous ne pouvez pas recompiler tout de suite, démarrez Firecracker avec un umask privé et un répertoire de journaux dans lequel seul l'utilisateur de Firecracker peut entrer. Dans une unité systemd, réglez
UMask=0077et exécutez le service sous son propre utilisateur.umask 077 install -d -m 0700 /var/log/firecracker chmod 600 /var/log/firecracker/firecracker.log -
Renouvelez chaque secret écrit dans MMDS sur un hôte concerné, et révoquez les anciennes valeurs à la source. Un secret qui a pu être lu reste compromis après la mise à jour.
- Utilisez le jailer lorsque c'est possible. Il exécute Firecracker dans un chroot privé, et Ostorlab a vérifié que le chroot bloque la lecture par un autre utilisateur. Le jailer n'aide pas si votre pipeline de journaux copie le fichier hors du chroot.
- Corrigez les chemins MMDS non canoniques dans l'agent de gestion comme défense en profondeur. Ne comptez pas sur ce changement, car une mise à jour d'un client peut réintroduire le chemin.
Le contournement par umask n'affecte que les nouveaux fichiers. Un journal 0644 existant reste lisible jusqu'à ce que vous changiez son mode. Si un collecteur de journaux lit le fichier, les permissions et le stockage du collecteur décident qui peut lire les secrets après l'expédition.
Le correctif ne masque que les corps MMDS. Les autres points de terminaison écrivent toujours le corps de leurs requêtes au niveau Info, donc un secret envoyé à un autre point de terminaison peut encore atteindre le journal.
Quelle est la cause racine ?
Firecracker décide de la rédaction du journal sur la cible brute de la requête, mais route sur un jeton de chemin normalisé. Toute cible dont le premier jeton est mmds mais dont l'orthographe brute n'est pas /mmds atteint le gestionnaire et est journalisée avec son corps.
Firecracker est un moniteur de machine virtuelle open source écrit en Rust. Amazon Web Services l'a développé pour accélérer des services comme AWS Lambda et AWS Fargate, et des moteurs de conteneurs comme Kata Containers et Flintlock l'intègrent. Un processus hôte contrôle chaque microVM via une API HTTP sur une socket de domaine Unix.
MMDS est le microVM Metadata Service, un magasin de données modifiable partagé entre l'hôte et l'invité. Il est facultatif et doit être configuré sur une interface réseau.
Le guide utilisateur de Firecracker utilise une clé d'accès secrète comme exemple de rotation des identifiants. L'hôte écrit la clé avec PUT /mmds, et l'invité la lit depuis le service de métadonnées. Le même magasin peut contenir des jetons d'amorçage et d'autres paramètres par VM.
Le serveur d'API lit la cible telle quelle. get_abs_path() renvoie la cible brute inchangée, y compris une chaîne de requête. La description du journal est construite à partir de cette chaîne avant l'exécution du routeur :
// src/firecracker/src/api_server/parsed_request.rs:71-83 (v1.18.0)
let request_uri = request.uri().get_abs_path().to_string();
let description = describe(
request.method(),
request_uri.as_str(),
request.body.as_ref(),
);
info_unrestricted!("The API server received a {description}.");
// Split request uri by '/' by doing:
// 1. Trim starting '/' characters
// 2. Splitting by '/'
let mut path_tokens = request_uri.trim_start_matches('/').split_terminator('/');
let path = path_tokens.next().unwrap_or("");
describe() a une branche de rédaction pour MMDS. Elle teste la chaîne brute contre le littéral exact "/mmds" :
// src/firecracker/src/api_server/parsed_request.rs:257-275 (v1.18.0)
fn describe(method: Method, path: &str, body: Option<&Body>) -> String {
match (path, body) {
("/mmds", Some(_)) | (_, None) => format!("{:?} request on {:?}", method, path),
("/cpu-config", Some(payload_value)) => {
// ...
}
(_, Some(payload_value)) => describe_with_body(method, path, payload_value),
}
}
Tout autre chemin avec un corps tombe dans describe_with_body(), qui ajoute le corps UTF-8 à la ligne. La ligne est émise avec info_unrestricted! avant le routage, au niveau Info par défaut, et contourne le limiteur de débit.
Le routage normalise séparément. Il supprime toutes les barres obliques initiales, découpe le reste sur / et prend le premier jeton. /mmds/, //mmds et ///mmds/// produisent tous le jeton mmds. Le répartiteur fait correspondre ce jeton et appelle parse_put_mmds() ou parse_patch_mmds(), donc la requête renvoie 204 No Content et les métadonnées sont appliquées.
Le mode du fichier complète l'exposition. open_file_nonblock() ouvre le journal avec create, read et write, sans mode explicite, donc le noyau applique 0666 moins l'umask.
La socket de l'API est liée sans chmod, donc le même umask lui donne 0777 moins l'umask. Avec l'umask 022 courant, le journal est 0644 et la socket 0755. Un utilisateur local peut lire le journal mais pas ouvrir la socket, car la connexion à une socket Unix exige la permission d'écriture.
Comment la faille est-elle exploitée ?
Un utilisateur local lit une ligne de journal qui contient un secret MMDS, après qu'un agent hôte a écrit ce secret via un chemin MMDS non canonique.
- L'attaquant obtient un compte local non privilégié sur l'hôte Firecracker. Le compte n'a pas besoin d'accéder à la socket de l'API.
- Un agent hôte ou un opérateur écrit des secrets dans MMDS. Si l'écriture utilise
/mmds/ou//mmdsau lieu de/mmds, le serveur d'API l'envoie au vrai gestionnaire MMDS. - Avant le routage,
describe()échoue au test de correspondance exacte et appelledescribe_with_body(). La ligne est écrite au niveauInfodans un fichier de mode0644. - Le routeur normalise la cible, fait correspondre le jeton
mmds, applique les métadonnées et renvoie204. - L'utilisateur local lit le journal, extrait le corps et récupère la clé d'accès, le jeton de session ou le secret d'amorçage.
- L'utilisateur présente l'identifiant récupéré au service qu'il protège, par exemple un stockage d'objets ou un plan de contrôle.
Le reproducteur public d'Ostorlab envoie la matrice de requêtes avec curl --path-as-is, car un client qui normalise le chemin masque la faille :
curl -sS --path-as-is --unix-socket "$FC_SOCK" -X PUT http://localhost/mmds \
-H 'Content-Type: application/json' -d '{"k":"REDACTED-MARKER"}'
curl -sS --path-as-is --unix-socket "$FC_SOCK" -X PUT http://localhost/mmds/ \
-H 'Content-Type: application/json' \
-d '{"access_key_id":"AKIAIOSFODNN7EXAMPLE","secret_access_key":"OSTORLAB-MMDS-MARKER-9F3A2"}'
curl -sS --path-as-is --unix-socket "$FC_SOCK" -X PUT http://localhost//mmds \
-H 'Content-Type: application/json' -d '{"x":"DBLSLASH-MARKER"}'
La première requête renvoie 204 et son corps est masqué. La deuxième et la troisième renvoient 204 et leurs corps apparaissent dans le journal. Les lignes de journal reproduites sont :
The API server received a Put request on "/mmds". <- redacted
The API server received a Put request on "/mmds/" with body "{\"access_key_id\":\"AKIAIOSFODNN7EXAMPLE\",\"secret_access_key\":\"OSTORLAB-MMDS-MARKER-9F3A2\"}".
The API server received a Put request on "//mmds" with body "{\"x\":\"DBLSLASH-MARKER\"}".
La même exécution a journalisé un corps PATCH /mmds/ et un corps PUT /mmds/config. La requête PUT /mmds/config a renvoyé 400 après l'écriture de son corps.
Lors du contrôle entre principaux, un second utilisateur local a lu le marqueur dans le journal 0644 et a reçu PermissionError: [Errno 13] Permission denied en se connectant à la socket 0755. Avec umask 077, le journal était 0600 et la lecture par le second utilisateur a échoué.
Comment se déroule l'attaque ?
Une écriture de l'hôte vers un chemin MMDS non canonique échappe à la rédaction à correspondance exacte. Elle atteint le gestionnaire MMDS et laisse le secret dans un journal qu'un utilisateur local peut lire.
avec PUT /mmds/"] --> B["Le serveur d'API lit
la cible brute"] B --> C["describe() ne correspond
qu'au /mmds exact"] C --> D["Le corps est écrit
dans le journal au niveau Info"] B --> E["Le routeur normalise
le premier jeton en mmds"] E --> F["Le gestionnaire MMDS applique
les métadonnées, renvoie 204"] D --> G["Un utilisateur local lit
le journal 0644"] G --> H["L'identifiant sert contre
le service qu'il protège"]
Que peut faire un attaquant ?
Un utilisateur local qui peut lire le journal de Firecracker peut récupérer le document MMDS complet ou une mise à jour incrémentale, y compris des identifiants que l'hôte destinait uniquement à l'invité. L'impact dépend de ce que ces identifiants ouvrent, par exemple un stockage d'objets, un plan de contrôle ou un service d'amorçage.
Chaque condition fait partie de l'impact :
- L'attaquant a besoin d'un compte local sur l'hôte et d'un accès en lecture au fichier de journal ou au système qui le stocke.
- MMDS doit être utilisé, et une écriture de l'hôte doit transporter un secret via un chemin dont le premier jeton est
mmdsmais dont l'orthographe brute n'est pas/mmds. - Le journal doit être lisible au-delà de l'utilisateur de Firecracker. L'
umask 022produit ce résultat ; l'umask 077et le chroot privé du jailer non. - L'attaquant n'a pas besoin de se connecter à la socket de l'API, et l'invité n'est pas impliqué.
Ostorlab a démontré la lecture avec un second utilisateur local sur une compilation auto-hébergée. Les travaux n'ont pas testé les services gérés par AWS et n'affirment rien à leur sujet. Un invité qui reçoit déjà les métadonnées n'est pas l'attaquant dans ce chemin. La fuite déplace le secret du plan de contrôle de l'hôte vers un journal de l'hôte, où un autre principal peut le lire.
Pourquoi le correctif fonctionne-t-il ?
Le correctif décide de la rédaction sur le même premier jeton normalisé que le routeur, donc chaque orthographe qui atteint le gestionnaire MMDS est masquée avant l'écriture de la ligne.
Le correctif calcule d'abord le jeton de chemin, le transmet à describe() et fait correspondre "mmds" au lieu de "/mmds" :
@@ -69,12 +69,6 @@ impl TryFrom<&Request> for ParsedRequest {
fn try_from(request: &Request) -> Result<Self, Self::Error> {
let request_uri = request.uri().get_abs_path().to_string();
- let description = describe(
- request.method(),
- request_uri.as_str(),
- request.body.as_ref(),
- );
- info_unrestricted!("The API server received a {description}.");
// Split request uri by '/' by doing:
@@ -82,6 +76,14 @@ impl TryFrom<&Request> for ParsedRequest {
let mut path_tokens = request_uri.trim_start_matches('/').split_terminator('/');
let path = path_tokens.next().unwrap_or("");
+ let description = describe(
+ request.method(),
+ request_uri.as_str(),
+ path,
+ request.body.as_ref(),
+ );
+ info_unrestricted!("The API server received a {description}.");
+
match (request.method(), path, request.body.as_ref()) {
@@ -251,25 +253,26 @@ impl ParsedRequest {
-fn describe(method: Method, path: &str, body: Option<&Body>) -> String {
+fn describe(method: Method, uri: &str, path: &str, body: Option<&Body>) -> String {
match (path, body) {
- ("/mmds", Some(_)) | (_, None) => format!("{:?} request on {:?}", method, path),
- ("/cpu-config", Some(payload_value)) => {
+ ("mmds", Some(_)) | (_, None) => format!("{:?} request on {:?}", method, uri),
+ ("cpu-config", Some(payload_value)) => {
Le correctif ajoute un test unitaire qui vérifie que le corps est supprimé pour /mmds, /mmds/, //mmds et ///mmds///. Il ajoute aussi un test d'intégration qui envoie ///mmds/ et ///mmds// directement à la socket, vérifie 204 et 400, et affirme que le secret est absent du journal.
Le correctif est complet pour les chemins dont le premier jeton est exactement mmds. Il ne déplace pas la ligne de journal après le routage, donc une requête qui échoue au routage écrit quand même son corps.
La revue de la demande de fusion a noté que PUT /mmds?x=1 et PUT /MMDS produisent encore une ligne de corps avant que le serveur renvoie 400. Ces orthographes n'atteignent pas MMDS, mais le corps reste sensible. Les autres points de terminaison conservent aussi leur journalisation de corps au niveau Info.
Comment vérifier si j'ai été compromis ?
Aucune campagne d'exploitation ni indicateur de compromission n'est public. Le contrôle est local : cherchez des lignes de corps MMDS dans le journal de Firecracker, et un journal que d'autres utilisateurs peuvent lire.
sudo grep -Ei 'received a (put|patch) request on "[^"]*mmds[^"]*" with body' /var/log/firecracker/firecracker.log
Une correspondance est une requête dont le chemin contenait mmds et dont le corps a été écrit dans le journal. Un PUT /mmds légitime n'a pas de corps dans la ligne, donc une correspondance indique un chemin non canonique ou rejeté. Traitez une correspondance comme une piste, pas comme une preuve de compromission, car la ligne montre seulement que la requête a été journalisée.
Vérifiez le mode du fichier et de son répertoire :
namei -l /var/log/firecracker/firecracker.log
stat -c '%a %U:%G %n' /var/log/firecracker/firecracker.log
Vérifiez le stockage central des journaux si un collecteur transfère le fichier, et cherchez le même motif. Cherchez les écritures MMDS dans la configuration de l'agent hôte pour savoir quels secrets ont pu être journalisés :
grep -R "mmds" /path/to/host-agent /etc/systemd/system 2>/dev/null
Si une correspondance ou un mode de journal trop large est présent, traitez chaque secret écrit dans MMDS sur cet hôte comme exposé et renouvelez-le. Une requête qui échoue au routage peut quand même laisser une ligne de corps, car la compilation vulnérable journalise avant de router.
Chronologie
- 2026-10-14 : Ostorlab vérifie le contournement sur main et trouve le même code à correspondance exacte dans l'arbre.
- 2026-11-09 : Firecracker publie v1.18.0. La version précède le correctif d'un jour et contient encore la faille.
- 2026-11-09 : Le mainteneur de Firecracker Ilias Stamatis ouvre la demande de fusion #6406 avec une rédaction basée sur le jeton et des tests.
- 2026-11-10 : La demande de fusion est fusionnée dans main au commit
21bf99a. - 2026-11-17 : Aucune version étiquetée ne contient le correctif. Aucune CVE n'est attribuée et la faille n'est pas dans le KEV de la CISA.
FAQ
Existe-t-il une CVE pour cette faille ?
Non. Firecracker a fusionné le correctif sans CVE, et aucun enregistrement pour cette faille n'existe dans la NVD ou la base d'avis GitHub au 17 novembre 2026. La demande de fusion publique est le dossier technique.
Cela affecte-t-il AWS Lambda ou AWS Fargate ?
Ostorlab n'a pas testé les services gérés par AWS, et cet article n'affirme rien à leur sujet. La classe concernée est celle des déploiements Firecracker auto-hébergés où un principal local peut lire le journal du VMM.
Un invité de VM peut-il exploiter cette faille ?
Non. L'invité peut déjà lire les métadonnées par conception. La fuite est côté hôte : un utilisateur local lit le journal de l'hôte, et l'invité ne fait pas partie du chemin.
Quelles versions sont corrigées ?
Aucune version étiquetée au 17 novembre 2026. Le commit 21bf99a sur main contient le correctif, et v1.18.0, publié le 9 novembre, ne le contient pas. Compilez depuis main ou attendez une version qui cite la demande #6406.
Le journal est-il toujours lisible par tous ?
Non. Le fichier vaut 0666 moins l'umask. L'umask 022 courant donne 0644, lisible par tous les utilisateurs locaux. L'umask 077 donne 0600, et le chroot privé du jailer bloque aussi la lecture. Un collecteur de journaux peut élargir l'audience après avoir copié le fichier.
Le correctif empêche-t-il tout corps MMDS d'atteindre le journal ?
Il arrête les chemins dont le premier jeton est exactement mmds. Une orthographe rejetée comme /mmds?x=1 ou /MMDS écrit encore son corps avant que le serveur renvoie 400, et les autres points de terminaison journalisent toujours leurs corps au niveau Info.
La faille est-elle exploitée dans la nature ?
Aucune attaque n'est signalée au 17 novembre 2026. Le catalogue KEV de la CISA ne liste pas Firecracker, et la faille n'a aucune CVE qui pourrait y figurer.
Références
- Ostorlab Research, « Firecracker API server logs MMDS request bodies in cleartext for non-canonical request targets », finding-001, la reproduction, le contrôle entre principaux et le commit concerné : https://github.com/Ostorlab/Research/tree/main/0-Day-Hunting/firecracker/finding-001 (vérifié le 17 novembre 2026)
- Ostorlab Research, « AWS Firecracker Vulnerability Audit and CVE Merit Evaluation (Scan 216217) », la notation élevée et l'analyse de la cause racine : https://github.com/Ostorlab/Research/blob/main/0-Day-Hunting/firecracker/scan-216217-audit-report.md (vérifié le 17 novembre 2026)
- Demande de fusion Firecracker #6406, « api: Redact MMDS bodies on all paths reaching MMDS », ouverte le 9 novembre 2026 et fusionnée le 10 novembre 2026 : https://github.com/firecracker-microvm/firecracker/pull/6406 (vérifié le 17 novembre 2026)
- Commit Firecracker
21bf99a31c0c1b81b0c634c676bdccafba8712fa, le correctif et ses tests : https://github.com/firecracker-microvm/firecracker/commit/21bf99a31c0c1b81b0c634c676bdccafba8712fa (vérifié le 17 novembre 2026) - Version Firecracker v1.18.0, publiée le 9 novembre 2026 : https://github.com/firecracker-microvm/firecracker/releases/tag/v1.18.0 (vérifié le 17 novembre 2026)
- Source Firecracker à v1.18.0,
src/firecracker/src/api_server/parsed_request.rs, le code de journalisation et de routage : https://github.com/firecracker-microvm/firecracker/blob/v1.18.0/src/firecracker/src/api_server/parsed_request.rs (vérifié le 17 novembre 2026) - Source Firecracker à v0.20.0,
src/api_server/src/parsed_request.rs, la même branche de rédaction à correspondance exacte : https://github.com/firecracker-microvm/firecracker/blob/v0.20.0/src/api_server/src/parsed_request.rs (vérifié le 17 novembre 2026) - Source Firecracker à v1.18.0,
src/vmm/src/utils/mod.rs,open_file_nonblock(): https://github.com/firecracker-microvm/firecracker/blob/v1.18.0/src/vmm/src/utils/mod.rs (vérifié le 17 novembre 2026) - Source Firecracker à v1.18.0,
src/vmm/src/logger/logging.rs, le niveauInfopar défaut : https://github.com/firecracker-microvm/firecracker/blob/v1.18.0/src/vmm/src/logger/logging.rs (vérifié le 17 novembre 2026) - Guide utilisateur MMDS de Firecracker, l'exemple de rotation d'identifiant : https://github.com/firecracker-microvm/firecracker/blob/v1.18.0/docs/mmds/mmds-user-guide.md (vérifié le 17 novembre 2026)
- README de Firecracker, les usages AWS Lambda, AWS Fargate, Kata Containers et Flintlock : https://github.com/firecracker-microvm/firecracker/blob/v1.18.0/README.md (vérifié le 17 novembre 2026)
- micro-http à la révision
7975fe0e59000e8c41cb1d58fbd39ffa102e5b27,src/request.rs,get_abs_path()renvoie la cible inchangée : https://github.com/firecracker-microvm/micro-http/blob/7975fe0e59000e8c41cb1d58fbd39ffa102e5b27/src/request.rs (vérifié le 17 novembre 2026) - Flux JSON du catalogue des vulnérabilités exploitées de la CISA, vérifié pour une entrée Firecracker le 17 novembre 2026 (aucune) : https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json (vérifié le 17 novembre 2026)
- Recherche par mot-clé Firecracker dans la NVD, vérifiée pour une nouvelle CVE le 17 novembre 2026 (aucune pour cette faille) : https://nvd.nist.gov/vuln/search/results?query=firecracker (vérifié le 17 novembre 2026)