CVE-2026-99593 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
arm64: sdei: Preserve the interrupted context's exception registers
An SDEI event is dispatched by firmware regardless of PSTATE.DAIF, so it can interrupt the kernel where the exception registers are live:
- exception entry, before kernel_entry has saved ELR_EL1/SPSR_EL1 and before the C handler has read ESR_EL1/FAR_EL1; - exception return, after kernel_exit has loaded ELR_EL1/SPSR_EL1 and before the ERET.
An IRQ or pseudo-NMI cannot arrive there with PSTATE.I set. Firmware saves only x0-x17, PC and PSTATE around an SDEI event, so a synchronous exception taken by the handler overwrites the interrupted context's ELR, SPSR, ESR and FAR. do_sdei_event() only notices that ELR changed, and warns.
The interrupted context then carries on with the handler's state. A task interrupted on its way into the kernel can be sent SIGILL for the handler's kernel data abort. A task interrupted on its way back to user space ERETs to EL1, at the handler's fixup address, with user registers loaded.
With SDEI delivering NMI backtraces, this happens in normal operation. The handler runs show_regs(), which reads through possibly-NULL pointers with the _nofault() accessors. print_worker_info() faults this way for a kworker that is not running a work item, and a single sysrq-l warned once per such kworker.
Save ELR, SPSR, ESR and FAR in __sdei_handler() before irqentry_nmi_enter(), which can take an exception too, and restore them after irqentry_nmi_exit().
Once they are restored, a nested exception is harmless if its handler is safe in NMI context. That holds for EL1 data aborts on translation, permission and access-flag faults, which never take the mmap lock in NMI context, and for BRK. Warn once, with the syndrome, about any other exception class.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel contains a critical vulnerability within the Arm System Data Exchange Interface (SDEI) implementation on arm64 architectures that stems from improper preservation of processor state during nested exceptions. SDEI is a firmware mechanism designed to deliver asynchronous events, such as hardware errors or performance monitoring interrupts, directly into the operating system with high priority and low latency. Unlike standard interrupt requests or pseudo-NMIs which are subject to PSTATE.DAIF masking, an SDEI event can be dispatched by firmware regardless of whether exceptions are masked in the processor state register. This capability allows SDEI events to interrupt kernel execution at precise moments when exception-related registers remain live and vulnerable to overwriting. Specifically, these critical windows occur during exception entry before the kernel has saved ELR_EL1 and SPSR_EL1 or read ESR_EL1 and FAR_EL1, as well as during exception return after those values have been loaded but before the actual ERET instruction executes.
The core technical flaw lies in how the firmware handles context saving for SDEI events. Firmware saves only general-purpose registers x0 through x17 along with the program counter and processor state around an SDEI event, deliberately omitting exception-specific registers like ELR_EL1, SPSR_EL1, ESR_EL1, and FAR_EL1 to optimize performance. Consequently, if a synchronous exception occurs while executing within an SDEI handler, it overwrites these interrupted context's exception registers with the state of the nested fault. The kernel function do_sdei_event() detects that ELR has changed but only issues a warning rather than preventing the corruption or properly restoring the original context. This results in the interrupted execution flow continuing with the corrupted state from the SDEI handler, leading to severe operational instability and potential security implications.
The impact of this vulnerability manifests differently depending on where the interruption occurs within the kernel's lifecycle. If a task is interrupted while entering the kernel, it may be incorrectly sent a SIGILL signal corresponding to the data abort that occurred inside the SDEI handler rather than its original context. More critically, if a task is interrupted during exception return when transitioning back to user space, it will execute an ERET instruction pointing to the fixup address of the SDEI handler instead of returning to the intended user-space location. This results in execution resuming at EL1 with user registers loaded from the wrong context, effectively breaking process isolation and potentially allowing unauthorized access or code execution paths that bypass standard security controls.
This issue is particularly relevant for systems utilizing SDEI for delivering Non-Maskable Interrupt (NMI) backtraces, a common operational scenario in production environments. When an NMI triggers show_regs() to dump register state, it reads through pointers using _nofault() accessors which are designed to handle faults gracefully. However, if the underlying context is corrupted by nested exceptions as described above, print_worker_info() may fault when inspecting kworkers that are not actively running work items. While this specific manifestation might only result in a single warning per affected worker via sysrq-l, it indicates deeper instability where kernel data structures could be misinterpreted or accessed incorrectly under concurrent exception conditions.
To mitigate this vulnerability, the Linux kernel has implemented changes to __sdei_handler() that explicitly save ELR_EL1, SPSR_EL1, ESR_EL1, and FAR_EL1 before calling irqentry_nmi_enter(), which is a point where nested exceptions can occur. These registers are then restored after irqentry_nmi_exit completes, ensuring the original interrupted context remains intact regardless of any synchronous exceptions taken during handler execution. This approach aligns with CWE-20 Improper Input Validation and CWE-362 Concurrent Execution using Shared Resource with Improper Synchronization by addressing race conditions in register state management across exception boundaries.
The mitigation strategy also includes logic to handle nested exceptions safely once the context is preserved. A nested exception becomes harmless if its handler operates correctly within NMI context, such as EL1 data aborts for translation, permission, or access-flag faults that do not acquire locks like mmap_lock in NMI context, and BRK instructions which are generally safe. For any other exception classes that might cause issues even with preserved state, the kernel now warns once along with the syndrome information to aid debugging without compromising system stability. This solution maps to MITRE ATT&CK technique T1059 Command Scripting by preventing unauthorized execution flows resulting from corrupted return addresses and aligns with CWE-787 Out-of-bounds Write if considering potential memory corruption scenarios arising from incorrect register states during exception handling.