Security Analysis of the Linux Kernel’s io_uring subsystem

In April and May 2026, X41 performed a source code audit of the io_uring subsystem in the Linux Kernel. This audit was sponsored by the Open Source Technology Improvement Fund (OSTIF). The findings were reported by X41 during the project and promptly fixed by io_uring’s maintainer Jens Axboe and ublk’s maintainer Ming Lei. The full report including a threat model, coverage, and a description of X41’s fuzzing efforts is now released.

Full report of the security audit: https://www.x41-dsec.de/static/reports/X41-OSTIF-io-uring-Audit-Public-Report-2026-11-17.pdf

OSTIF blog post: https://ostif.org/io_uring-audit-complete/

IO uring

The io_uring subsystem provides an asynchronous high throughput I/O interface for applications running on Linux. Essentially, it is an alternative system call mechanism that allows applications to submit many I/O related system calls in a completely asynchronous manner, improving the throughput of especially I/O intensive programs. Historically, io_uring has been the target of many kernel exploits, as e.g., memory corruption vulnerabilities in the subsystem allow an attacker to elevate their privileges to root or leak sensitive memory from kernel space. It has been disabled in many sandboxes (e.g., on the Android Linux kernel) for this reason. However, disabling io_uring also prevents applications from utilizing the performance benefits that io_uring provides.

Audit Results

During the audit, X41 significantly improved the fuzzing coverage of the Syzkaller kernel fuzzer for the io_uring subsystem. Syzkaller utilizes a domain-specific language (DSL) to specify system call interfaces. This specification often lags behind the actual development of the system calls and becomes inefficient for covering the newest features. X41 improved Syzkaller’s specification to cover the latest io_uring opcodes and data structures. The result of these efforts have been merged into upstream Syzkaller (pull request on Github). Additionally, X41 noticed that not all code coverage was accounted for when fuzzing io_uring. Due to the asynchronous nature of io_uring some code is executed in the background and Syzkaller does not recognize this as code coverage it triggered by its current test case, which has a negative impact on the fuzzing behavior. To solve this problem X41 introduced an experimental remote coverage mode specific for the asynchronous system calls executed by the Linux kernel in the background. This allows the kcov coverage tracking mechanism used by Syzkaller to accurately associate executed code in the asynchronous parts of io_uring to the fuzzer-generated test case. The proposed changes have been accepted into the Linux kernel (see here).

X41 ran several fuzzing campaigns with different kernel configurations (enabled sanitizers and subsystems, etc.) using Syzkaller. While the overall code coverage numbers stayed below those of the public Syzkaller configuration, our fuzzing campaign reached code paths that were not covered by the syzbot Syzkaller instances. Additionally, X41 performed in-depth manual code review of the io_uring subsystem. In total, five vulnerabilities across all Linux kernel subsystems were discovered by X41 during the audit. None were rated as having a critical severity, two as high, two as medium, and one as low. Additionally, seven issues without a direct security impact were identified.

Conclusion

The code quality of the io_uring subsystem itself is very high. However, at the same time the interface is very difficult to defend due to the inherent high complexity. Due to the asynchronous and concurrent nature, the code and any potential vulnerabilities are hard to reason about. Further development of this interface makes it likely that exploitable bugs will emerge in the future.

From time to time, the io_uring subsystems gains new operations that allow further system calls to happen in an asynchronous manner. These new operations can expose old Linux kernel code paths in a way where old assumptions about the code, such as locking mechanisms and kernel object lifetimes, suddenly do not hold anymore. This can potentially lead to new critical kernel vulnerabilities. To defend this interface io_uring very recently gained the ability to filter io_uring operations, which makes it possible to harden applications or containers to prevent such exploitation scenarios. Note that this feature was not in the kernel version that was in-scope for this audit. Additionally, efforts that improve Syzkaller’s coverage of the io_uring interface to cover all operations are crucial in order to catch potential bugs as soon as possible. Continued investment in both proactive auditing and runtime mitigation mechanisms like operation filtering will be key to maintaining the security of io_uring as the subsystem evolves.

Finally, X41 thanks OSTIF for sponsoring this work and the kernel developers Jens Axboe and Ming Lei for the responsive collaboration in addressing the reported issues.