CVE-2026-99802 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
io_uring/register: enforce per-task restrictions in io_uring_register_blind()
When io_uring_register(2) is invoked with fd == -1, it dispatches directly to io_uring_register_blind() without checking current->io_uring_restrict.
As a result, a task with per-task register restrictions installed via IORING_REGISTER_RESTRICTIONS can still invoke blind registration opcodes such as IORING_REGISTER_SEND_MSG_RING even when those opcodes are not in the task's allowed register_op bitmap.
Check current->io_uring_restrict->register_op in io_uring_register_blind() before dispatching blind registration opcodes.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel’s io_uring subsystem provides a high-performance interface for asynchronous I/O operations, allowing applications to submit and complete requests without the overhead of traditional system calls. A critical aspect of this subsystem is the ability to enforce security restrictions on specific tasks through per-task registration limits. These restrictions are designed to limit which types of registrations an unprivileged or constrained task can perform, thereby reducing the attack surface associated with io_uring features that require file descriptor manipulation or ring setup. The vulnerability identified in io_uring_register_blind() represents a significant oversight in this enforcement mechanism, where the kernel fails to validate these per-task restrictions for specific blind registration operations.
The technical flaw lies within the execution path of io_uring_register when invoked with a file descriptor argument equal to -1. In such cases, the kernel dispatches directly to the internal function io_uring_register_blind(), which is intended for operations that do not require an associated file descriptor. However, this code path bypassed the standard validation logic that checks current->io_uring_restrict against the requested operation. Specifically, when a task has installed restrictions via IORING_REGISTER_RESTRICTIONS to limit its allowed register_op bitmap, it should be prevented from executing any registration opcode not explicitly permitted. The absence of a check for current->io_uring_restrict in io_uring_register_blind() means that tasks can bypass these constraints and invoke blind registration opcodes such as IORING_REGISTER_SEND_MSG_RING even when those operations are prohibited by the task's security policy.
This vulnerability allows an attacker or malicious process to escalate privileges within the context of the io_uing subsystem by performing restricted registrations. By exploiting this flaw, a constrained task can register message rings or other sensitive resources that were intended to be blocked. This undermines the isolation guarantees provided by per-task restrictions and could potentially lead to further exploitation scenarios where the attacker gains unauthorized access to kernel memory structures or manipulates I/O queues in ways not permitted by system policies. The impact is particularly severe because io_uring operations often involve direct interaction with hardware resources and kernel data structures, making any bypass of security checks a potential pathway for privilege escalation or denial of service attacks against other processes sharing the same kernel context.
From a classification perspective, this issue aligns with CWE-250, which describes execution with unnecessary privileges, as well as CWE-862, involving missing authorization checks. In terms of the MITRE ATT&CK framework for Linux, this vulnerability facilitates techniques related to privilege escalation and defense evasion by allowing unauthorized configuration changes that bypass intended security controls. The failure to enforce restrictions in a blind registration path creates an inconsistency in how io_uring handles permission validation across different operation types, highlighting the importance of comprehensive coverage in access control logic within kernel subsystems.
To mitigate this vulnerability, it is essential to apply the upstream Linux kernel patches that introduce the necessary checks for current->io_uring_restrict before dispatching blind registration opcodes. System administrators should ensure their systems are updated with the latest stable kernel versions where this fix has been integrated. For environments running older kernels without immediate patch availability, restricting io_uring usage through mandatory access control policies such as SELinux or AppArmor can provide an additional layer of defense by limiting which processes can invoke io_uring syscalls altogether. Additionally, auditing applications that utilize io_uring for compliance with expected registration patterns may help detect attempts to exploit this flaw in real-time before significant damage occurs.