The Short Version
What it is: CVE-2026-64531, also known as OVSwrap, is a Linux kernel local privilege escalation in the Open vSwitch action-validation path. A 16-bit length field wraps when the kernel builds an oversized nested action, and the parser resumes reading inside attacker-controlled bytes, which are then processed as legitimate Open vSwitch actions. Jump to this section →
Impact: An ordinary local user can leak kernel pointers, read kernel memory, and land a targeted write. The public proof of concept chains those into a complete credential-corruption path that writes a sudoers entry and opens a root shell. It ships with precomputed offsets for roughly 800 x86-64 kernel builds. Jump to this section →
Severity: With a severity score of 7.8, treat this as high priority. Exploitation needs a normal local account and nothing else: no Open vSwitch configuration, no running ovs-vswitchd, no OVS bridge, no CAP_NET_ADMIN in the initial namespace, no privileged container. unshare -Urn supplies the capability inside a namespace the attacker creates. Jump to this section →
Who is affected: Any affected kernel where unprivileged user namespaces are permitted and the openvswitch module is available for loading. That is the shipping default on most distributions. Confirmed in scope by our own backport analysis: Enterprise Linux 9.7 and later, Enterprise Linux 10.1 and later, Debian 12 and 13, Ubuntu 22.04 and 24.04, and Amazon Linux 2023. Jump to this section →
Status: Not a zero-day. Reported privately on June 19, 2026, and fixed in stable branches on July 24. The CVE record and the Linux CVE announcement went public on July 27, followed by the full write-up and a working exploit on July 28. There is no public claim of exploitation in the wild. Jump to this section →
Do this now: Apply a fixed vendor kernel and reboot, or deploy the KernelCare rebootless live patch (which was already automatically deployed to users of several distros). If the host does not use Open vSwitch, block the module in the meantime. One thing to skip: apparmor_restrict_unprivileged_userns and the related Debian and Ubuntu userns hardening knobs do not stop this chain. Our kernel team tested them. Jump to this section →
Checking whether the module is loaded is not the right test. Check whether it is present on disk for the running kernel:
ls /lib/modules/$(uname -r)/kernel/net/openvswitch/openvswitch.ko* 2>/dev/null
If that prints a path, the host is exposed until the kernel is patched or the module is blocked, whether or not anything has loaded it yet.
Patch CVE-2026-64531 Without an Emergency Reboot
KernelCare applies the Open vSwitch validation fix directly to the running kernel, closing the vulnerable code path without a maintenance window or a workload restart.
KernelCare status (2026-08-03): Rebootless live patches for Enterprise Linux 9 kernels, covering RHEL, AlmaLinux, Rocky Linux, CloudLinux, and Oracle Linux 9, were released on July 30, 2026. Enterprise Linux 10, Debian, Ubuntu, and Amazon Linux coverage has followed on a per-flavour basis. Availability differs by kernel family and feed, so confirm coverage for your exact kernel on the current status page before you rely on it.
The Long Version
Most of the hosts exposed to OVSwrap have never knowingly run Open vSwitch. That is the part that catches teams out.
OVS is widely associated with software-defined networking: OpenStack, OVN, Kubernetes CNIs, virtualization platforms. If none of that is in your stack, the reasonable assumption is that this CVE does not apply. But the vulnerable code ships as a loadable module in the standard kernel package on nearly every mainstream distribution, and the kernel loads it on demand when something asks for it.
An unprivileged user asks for it. They create a private user and network namespace, which grants CAP_NET_ADMIN inside that namespace, and that is enough to install Open vSwitch flows through the Netlink interface. The request autoloads the module into the host kernel. No administrator decision, no configuration file, no daemon.
So “we don’t run Open vSwitch” is not a statement about exposure. It is a statement about whether blocking the module will break anything, which is a different question and a more useful one.
The timing is the other thing to note. Upstream commit 3f1f75536668 reached stable four days before the exploit went public, so fleets on quick stable-kernel cadences may already be covered. Four days is also the entire gap between “fix available” and “working exploit with offsets for 800 builds.”
How OVSwrap Works
Open vSwitch actions are carried as Netlink attributes. Each one begins with a struct nlattr header containing a 16-bit nla_len field, which can represent at most 65,535 bytes.
When OVS validates a flow, it expands nested actions into an internal action stream that the kernel generates itself. OVS_ACTION_ATTR_CLONE is the one that matters here, because it wraps another action list and can therefore nest. The vulnerable code never verified that a generated nested attribute still fit inside the 16-bit length field.
[Attacker enters a private user and network namespace]
|
v
[Attacker gains CAP_NET_ADMIN inside that namespace]
|
v
[Attacker installs a flow packing hundreds of conntrack
actions inside a CLONE wrapper]
|
v
[Generated nested action stream exceeds 65,535 bytes]
|
v
[Length is stored in the 16-bit nla_len field and wraps
to a small value]
|
v
[Parser resumes mid-stream, inside attacker-controlled data]
|
v
[Forged action headers are parsed as real OVS actions]
|
v
[Kernel read and constrained write primitives]
|
v
[Host-process credentials corrupted, root shell]
The exploit packs hundreds of conntrack actions inside a CLONE wrapper. As OVS expands them, the generated stream grows past what nla_len can hold, the value truncates and wraps to something small, and the parser stops at the wrong offset. It resumes partway through the stream, in bytes the attacker chose, arranged to look like valid action headers. The kernel processes them as genuine actions.
Reachability requirements are the only real limits: x86-64, an OVS kernel datapath with conntrack and FTP-helper support available, and unprivileged namespace creation permitted. A stock x86-64 distribution kernel with rootless containers enabled meets all three.
From a Wrapped Length to Root
The forged actions are where the primitives come from.
Fake tunnel SET actions give a kernel-pointer leak and a kernel memory read. A separate tunnel-destination cleanup path gives a constrained write, in the form of a targeted 32-bit reference-count decrement.
A single 32-bit decrement sounds too weak to matter, and on its own it is. The setup around it is what makes it enough. Before entering the namespace, the exploit forks a process that stays on the host side. It then aims the decrement at that process’s credentials, and once the process is privileged, writes an entry into the sudoers configuration and launches a root shell.
The result is a reliable privilege escalation rather than a crash. Combined with precomputed offsets for roughly 800 kernel builds, the work required to reproduce this on a supported target is close to zero.
Why Systems Are Vulnerable Without Using Open vSwitch
Two conditions decide whether a host is exploitable, and both are defaults nearly everywhere: unprivileged user namespaces are permitted, and openvswitch sits in the standard kernel package with no autoload restriction in front of it. Distributions leave namespaces enabled because rootless Podman, rootless Docker, Bubblewrap, Flatpak, unprivileged unshare(1), and Chromium’s sandbox all depend on them.
The published attack does not require:
- A running ovs-vswitchd process
- An existing Open vSwitch bridge
- Any prior Open vSwitch configuration
- CAP_NET_ADMIN in the host namespace
- A privileged container
- The module to be loaded before the attack begins
Which means the attack surface is broader than hosts that actively run OVS: it includes affected systems where the module is merely available for an unprivileged user to trigger, and the researcher’s testing found that describes most distributions tested in stock configuration.
Picture where that lands. A shared build runner executing whatever the last merge request pushed. A multi-tenant node where customer code runs under an ordinary account. A developer workstation with rootless containers and a few hundred dependencies nobody has read. In each case the attacker already has the local account, and the module they need is one Netlink request away from loading itself.
The decision for each host is short:
- If the host does not use OVS, and nothing on it depends on OVS-backed bridges, block the module. That removes the vulnerable code path rather than blocking one route to it.
- If the host does use OVS, whether that is an OVN or OpenStack Neutron node, a Kubernetes cluster running ovn-kubernetes or Antrea, or a libvirt or oVirt host with OVS-backed bridges, leave the module alone. Deny unprivileged user namespaces or apply the patch instead.
The Bug Is Old, but the Exploitable Window Is Not
Two dates matter, and conflating them produces the wrong triage answer.
The unsafe assignment to the 16-bit length field is roughly 13 years old. For most of that time a separate conditional limit capped the generated action stream at 32 KiB, which kept an action from ever growing large enough to wrap nla_len. The cap was removed in March 2025, and that is what made the latent bug reachable.
In mainline terms the affected window opens around Linux 6.14. Older longterm branches became vulnerable when the cap removal was backported into them, not when the original bug was written.
Publicly reported stable ranges:
- 5.15.180 through 5.15.211
- 6.1.132 through 6.1.177
- 6.6.84 through 6.6.144
- 6.18.0 through 6.18.39
- 7.1.0 through 7.1.4
Reported first-fixed releases: 5.15.212, 6.1.178, 6.6.145, 6.12.97, 6.18.40, and 7.1.5.
Vendor kernels diverge from upstream in both directions, so the ranges above are a starting point rather than an answer. Some RHEL-derived 5.14 kernels carry the enabling change and are affected despite sitting below every range in the table. Some SUSE 6.12 kernels kept the old cap and are not affected despite sitting inside one.
Enterprise distributions also backport individual commits without adopting an upstream version, so a kernel whose version falls outside the published window can still carry the vulnerable combination. The window was introduced directly in the 6.14 development line and then extended to older longterm branches as that change was backported into them. Check the advisory or patch status for the exact distribution kernel.
Commit a1e64addf3ff, “net: openvswitch: remove misbehaving actions length check,” removed that limit in March 2025 because it was causing unpredictable failures, since OVS actions can grow or shrink as they are converted to their internal form. Removing the total-length check was reasonable. The side effect was that nothing stopped an individual nested attribute from crossing 65,535 bytes.
Who Is Affected
Our kernel analysis confirmed the vulnerable path in these supported platform families:
- Enterprise Linux 9.7 and later
- Enterprise Linux 10.1 and later
- Debian 12 (only versions 6.1.132-1 and later) and Debian 13
- Ubuntu 22.04 LTS and Ubuntu 24.04 LTS
- Amazon Linux 2023
The Enterprise Linux scope covers the corresponding RHEL, AlmaLinux, Rocky Linux, and CloudLinux kernels where they share the affected code. CloudLinux 9 runs the AlmaLinux 9 kernel and CloudLinux 10 runs the AlmaLinux 10 kernel, so both inherit the exposure directly.
Coverage is release- and flavor-specific. Do not infer that an adjacent stream is vulnerable, or fixed, because another release from the same distribution appears on the list.
Two things are still open rather than clear. Enterprise Linux 8 and CloudLinux 8, which runs its own kernel line distinct from AlmaLinux 8, have not been confirmed either way, and neither have Ubuntu 20.04 and the older longterm Debian and Ubuntu branches. The question for all of them is whether they took the cap-removal backport.
One hardening assumption to drop early: the researcher reports that neither SELinux nor AppArmor blocked any step of the exploit in testing, apart from AppArmor’s user-namespace policy blocking namespace creation on some Ubuntu releases, which is covered below. Enforcing mode does not change the outcome here.
Why Common User-Namespace Restrictions May Not Help
This is the part most likely to cost someone a weekend.
Recent Ubuntu releases ship an AppArmor policy that restricts unprivileged user namespace creation, controlled by kernel.apparmor_restrict_unprivileged_userns. It is the first knob most teams reach for, and it does block the plain unshare -Urn route: on Ubuntu 24.04 and 26.04 the direct attempt fails with the stock policy in place.
It is not a mitigation you should rely on. A publicly documented AppArmor bypass defeats the policy on 24.04, and on 26.04 the exploit works as soon as the restriction is turned off. Our own kernel team reached the vulnerable path with those Debian and Ubuntu userns hardening knobs enabled. Treat the policy as a speed bump on the way to a patch.
Denying namespace creation outright does break the published chain, because the attacker can no longer reach CAP_NET_ADMIN through unshare -Urn. The control that does that is the upstream one:
# /etc/sysctl.d/99-ovswrap.conf
user.max_user_namespaces = 0
sudo sysctl --system
Use user.max_user_namespaces rather than kernel.unprivileged_userns_clone. The latter is a deprecated Debian-family downstream patch that does not exist on Enterprise Linux at all, and on Ubuntu, where both may be present, setting only the unprivileged_userns_clone knob can leave a residual path to namespace creation depending on kernel version.
Verify the value actually took, because a distribution file in /usr/lib/sysctl.d/ that sorts later will silently win:
sysctl user.max_user_namespaces
The compatibility cost is real. Rootless container tooling breaks, unprivileged unshare(1) breaks, and Chromium’s sandbox breaks. On a conventional hosting or database fleet nobody notices. On developer workstations and container build hosts, they notice within minutes.
Is There a Workaround?
The right temporary mitigation depends on whether the host actually uses Open vSwitch. Neither option is a substitute for the fix.
- Block the Open vSwitch module. Preferred on any host that does not use OVS, which is most hosting fleets. Check lsmod | grep openvswitch and confirm no ovs-vswitchd is running first. Then:
# /etc/modprobe.d/99-ovswrap.conf
blacklist openvswitch
install openvswitch /bin/false
The install line is the one doing the work. A blacklist entry on its own does not stop the kernel’s own on-demand module request, which is exactly the path this exploit uses, so blacklisting alone is not a mitigation here. Note that root can still override an install directive with modprobe –ignore-install, and that modules forced in through the initramfs are not subject to either directive.
The rule blocks future loads only. If the module is already in memory, stop anything depending on it and unload it, which also needs no reboot:
sudo modprobe -r openvswitch
The module file stays on disk and modinfo openvswitch still returns output afterward. That is expected. The rule stops loading; it does not delete anything.
Do not apply this on OVN or OpenStack Neutron compute and network nodes, Kubernetes clusters using ovn-kubernetes or Antrea, or libvirt and oVirt hosts with OVS-backed bridges. Blocking the module there will break networking.
- Deny unprivileged user namespaces. Use the user.max_user_namespaces sysctl above. It works regardless of module state, which makes it the fallback for hosts that genuinely run OVS, at the cost of the rootless-tooling breakage already described. Test it against your workloads first.
- Treat the third-party BPF guard carefully. The public exploit repository ships an emergency BPF-based guard. We have not tested it. Review and validate it on representative systems before production use, and do not treat it as equivalent to a vendor fix.
After patching, remove the namespace restriction if it is no longer needed:
sudo rm -f /etc/sysctl.d/99-ovswrap.conf
The module block can stay. It is not tied to a kernel version, it survives updates and reboots, and on a host with no use for Open vSwitch it keeps a chunk of attack surface closed. Document it so the next person knows why networking fails if that host ever needs OVS, and remove it then with rm /etc/modprobe.d/99-ovswrap.conf.
The Fix
The upstream correction is commit 3f1f75536668, “net: openvswitch: reject oversized nested action attrs.”
It adds validation that rejects a generated nested action whose size cannot be represented safely in nla_len. Instead of letting an oversized value truncate into 16 bits, the kernel stops the invalid action during validation, before the malformed stream reaches the datapath.
The change sits in the validation path rather than the datapath fast path. It requires no kernel data-structure migration and no persistent per-task state, which is what makes it suitable for rebootless patching.
Patch and Verify the Running Kernel
Installing an updated kernel package does not patch the kernel running in memory. For a conventional update: install the fixed package for your exact distribution and release, reboot, and confirm the corrected kernel is running.
uname -r
Compare that against the applicable vendor advisory, not against the newest package on disk. And do not assume a kernel built after July 24, 2026 carries the fix. Distribution version numbers do not map to upstream releases, the vulnerable state arrived in these branches through a backport, and the correction was backported on separate schedules.
Rebootless Patching
KernelCare applies the same upstream validation logic to the active kernel. Once patched, OVS rejects oversized generated nested actions before the length can wrap, with no need to disable Open vSwitch, change module policy, or restart the workload. It is a kernel-only bug, with no userspace library component to chase.
Most deployments pick up new patches automatically in the background on a set interval, commonly every four hours. To pull on demand from the production feed:
kcarectl --update
Where a patch is still moving through the testing feed for your kernel family:
kcarectl --update --prefix test
Then check whether the CVE is listed in the installed patch information:
kcarectl --patch-info | grep 'CVE-2026-64531'
Confirm the patch appears for the exact running kernel before you remove any temporary mitigation. If coverage has not landed for your family yet, keep the module block or the namespace restriction in place.
Detection and Incident Review
There is no single clean indicator, so treat everything here as a lead rather than proof.
The most useful signal is the module itself. On a host with no legitimate use for Open vSwitch, openvswitch appearing in lsmod is anomalous on its own, and module-load audit records or journal entries for it are worth chasing. That signal disappears once you deploy the modprobe block, so look before you apply it.
Then check what the published PoC does with its root access:
sudo stat /etc/sudoers /etc/passwd /etc/shadow
sudo find /etc/sudoers.d -maxdepth 1 -type f -printf '%TY-%Tm-%Td %TH:%TM:%TS %p\n'
Unexpected sudoers entries or new files under /etc/sudoers.d/ are artifacts of the published proof of concept, though an attacker with root could skip that step entirely. Look also for new or newly privileged accounts, unexplained SSH keys, and privilege gains with no matching sudo, login, or authentication event, since credentials corrupted through a kernel write leave no auth trail.
Other behavioral leads: unprivileged processes creating user and network namespaces where no workload does that normally, a process running with root credentials that was not started as root and has no setuid ancestry, and kernel warnings or oopses from the OVS flow-validation path, which failed attempts can produce.
We have not yet reproduced the public PoC against restricted or containerized environments in-house, so do not assume per-user or container isolation contains it without testing that syscall path in your own setup.
Is This a Zero-Day?
No. The issue was reported privately on June 19, 2026, the fix reached stable branches on July 24 under a coordinated embargo, and the write-up and PoC followed on July 28. Nothing in the disclosure claims exploitation in the wild before a fix existed.
That does not make it low priority. Once the exploit went public, attackers received a tested path from an ordinary local account to root, plus offsets for a large collection of kernel builds. A four-day head start only helps the fleets that were already patching stable kernels quickly.
Why CVE-2026-64531 Matters
Three details make this easy to file as routine, and all three mislead.
It needs local access, so it looks like a second-stage problem, except local access is what tenants, CI runners, and untrusted dependencies already have. It needs Open vSwitch, so it looks like a niche networking problem, except the module loads itself on request. And it needs an unprivileged user namespace, so it looks like something existing hardening already covers, except the specific hardening most Debian and Ubuntu teams trust here does not work.
The version history carries the other lesson. A change that removed a size cap in March 2025 turned a dormant decade-old assignment into a live privilege escalation, and it reached longterm branches as an ordinary backport rather than a release. A triage queue keyed only on upstream version numbers would have read those kernels as outside the window.
For conventionally patched systems, install the vendor update and confirm the host boots into it. For fleets where emergency reboots create their own operational risk, KernelCare closes the vulnerable validation path in the running kernel without taking systems offline. Either way, the cheap move today is the module block on every host that does not use OVS: reversible, low-impact, and it removes the code path instead of arguing with it.
Timeline
| Date | Event |
| Approximately 2013 | Unsafe assignment to the 16-bit Open vSwitch attribute length field is introduced, unreachable behind a conditional 32 KiB action-stream cap |
| March 2025 | The 32 KiB cap is removed in the 6.14 development window, making the latent wraparound reachable. The change is later backported into longterm branches |
| July 24, 2026 | Upstream fix 3f1f75536668 is merged into stable kernel branches |
| July 27, 2026 | CVE-2026-64531 and the Linux CVE announcement become public |
| July 29, 2026 | Full technical write-up and working proof of concept are published |
| July 30, 2026 | KernelCare rebootless patches released for Enterprise Linux 9 kernels |
| Late July onward | Vendor and live-patch rollout continues across the remaining affected kernel families |
References
- Asim Manizada, OVSwrap disclosure, oss-security, July 28, 2026, and the seclists mirror
- OVSwrap technical write-up: https://heyitsas.im/posts/ovswrap
- Public OVSwrap proof of concept and BPF guard: https://github.com/manizada/OVSwrap
- Upstream Linux fix 3f1f75536668, “net: openvswitch: reject oversized nested action attrs”
- Linux CVE announcement for CVE-2026-64531
- CVE record, CVE-2026-64531
- Applicable RHEL, AlmaLinux, Rocky Linux, CloudLinux, Debian, Ubuntu, and Amazon Linux advisories