---
title: "From Patch to KVM and Firecracker Escape"
description: "NebuSec analyzes a Linux kernel checksum validation flaw and demonstrates guest-to-host code execution in Firecracker and QEMU environments."
url: https://nebusec.ai/research/cve-2026-99999-kvm-firecracker-escape/
published: 2026-11-19T00:00:00.000Z
---

![NebuSec](https://nebusec.ai/static/nebusec-fulllogo-light.svg)

# From Patch to KVM and Firecracker Escape

NebuSec · November 19, 2026 · 9 min read

* [linux](https://nebusec.ai/tags/linux/)
* [CVE-2026-99999](https://nebusec.ai/tags/CVE-2026-99999/)
* [firecracker](https://nebusec.ai/tags/firecracker/)
* [qemu](https://nebusec.ai/tags/qemu/)
* [virtualization](https://nebusec.ai/tags/virtualization/)

Table of contents

* [Summary of Findings](#summary-of-findings)
* [Impact on Virtual Machine Isolation](#impact-on-virtual-machine-isolation)
* [Tested Environments and Requirements](#tested-environments-and-requirements)
* [Understanding the Checksum Validation Flaw](#understanding-the-checksum-validation-flaw)
* [From Checksum Validation to Host Compromise](#from-checksum-validation-to-host-compromise)
* [Exploit Development from the Kernel Patch](#exploit-development-from-the-kernel-patch)
* [Exploit Validation and Results](#exploit-validation-and-results)
* [Patch and Mitigation](#patch-and-mitigation)
* [Discussion](#discussion)
* [Conclusion](#conclusion)

> A Linux kernel vulnerability involving improper validation of network checksum metadata can allow an attacker to cross the isolation boundary between a guest virtual machine and its host.

The vulnerability, [CVE-2026-99999](https://www.cve.org/CVERecord?id=CVE-2026-99999), was originally discovered by researchers at [pwn.ai](https://pwn.ai/). It affects how the Linux kernel handles checksum metadata supplied through virtio-net and can lead to a host kernel crash or guest-to-host execution under specific conditions. An attacker from virtual machine can overwrite kernel object fields such as `skb_shared_info.nr_frags` to convert the original Out-Of-Bound write primitive to a page-level Use-After-Free, and then perform regular kernel exploit technology to finish the exploded.

We investigated the vulnerability by using the NebuSec AI-driven security research pipeline. Starting with the publicly available kernel patch, the pipeline identified an exploitation path that hadn’t been publicly documented. We subsequently developed working exploits for Firecracker and QEMU.

In our tested Firecracker environment, the exploit achieved host-level code execution in 20 out of 20 cold-start tests.

This post describes the underlying vulnerability, the interactions between kernel subsystems that make exploitation possible, and our testing results and available fixes.

Your browser does not support the video tag.

The host boots a Firecracker guest on Ubuntu 7.0.0-1011-aws. From a root shell in the guest, the exploit returns a root shell on the host.

## Summary of Findings

Our investigation produced the following findings:

* **Root cause:** Improper validation of IPv4 checksum metadata in the Linux kernel’s virtio-net networking path.
* **Affected environments:** We developed working exploits for Firecracker and QEMU. Cloud Hypervisor is also affected by the underlying issue, although its latest version includes a userspace mitigation.
* **Security impact:** A guest with root or `CAP_NET_RAW` privileges can trigger a host kernel panic or, under the demonstrated conditions, achieve guest-to-host code execution.
* **Exploit development:** Analysis of the upstream kernel patch revealed an exploitation path that wasn’t publicly documented.
* **Testing results:** The exploit achieved host-level execution in all 20 cold-start tests conducted in the documented Firecracker environment.
* **Remediation:** An upstream Linux kernel patch adds validation to prevent checksum processing from beginning in the IPv4 header.

## Impact on Virtual Machine Isolation

Virtual machine monitors (VMMs) provide isolation between guest workloads and their underlying hosts. This isolation depends on several components, including the host operating system and the interfaces through which guest-controlled data is processed.

The vulnerability examined in this research originates in the Linux host kernel’s networking stack rather than in a specific VMM. This distinction matters because multiple virtualization technologies can expose the affected networking path.

We developed working exploits for Firecracker and QEMU, demonstrating guest-to-host compromise in the tested environments. Our analysis also found that Cloud Hypervisor is affected by the underlying vulnerability. According to our research, its latest version includes a userspace patch that prevents the vulnerable behavior.

Two security outcomes are possible:

1. **Host kernel panic:** Malformed packet metadata can cause the host kernel to crash, resulting in service disruption.
2. **Guest-to-host code execution:** Under more specific conditions, the vulnerability can be exploited to execute code in the host kernel.

The second outcome crosses a security boundary that cloud and virtualized environments rely on to separate workloads from their underlying infrastructure. The findings don’t establish that every deployment of these VMMs is vulnerable. Exposure depends on the host kernel, networking configuration and available mitigations.

## Tested Environments and Requirements

The documented Firecracker exploit was evaluated against the following configuration:

| Component                   | Details                                                               |
| --------------------------- | --------------------------------------------------------------------- |
| Vulnerability               | CVE-2026-99999                                                        |
| Host kernel                 | Ubuntu 7.0.0-1011-aws                                                 |
| Tested VMM                  | Firecracker v1.14.4                                                   |
| Additional demonstrated VMM | QEMU                                                                  |
| Cloud Hypervisor mitigation | Userspace patch in the latest version, according to NebuSec research  |
| Affected functionality      | virtio-net checksum offload, IPv4 reassembly and output fragmentation |
| Guest privileges            | Root or `CAP_NET_RAW`                                                 |
| Root cause                  | Improper validation of `CHECKSUM_PARTIAL` metadata                    |
| Demonstrated impact         | Host kernel panic or guest-to-host code execution                     |

The vulnerable path requires a guest with access to a virtio-net device that accepts checksum-offload metadata and an IPv4 route forwarded by the host.

The demonstrated Firecracker exploit targets the specific kernel build listed above. The results shouldn’t be interpreted as evidence that all Firecracker deployments or Linux kernel versions are vulnerable.

## Understanding the Checksum Validation Flaw

The vulnerability originates in the Linux kernel’s handling of checksum metadata supplied through virtio-net. Checksum offloading allows parts of the networking stack to defer checksum calculations until later in the packet processing. The mechanism relies on metadata that specifies where checksum processing should begin and where the checksum field is located.

In the vulnerable implementation, the kernel checks that the checksum field falls within the packet and applies a minimum transport-offset check. However, it doesn’t adequately verify that checksum processing begins beyond the IPv4 header. As a result, guest-controlled metadata can pass initial validation even when the checksum operation points into the IPv4 header itself.

When the host processes the packet, checksum completion can overwrite critical IPv4 header information, including the header-length field. This creates an inconsistency between the packet structure established during earlier processing and the header information interpreted by subsequent networking operations.

Linux represents packets with socket buffers (`sk_buff`). The associated `skb_shared_info` structure holds shared metadata, including descriptors for packet data stored in page fragments.

IPv4 reassembly, for example, may have already established assumptions about the packet’s structure. Later fragmentation operations can encounter header values that no longer match those assumptions.

Depending on the processing path, the inconsistency can result in a kernel panic. Our investigation also identified interactions involving IPv4 and IPv6 reassembly, memory allocation and packet cleanup that make more serious exploitation possible.

## From Checksum Validation to Host Compromise

The checksum validation flaw is the starting point of the exploitation chain, but it’s not sufficient on its own to explain the guest-to-host escape. The more serious behavior comes from interactions between several kernel subsystems.

At a high level, the exploit happens in four stages:

1. **Packet metadata validation:** Guest-controlled checksum metadata passes the initial checks and causes the host to modify IPv4 header information.
2. **Memory corruption:** Subsequent packet processing encounters inconsistent structural information. Interactions involving reassembly, fragmentation and memory management create conditions in which kernel memory can be improperly released and reused.
3. **Memory disclosure and manipulation:** The resulting memory-safety issue provides limited capabilities to disclose or modify sensitive kernel data.
4. **Host-level execution:** The exploit uses those capabilities to affect kernel execution behavior and achieve code execution on the host.

The exploit also accounts for kernel address space layout randomization (KASLR), which randomizes kernel memory locations to make exploits more difficult.

These interactions explain why the impact of the vulnerability extends beyond a packet-processing crash. The original validation error occurs in a narrow part of the networking stack, but its effects move through other components that depend on consistent packet metadata.

## Exploit Development from the Kernel Patch

Our investigation began with the upstream Linux kernel patch addressing the checksum validation issue. The patch identified the missing validation check, but didn’t establish how the flaw could be used to achieve host-level code execution.

We analyzed the affected networking code and its interactions with packet reassembly, fragmentation and memory management. We identified an exploitation path that hadn’t been publicly documented.

From there, we developed working exploits for Firecracker and QEMU to evaluate whether the vulnerability could be used to cross the guest-to-host isolation boundary. The resulting exploits demonstrated that the checksum validation issue could lead to host-level code execution under the tested conditions.

The investigation also required accounting for memory allocation behavior, kernel address randomization and execution context. These factors are relevant to exploit reliability because the underlying memory-safety issue doesn’t produce the same outcome on every execution.

## Exploit Validation and Results

We evaluated the Firecracker exploit against the specified Ubuntu kernel build in a controlled environment. Unlike a proof-of-concept that only triggers a kernel panic, the exploit demonstrated host-level command execution while leaving the system running.

Across 20 consecutive cold-start tests, the exploit achieved host-level execution in every attempt.

| Test                             | Result                |
| -------------------------------- | --------------------- |
| Environment                      | Firecracker v1.14.4   |
| Host kernel                      | Ubuntu 7.0.0-1011-aws |
| Test method                      | 20 cold-start runs    |
| Successful host-level executions | 20                    |
| Observed success rate            | 100%                  |

The results demonstrate repeatability in the documented configuration. They don’t establish the same level of reliability across other kernel builds, virtualization configurations or deployment environments.

We also developed a working exploit for QEMU. The 20-run result reported here applies specifically to the documented Firecracker testing.

## Patch and Mitigation

The upstream Linux kernel fix addresses the underlying checksum validation failure. It adds an IPv4-specific validation check to ensure that checksum processing can’t begin within the IPv4 header.

By rejecting malformed checksum metadata before checksum completion, the change prevents the header modification that initiates the vulnerable processing sequence.

The upstream patch is available here: [Linux kernel commit 6785011f8b16](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6785011f8b16abf40b1e9d8b2e332232b3e68822).

Organizations operating potentially affected environments should review their host kernel versions and determine whether the relevant fix or equivalent vendor backport has been applied.

Additional considerations include:

* **Networking configuration:** Identify environments where guest-controlled checksum-offload metadata can reach host networking paths.
* **VMM-specific mitigations:** Review applicable userspace fixes, including the mitigation identified in Cloud Hypervisor.
* **Kernel patch status:** Confirm remediation against vendor advisories and backport information instead of relying on version numbers.
* **Validation:** Verify that the applied fix prevents the vulnerable behavior.

Because the issue originates in a shared kernel component, evaluating the host kernel and the VMM configuration together is important when determining exposure.

## Discussion

This case illustrates how a validation error in one part of the Linux networking stack can have consequences across other kernel subsystems.

The original flaw concerns checksum metadata. Its more serious impact depends on how packet reassembly, fragmentation, memory management and cleanup operations interact.

Our investigation focused on reconstructing the interactions and determining whether they could produce a practical exploitation path. The resulting exploits demonstrate that the vulnerability can cross the guest-to-host isolation boundary under the tested conditions.

The research also provides an example of how AI-assisted code analysis can contribute to exploitability assessment. In this case, the pipeline helped identify a path from a known validation weakness to host compromise, which was subsequently demonstrated through working exploits.

## Conclusion

CVE-2026-99999 demonstrates how improper validation of network checksum metadata can lead to consequences beyond the immediate packet-processing code. Although the vulnerability was already known, its exploitation path hadn’t been publicly documented. Our investigation of the upstream kernel patch and related networking subsystems led to working exploits for Firecracker and QEMU.

The Firecracker exploit achieved host-level execution in 20 out of 20 cold-start tests in the documented environment.

The findings highlight the importance of examining how vulnerabilities interact with surrounding code, especially when the interactions affect memory safety and isolation boundaries.

We’ll continue investigating how AI-driven analysis can support vulnerability research, exploitability assessment and remediation across complex systems and environments.

Learn more about NebuSec at [nebusec.ai](https://nebusec.ai/index.md).
