CVE-2026-98656
NoneCVSS
—
EPSS
0.2%
Published
Oct 18, 2026
CISA due date
—
Cloudanix analysis
A memory-handling mistake in the Linux kernel could let attackers crash devices or potentially run harmful code on systems that use certain sensor triggers.
- Exploitation
- Local Privilege
- Attacker needs
- Local User
- Complexity
- Moderate
- Impact
- Privilege Gain
- Component
- OS kernel
- Class
- Use After Free
- Remediation
- Upgrade
- Effort
- Medium
- Patch risk
- Low
What it actually does
Use-after-free in the Linux kernel IIO trigger subsystem where iio_trigger_notify_done_atomic() schedules ->reenable() work on the system workqueue that dereferences the trigger via container_of(), but iio_trig_release() frees the trigger without canceling the pending work, allowing the worker to touch freed memory.
Why it matters to the business
Linux systems processing IIO sensor triggers may experience kernel crashes, memory corruption, or potential privilege escalation, leading to system instability or compromise on affected devices and servers.
How an attack unfolds
An attacker with the ability to arm IIO triggers and deliver IRQs triggers the deferred reenable work, races the final trigger release through device put_device, and causes the out-of-lifetime worker to dereference freed memory for denial-of-service or arbitrary code execution.
How to fix it
Apply the upstream kernel patch that cancels reenable_work at the start of iio_trig_release(); rebuild and deploy a fixed kernel version containing this change.
How to confirm the fix worked
Confirm the presence of the cancel_work_sync call at the beginning of iio_trig_release() in the kernel source; test by exercising trigger arm/release paths under load and verifying absence of use-after-free reports in KASAN or similar sanitizers.
Typical attack path
- Identify or create an IIO trigger device
- Arm the trigger and generate a final IRQ to schedule reenable_work
- Trigger trigger release via device removal or unregistration
- Race the workqueue execution against the free in iio_trig_release
- Use the resulting use-after-free for memory corruption or crash
How to detect it
Inspect kernel logs for oops/panic traces referencing iio_trig_release, container_of on a trigger, or workqueue execution after device release; look for KASAN or KMSAN reports mentioning freed trigger memory.
What your security team should do
- Prioritize kernel updates on systems exposing IIO triggers
- Monitor for kernel oops or panic logs involving iio_trig_release or reenable_work
- Limit unprivileged access to IIO devices where possible until patched
The record
In the Linux kernel, the following vulnerability has been resolved: iio: trigger: cancel reenable_work before freeing trigger iio_trigger_notify_done_atomic() defers ->reenable() into trig->reenable_work on the system workqueue, and the worker dereferences the owning trigger through container_of(). Nothing cancels this work before iio_trig_release() frees the trigger, so a worker armed by the last in-flight IRQ can outlive the free and touch freed memory. Cancel it at the top of iio_trig_release(), which every free path reaches through the device core's final put_device(). Found by an in-house static analysis tool.
Affected packages
| Ecosystem | Package | Introduced | Fixed |
|---|