KernelScan.io

CRITICAL

skbuff Zerocopy UAF

CVE-2026-90049

CVSS 9.3 / 10.0 NVD

CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H

KernelScan AI8.1HIGH

01

In the Linux kernel, the following vulnerability has been resolved: net: skbuff: don't skb_tx_error() the source skb in skb_zerocopy() skb_zerocopy() copies frags from @from into @to. On an skb_orphan_frags() failure it calls skb_tx_error(@from), a destructive operation on the source skb the copy helper does not own. That completes @from's zerocopy uarg and clears SKBFL_ALL_ZEROCOPY, including the SKBFL_SHARED_FRAG page-ownership marker. Both callers already report the failure on their own drop path. nfnetlink_queue does it at nla_put_failure, and Open vSwitch does it in the flow-miss drop arm of ovs_dp_process_packet(), so nothing is lost by dropping it here. On Open vSwitch's OVS_ACTION_ATTR_USERSPACE path the skb is not freed on this error: do_execute_actions() ignores output_userspace()'s return value and, unless the upcall was the last action, keeps forwarding the same skb through the flow's remaining actions. The uarg is completed while that skb is still in flight, telling the producer its buffers are free, and SKBFL_SHARED_FRAG is cleared on an skb the rest of the stack still handles. That flag is what makes esp_input() call skb_cow_data() instead of decrypting in place, so a later local ESP delivery can decrypt over frags the skb does not own privately. Leave error reporting to the callers.

02

Engine v0.6.0

Risk summary

A network attacker can trigger memory corruption on a host running Open vSwitch by sending packets through a flow that includes a userspace upcall action. When the error path fires under memory pressure, the source skb's zerocopy state is prematurely destroyed while the skb is still in flight, and a subsequent ESP/IPsec delivery can decrypt over fragments the skb no longer owns, corrupting kernel memory. This can lead to information disclosure, data integrity violation, or a kernel crash.

Affectednet/core/skbuff.c (networking core)

Vulnerability analysis

When the kernel's skb zerocopy helper encounters a memory allocation failure while orphaning fragments, it calls a destructive error-reporting function on the source skb — a skb it does not own. This prematurely completes the source skb's zerocopy state, telling the original producer its buffers are free, and clears the shared-fragment ownership flag. In the Open vSwitch datapath, the skb is not freed on this error: the action execution loop ignores the failure return value and continues forwarding the same skb through remaining flow actions. With the ownership flag cleared, a later ESP/IPsec delivery will decrypt in place over fragments that may have already been freed and reused by the producer, causing use-after-free memory corruption. The fix removes the destructive error-reporting call from the copy helper entirely, leaving error reporting to the two callers (nfnetlink_queue and Open vSwitch) which already handle it on their own drop paths. The vulnerability is reachable from the network by an unauthenticated attacker sending packets through an OVS bridge configured with a userspace upcall action that is not the final action in the flow, though triggering the error path requires memory pressure and the full corruption scenario additionally requires an ESP/IPsec delivery path on the same host.

03

BranchIntroducedFixed inPatch commit
3.103.10.513.11849bdb831237
5.10—5.10.270767ec2a65cc0
5.15—5.15.2218069643ae64d
6.1—6.1.18804dd250a78e2
7.2—7.2.5—
mainline—7.3-rc1—
6.18—6.18.518ece90615012
6.6—6.6.157a13b1e80e501
6.12—6.12.110bab5a851e44a
3.123.12.403.13fb10e0e9b220