KernelScan.io

HIGH Introduced in 6.17

io_uring IncrementalBuffer Race

CVE-2026-99264

CVSS 7.8 / 10.0 NVD

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

KernelScan AI7.1HIGH

01

In the Linux kernel, the following vulnerability has been resolved: io_uring/net: don't retry recv on uncommitted buffers Commit 41b70df5b38b ("io_uring/net: commit partial buffers on retry") commits ring provided buffers when a receive is going to be retried after a partial transfer, so that another request using the same buffer group can't be handed the memory the first one keeps receiving into. It commits the number of bytes received so far. That does the job for a single buffer which is consumed as a whole, but the request hangs on to all it has mapped: - For a buffer ring with IOU_PBUF_RING_INC only these bytes are consumed. The rest of the buffer stays at the head of the ring. - For a bundle only the buffers which hold these bytes are consumed, the others that were peeked stay in the ring. In both cases the next receive with that buffer group gets memory that the retried request is still going to write to, and whoever comes last overwrites the data of the other. What the retry fills isn't committed at all, as the buffer list isn't known any more at that point. So the kernel hands it out again later on, while the CQE tells the application that it was used, and for an incremental buffer that it is done with. The remainder can't be committed in advance: if the request ends up receiving less, there is no way to tell the application that more was consumed than the CQE accounts for. Complete the request with what it has got instead of retrying it. MSG_WAITALL is no longer honoured for receives into incremental buffers or multi buffer bundles, they can return a short count, with the request marked as failed like for other short MSG_WAITALL transfers.

02

Engine v0.10.0

Risk summary

A local unprivileged user with access to io_uring can trigger a race condition in the network receive path when using incremental buffers or multi-buffer bundles. By causing concurrent receive operations to write to the same buffer memory, an attacker can corrupt kernel data and potentially escalate privileges or cause a denial of service. The vulnerability affects kernels 6.7 through 7.3 and is fixed in 6.12.115, 6.16, 7.2.14, and 7.4-rc1.

Affectedio_uring/net.c (io_uring)

Vulnerability analysis

When a network receive operation using ring-provided buffers receives a partial transfer, the kernel previously retried the operation after committing only the bytes received so far. For incremental buffers or buffer bundles, the remaining uncommitted portion of the buffer stayed in the ring and could be handed to another concurrent receive request. Both requests would then write to the same memory concurrently, with the last write overwriting the other's data. The fix adds a check that prevents retrying receives on incremental buffers or multi-buffer bundles; instead, the request completes with a short count, preserving MSG_WAITALL semantics only for single-buffer cases. An unprivileged local user who can submit io_uring requests (available by default on most distributions) can trigger this race by orchestrating concurrent receives on the same buffer group.

03

BranchIntroducedFixed inPatch commit
6.126.12.446.12.11521cb1770a56a
6.156.15.116.1697b8dc36ba3c
6.166.16.26.178444de681a17
6.186.176.18.60—
6.66.6.1036.7fc8506eea449
7.26.177.2.14—
mainline6.177.4-rc1—