CVE-2026-99443 in Linuxinfo

Summary

by MITRE • 11/19/2026

In the Linux kernel, the following vulnerability has been resolved:

pps: generators: don't use the driver's info after unregister

A file that was opened before pps_gen_unregister_source() keeps pps_gen, and with it the pointer to the driver's pps_gen_source_info. PPS_GEN_SETENABLE and PPS_GEN_USESYSTEMCLOCK keep using that pointer after the driver has gone:

- pps_gen_tio allocates its info with devm_kzalloc(), so after an unbind both ioctls read freed memory, and SETENABLE calls the driver's enable() with its freed private data.

- pps_gen-dummy does not set info->owner, so it can be unloaded while the file is open, and the ioctls then read the unloaded module's data and call its code.

TIO can't probe in a VM, as it needs ART. A test driver that registers its info in devm memory like TIO does, unbound while /dev/pps-gen0 is open, gives:

BUG: KASAN: slab-use-after-free in pps_gen_cdev_ioctl+0x4c1/0x580 Read of size 1 at addr ffff88800e647f38 by task ppsgen64/145 ... Freed by task 146: kfree+0x25a/0x6d0 release_nodes+0xd1/0x140 devres_release_all+0x10e/0x1a0 device_unbind_cleanup+0x71/0x250 device_release_driver_internal+0x41b/0x570 unbind_store+0xd9/0x100

and unloading pps_gen-dummy while its file is open oopses:

BUG: unable to handle page fault for address: ffffffffa0203040 Oops: Oops: 0000 [#1] SMP KASAN NOPTI
RIP: 0010:pps_gen_cdev_ioctl+0x372/0x580

Protect info in the ioctl handler with a mutex, and clear it under the mutex on unregister, so that unregister waits for the ioctls using it and later ones fail with -ENODEV. PPS_KC_BIND does the same for a removed PPS device since commit 3649f9a6b897 ("pps: don't allow PPS_KC_BIND on removed devices"). The sysfs attributes need nothing new: they are removed, and their callbacks drained, before info is cleared.

If you want to get best quality of vulnerability data, you may have to visit VulDB.

Analysis

by VulDB Data Team • 11/19/2026

The Linux kernel presents a use-after-free vulnerability within the Pulse Per Second (PPS) generator subsystem, specifically affecting the interaction between user-space file handles and driver unbinding or module unloading operations. This flaw arises from an improper lifecycle management of the pps_gen_source_info structure associated with PPS generators. When a device is unbound from its driver or when a kernel module providing such functionality is unloaded, the underlying memory for the source info may be freed if it was allocated using managed resources like devm_kzalloc. However, existing file descriptors opened prior to this event retain references to these now-freed structures. Consequently, subsequent ioctl calls on those open files attempt to access invalid memory addresses or execute code from an unloaded module, leading to severe stability issues and potential security exploits.

The technical root cause lies in the lack of synchronization between driver unregistration and active user-space interactions via ioctls such as PPS_GEN_SETENABLE and PPS_GEN_USESYSTEMCLOCK. In scenarios involving drivers like pps_gen_tio that utilize devm_kzalloc for info allocation, an unbind operation triggers device resource cleanup which frees the memory. If a process still holds an open file descriptor to /dev/pps-genX, it can invoke these ioctls, causing reads from freed slab memory and invoking driver enable callbacks with dangling private data pointers. Similarly, in cases involving pps_gen-dummy or other modules that fail to properly set info->owner, the kernel allows module unloading while files remain open. This results in execution of code within a page frame that has been unmapped or reclaimed by the kernel memory manager, triggering general protection faults or null pointer dereferences depending on the specific state of the freed memory and instruction pointers.

The operational impact of this vulnerability is significant, manifesting as system crashes, kernel panics, or undefined behavior due to corrupted data structures. As evidenced by KASAN reports, accessing freed slab memory leads to BUG: KASAN errors indicating out-of-bounds reads, while module unloading issues result in page faults with SMP and NOPTI flags active, causing immediate kernel oopses. These events disrupt system stability and can potentially be leveraged for privilege escalation or denial of service attacks if an attacker can control the timing of file descriptor retention relative to driver unload operations. The vulnerability affects systems relying on PPS generators where device hot-unplugging or dynamic module loading/unloading occurs concurrently with active monitoring or configuration processes via ioctl interfaces.

To mitigate this risk, the kernel implementation has been updated to enforce strict synchronization using mutexes within the ioctl handler and during the unregister process. By protecting access to the info structure with a mutex, the system ensures that unregistration waits for any ongoing ioctls to complete before clearing the pointer. This approach guarantees that once a device is removed or driver unloaded, subsequent ioctl attempts will fail gracefully with an -ENODEV error code rather than accessing invalid memory. Additionally, this change aligns with existing practices in PPS_KC_BIND handling since commit 3649f9a6b897, which prevents binding to removed devices. The sysfs attributes are handled safely as they are removed and drained before the info pointer is cleared, ensuring no race conditions exist there. This fix effectively closes the window for use-after-free exploits in this subsystem by enforcing proper reference counting and synchronization protocols during device lifecycle transitions.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00174

KEV

no

Activities

very low

Sources

Interested in the pricing of exploits?

See the underground prices here!