Firecracker MMDS Secret Leak via API Log Redaction Bypass
Firecracker redacts MMDS request bodies only for the exact path /mmds; /mmds/ and //mmds reach the handler and write secrets to the host log.
TL;DR
- Firecracker logs the body of MMDS writes in cleartext when the request path is not exactly
/mmds. A trailing slash or a double slash reaches the MMDS handler and bypasses the redaction. - Releases v0.20.0 through v1.18.0 are affected. The fix has been on main since November 10, 2026, but no tagged release contains it as of November 17.
- Ostorlab's audit rates the exposure High. No CVE is assigned, no attacks are reported, and the flaw is not in CISA KEV as of November 17, 2026.
- Build from main at commit
21bf99a, or start Firecracker withumask 077and a private log directory, and rotate any secret that was written to MMDS. See "How do I fix it?".
Am I affected?
You are exposed when all of these hold:
- You run a self-hosted Firecracker release from v0.20.0 through v1.18.0. Ostorlab verified the exact-match redaction at 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 and v1.18.0.
- A host agent or operator writes secrets to MMDS with
PUT /mmdsorPATCH /mmds, and at least one write uses a non-canonical target such as/mmds/,//mmdsorPATCH /mmds/. - Firecracker writes its API log to a file that another local principal can read. The file is created with mode
0666minus the process umask, so the commonumask 022gives0644. - That other principal cannot connect to the API socket. The socket is bound with mode
0777minus the umask, or0755underumask 022, and connecting needs write permission.
If MMDS carries only public data, the leak exposes nothing sensitive. If it carries credentials, bootstrap tokens or other secrets, the reader gets the same values the guest uses. The flaw is not remote and does not cross the guest boundary. It is a host-local read of a log written by the host.
| Release line | Affected versions | Fixed version |
|---|---|---|
| Latest | v1.18.0 | None tagged; main after commit 21bf99a (2026-11-10) |
| Earlier | v0.20.0 through v1.17.0, verified at 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 and v1.17.0 | None tagged |
| Legacy | Before v0.20.0 | Not tested |
Check the version that runs on the host:
firecracker --version
Check the log and socket modes. Replace the paths with the ones in your unit file or launcher:
FC_LOG=/var/log/firecracker/firecracker.log
FC_SOCK=/run/firecracker/firecracker.sock
stat -c '%a %U:%G %n' "$FC_LOG" "$FC_SOCK"
A log mode of 644 or 664 means local users other than the Firecracker owner can read it. A socket mode of 755 means they cannot connect. Check every directory on the log path with namei -l "$FC_LOG".
Find writes to MMDS in the host agent or orchestration code:
grep -R "mmds" /path/to/host-agent /etc/systemd/system 2>/dev/null
How do I fix it?
No tagged release contains the fix as of November 17, 2026. Firecracker merged the patch into main on November 10, 2026, in commit 21bf99a, through pull request #6406. Build from that commit, or wait for the next release and confirm its changelog names PR #6406.
-
Build Firecracker from the fix commit. The build needs libseccomp 2.6 or later.
git clone https://github.com/firecracker-microvm/firecracker.git cd firecracker git checkout 21bf99a31c0c1b81b0c634c676bdccafba8712fa cargo build --release -p firecracker -
If you cannot rebuild yet, start Firecracker with a private umask and a log directory that only the Firecracker user can enter. In a systemd unit, set
UMask=0077and run the service under its own user.umask 077 install -d -m 0700 /var/log/firecracker chmod 600 /var/log/firecracker/firecracker.log -
Rotate every secret that was written to MMDS on an affected host, and revoke the old values at the source. A secret that may have been read stays compromised after the upgrade.
- Use the jailer where you can. It runs Firecracker in a private chroot, and Ostorlab verified that the chroot blocks the cross-user read. The jailer does not help if your log pipeline copies the file outside the chroot.
- Fix non-canonical MMDS paths in the management agent as defense in depth. Do not rely on that change, because one client update can reintroduce the path.
The umask workaround only affects new files. An existing 0644 log stays readable until you change its mode. If a log shipper reads the file, the shipper's permissions and storage decide who can read the secrets after shipping.
The patch redacts MMDS bodies only. Other endpoints still log their request bodies at Info, so a secret sent to a different endpoint can still reach the log.
What is the root cause?
Firecracker decides log redaction on the raw request target, but routes on a normalized path token. Any target whose first token is mmds but whose raw spelling is not /mmds reaches the handler and is logged with its body.
Firecracker is an open-source virtual machine monitor written in Rust. Amazon Web Services developed it to accelerate services such as AWS Lambda and AWS Fargate, and container runtimes such as Kata Containers and Flintlock embed it. A host process controls each microVM through an HTTP API on a Unix domain socket.
MMDS is the microVM Metadata Service, a mutable data store shared between the host and the guest. It is optional and must be configured on a network interface. The Firecracker user guide uses a secret access key as its credential-rotation example: the host writes the key with PUT /mmds, and the guest reads it from the metadata service. The same store can hold bootstrap tokens and other per-VM configuration.
The API server reads the target verbatim. get_abs_path() returns the origin-form target unchanged, including a query string. The log description is built from that string before the router runs:
// 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() has a redaction arm for MMDS. It tests the raw string against the exact literal "/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),
}
}
Every other path with a body falls to describe_with_body(), which appends the UTF-8 body to the line. The line is emitted with info_unrestricted! before routing, at the default Info level, and bypasses the rate limiter.
Routing normalizes separately. It trims every leading slash, splits the remainder on /, and takes the first token. /mmds/, //mmds and ///mmds/// all produce the token mmds. The dispatcher matches that token and calls parse_put_mmds() or parse_patch_mmds(), so the request returns 204 No Content and the metadata is applied.
The file mode completes the exposure. open_file_nonblock() opens the log with create, read and write, and no explicit mode, so the kernel applies 0666 minus the umask.
The API socket is bound without a chmod, so the same umask gives it 0777 minus the umask. Under the common umask 022, the log is 0644 and the socket is 0755. A local user can read the log but cannot open the socket, because connecting to a Unix socket needs write permission.
How is it exploited?
A local user reads a log line that holds an MMDS secret, after a host agent writes that secret through a non-canonical MMDS path.
- The attacker gets an unprivileged local account on the Firecracker host. The account does not need access to the API socket.
- A host agent or operator writes secrets to MMDS. If the write uses
/mmds/or//mmdsinstead of/mmds, the API server sends it to the real MMDS handler. - Before routing,
describe()fails the exact-match test and callsdescribe_with_body(). The line is written atInfoto a file with mode0644. - The router normalizes the target, matches the
mmdstoken, applies the metadata and returns204. - The local user reads the log, extracts the body and recovers the access key, session token or bootstrap secret.
- The user presents the recovered credential to the service it protects, for example an object store or a control plane.
The public reproducer from Ostorlab sends the request matrix with curl --path-as-is, because a client that normalizes the path hides the bug:
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"}'
The first request returns 204 and its body is redacted. The second and third return 204 and their bodies appear in the log. The reproduced log lines are:
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\"}".
The same run logged a PATCH /mmds/ body and a PUT /mmds/config body; the PUT /mmds/config request returned 400 after its body was written. In the cross-principal check, a second local user read the marker from the 0644 log and received PermissionError: [Errno 13] Permission denied when connecting to the 0755 socket. Under umask 077 the log was 0600 and the second user's read failed.
How does the attack flow?
A host write to a non-canonical MMDS path slips past the exact-match redaction, reaches the MMDS handler, and leaves the secret in a log that a local user can read.
with PUT /mmds/"] --> B["API server reads
the raw target"] B --> C["describe() matches only
the exact /mmds"] C --> D["Body written to the log
at Info"] B --> E["Router normalizes
the first token to mmds"] E --> F["MMDS handler applies
the metadata, returns 204"] D --> G["Local user reads
the 0644 log"] G --> H["Credential used against
the service it protects"]
What can an attacker do?
A local user who can read the Firecracker log can recover the full MMDS document or an incremental update, including credentials that the host intended only for the guest. The impact depends on what those credentials unlock, such as an object store, a control plane or a bootstrap service.
Every condition is part of the impact:
- The attacker needs a local account on the host and read access to the log file or the system that stores it.
- MMDS must be in use, and a host write must carry a secret through a path whose first token is
mmdsbut whose raw spelling is not/mmds. - The log must be readable beyond the Firecracker user.
umask 022gives that result;umask 077and the jailer's private chroot do not. - The attacker does not need to connect to the API socket, and the guest is not involved.
Ostorlab demonstrated the read with a second local user on a self-hosted build. The work did not test AWS-managed services, and it makes no claim about them. A guest that already receives the metadata is not the attacker in this path. The leak moves the secret from the host's control plane into a host log, where a different principal can read it.
Why does the fix work?
The fix decides redaction on the same normalized first token that the router uses, so every spelling that reaches the MMDS handler is redacted before the line is written.
The patch computes the path token first, passes it to describe(), and matches "mmds" instead of "/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)) => {
The patch adds a unit test that asserts the body is dropped for /mmds, /mmds/, //mmds and ///mmds///. It also adds an integration test that sends ///mmds/ and ///mmds// directly to the socket, checks for 204 and 400, and asserts that the secret is absent from the log.
The fix is complete for paths whose first token is exactly mmds. It does not move the log line after routing, so a request that fails routing still writes its body.
The pull request review noted that PUT /mmds?x=1 and PUT /MMDS still produce a body line before the server returns 400. Those spellings do not reach MMDS, but the body is still sensitive. Other endpoints also keep their current body logging at Info.
How do I check if I was compromised?
No exploitation campaign or indicators of compromise are public. The check is local: look for MMDS body lines in the Firecracker log, and for a log that other users can read.
sudo grep -Ei 'received a (put|patch) request on "[^"]*mmds[^"]*" with body' /var/log/firecracker/firecracker.log
A hit is a request whose path contained mmds and whose body was written to the log. A legitimate PUT /mmds has no body in the line, so a hit points to a non-canonical path or a rejected path. Treat a hit as a lead, not as proof of compromise, because the line shows only that the request was logged.
Check the file mode and its directory:
namei -l /var/log/firecracker/firecracker.log
stat -c '%a %U:%G %n' /var/log/firecracker/firecracker.log
Check the central log store if a shipper forwards the file, and search it for the same pattern. Search the host agent's configuration for MMDS writes so you know which secrets could have been logged:
grep -R "mmds" /path/to/host-agent /etc/systemd/system 2>/dev/null
If a hit or a broad log mode is present, treat every secret that was written to MMDS on that host as exposed and rotate it. A request that fails routing can still leave a body line, because the vulnerable build logs before it routes.
Timeline
- 2026-10-14: Ostorlab verifies the bypass on main and finds the same exact-match code in the tree.
- 2026-11-09: Firecracker releases v1.18.0. The release is one day before the fix and still contains the flaw.
- 2026-11-09: Firecracker maintainer Ilias Stamatis opens pull request #6406 with a token-based redaction and tests.
- 2026-11-10: The pull request merges into main as commit
21bf99a. - 2026-11-17: No tagged release contains the fix. No CVE is assigned and the flaw is not in CISA KEV.
FAQ
Is there a CVE for this flaw?
No. Firecracker merged the fix without a CVE, and no record for this flaw exists in NVD or the GitHub Advisory Database as of November 17, 2026. The public pull request is the technical record.
Does it affect AWS Lambda or AWS Fargate?
Ostorlab did not test AWS-managed services, and this writeup makes no claim about them. The affected class is self-hosted Firecracker deployments where a local principal can read the VMM log.
Can a guest VM exploit this?
No. The guest can already read the metadata by design. The leak is on the host: a local user reads the host log, and the guest is not part of the path.
Which versions are fixed?
None as a tagged release as of November 17, 2026. Commit 21bf99a on main contains the fix, and v1.18.0, released on November 9, does not. Build from main or wait for a release that names PR #6406.
Is the log always world-readable?
No. The file is 0666 minus the umask. The common umask 022 gives 0644, which is readable by every local user. umask 077 gives 0600, and the jailer's private chroot also blocks the read. A log shipper can widen the audience after it copies the file.
Does the fix stop every MMDS body from reaching the log?
It stops paths whose first token is exactly mmds. A rejected spelling such as /mmds?x=1 or /MMDS still writes its body before the server returns 400, and other endpoints still log their bodies at Info.
Is it exploited in the wild?
No attacks are reported as of November 17, 2026. The CISA KEV catalog does not list Firecracker, and the flaw has no CVE that could appear there.
References
- Ostorlab Research, "Firecracker API server logs MMDS request bodies in cleartext for non-canonical request targets", finding-001, the reproduction, the cross-principal check and the affected commit: https://github.com/Ostorlab/Research/tree/main/0-Day-Hunting/firecracker/finding-001 (checked November 17, 2026)
- Ostorlab Research, "AWS Firecracker Vulnerability Audit and CVE Merit Evaluation (Scan 216217)", the High rating and the root-cause analysis: https://github.com/Ostorlab/Research/blob/main/0-Day-Hunting/firecracker/scan-216217-audit-report.md (checked November 17, 2026)
- Firecracker pull request #6406, "api: Redact MMDS bodies on all paths reaching MMDS", opened November 9, 2026 and merged November 10, 2026: https://github.com/firecracker-microvm/firecracker/pull/6406 (checked November 17, 2026)
- Firecracker commit
21bf99a31c0c1b81b0c634c676bdccafba8712fa, the fix and its tests: https://github.com/firecracker-microvm/firecracker/commit/21bf99a31c0c1b81b0c634c676bdccafba8712fa (checked November 17, 2026) - Firecracker v1.18.0 release, published November 9, 2026: https://github.com/firecracker-microvm/firecracker/releases/tag/v1.18.0 (checked November 17, 2026)
- Firecracker source at v1.18.0,
src/firecracker/src/api_server/parsed_request.rs, the logging and routing code: https://github.com/firecracker-microvm/firecracker/blob/v1.18.0/src/firecracker/src/api_server/parsed_request.rs (checked November 17, 2026) - Firecracker source at v0.20.0,
src/api_server/src/parsed_request.rs, the same exact-match redaction arm: https://github.com/firecracker-microvm/firecracker/blob/v0.20.0/src/api_server/src/parsed_request.rs (checked November 17, 2026) - Firecracker source at 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 (checked November 17, 2026) - Firecracker source at v1.18.0,
src/vmm/src/logger/logging.rs, the defaultInfolevel: https://github.com/firecracker-microvm/firecracker/blob/v1.18.0/src/vmm/src/logger/logging.rs (checked November 17, 2026) - Firecracker MMDS user guide, the credential-rotation example: https://github.com/firecracker-microvm/firecracker/blob/v1.18.0/docs/mmds/mmds-user-guide.md (checked November 17, 2026)
- Firecracker README, the AWS Lambda, AWS Fargate, Kata Containers and Flintlock uses: https://github.com/firecracker-microvm/firecracker/blob/v1.18.0/README.md (checked November 17, 2026)
- micro-http at revision
7975fe0e59000e8c41cb1d58fbd39ffa102e5b27,src/request.rs,get_abs_path()returns the target unchanged: https://github.com/firecracker-microvm/micro-http/blob/7975fe0e59000e8c41cb1d58fbd39ffa102e5b27/src/request.rs (checked November 17, 2026) - CISA Known Exploited Vulnerabilities catalog JSON feed, checked for a Firecracker entry on November 17, 2026 (none): https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json (checked November 17, 2026)
- NVD keyword search for Firecracker, checked for a new CVE on November 17, 2026 (none for this flaw): https://nvd.nist.gov/vuln/search/results?query=firecracker (checked November 17, 2026)