A data race condition in the Linux kernel's audit subsystem allows local attackers to cause denial of service and minimal integrity impact by exploiting unsynchronized reads of the audit queue length. The flaw affects kernel versions from 4.10 through the unpatched stable series, triggered when concurrent readers and writers access the queue without proper locking,
Out-of-bounds read in the Linux kernel's SMB/CIFS client POSIX SID parser allows a malicious or MITM SMB server to cause kernel memory disclosure and denial of service on connecting clients. The `posix_info_sid_size()` helper reads `sid[1]` (the SubAuthorityCount byte) after validating only one remaining byte, permitting a truncated server-supplied POSIX SID to trigger a one-byte OOB read - leaking a byte of kernel heap context (C:L) and risking a crash (A:H). No public exploit code exists and EPSS is 0.22%, but the vulnerability is client-facing and triggered entirely from the server side without client-side privilege. Patches are available across all maintained stable branches.
Privilege escalation in the Linux kernel's KVM on ARM64 with pKVM allows a host with root privileges to corrupt hypervisor memory via an out-of-bounds list register index, potentially leading to full hypervisor compromise. The vulnerability arises from missing bounds clamping of the used_lrs field when copying vGIC state from host to hyp, enabling a malicious host to read or write beyond the implemented list registers. A patch is available across several stable kernel branches; the EPSS score is low (0.21%) and no public exploit or active exploitation is known at time of analysis.
Privilege escalation in the Linux kernel's
Arbitrary file upload leading to remote code execution affects the WPForms Pro plugin for WordPress in all versions up to and including 1.10.1.1, exploitable by unauthenticated attackers through the ajax_chunk_upload_finalize function. Because file-type validation runs only after chunk metadata and file contents are written to disk, and the assembled file is not removed when validation fails, an attacker can leave an executable payload (e.g. a PHP file) on the server. Reported by Wordfence and tracked as ENISA EUVD-2026-48766, this carries a CVSS 8.1; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.
Remote code execution in Knot Resolver versions prior to 6.4.1 stems from a heap-based buffer overflow triggered along the DNS-over-QUIC (DoQ) receive path, allowing a remote unauthenticated attacker to corrupt heap memory by sending malformed QUIC-transported DNS traffic to an exposed resolver. Because the flaw lives in the query-receiving code, any Knot Resolver instance that has DoQ listening is reachable over the network without credentials. Publicly available exploit code exists (a dedicated 'knot-doq' proof-of-concept was published), and the issue was disclosed via oss-security; it is not listed in CISA KEV, so there is no confirmation of active exploitation yet.
Out-of-bounds write in the Linux kernel's rtl8723bs staging Wi-Fi driver when processing a maliciously crafted 802.11 Association Response frame. An attacker within Wi-Fi range can send an oversized HT Capabilities IE, leading to up to 229 bytes of kernel memory corruption, resulting in high integrity and availability impact with no user interaction or authentication required. No public exploit or active exploitation is known; EPSS indicates very low exploitation probability (0.22%).
Data zeroing attack in the Linux kernel's ksmbd SMB server allows an authenticated client to destroy file contents without requiring FILE_WRITE_DATA permission. A handle opened with only FILE_WRITE_ATTRIBUTES is sufficient to send FSCTL_SET_ZERO_DATA, bypassing the missing per-handle access check. Publicly available exploit code exists, and vendor patches have been released.
Out-of-bounds reads in the Linux kernel's rtl8723bs staging WiFi driver allow an attacker-controlled access point to leak kernel memory or crash affected systems by sending beacon or probe-response frames with a truncated final information element. Two IE-parsing loops in issue_assocreq() and join_cmd_hdl() dereference pIE->length without first verifying that at least sizeof(*pIE) bytes remain in the buffer, so a one-byte stub IE at the end of AP-supplied data reads one byte past the buffer end. No public exploit has been identified at time of analysis, and EPSS sits at 0.22%, consistent with the adjacent-network attack vector and niche driver footprint.
Out-of-bounds read in the Linux kernel's rtl8723bs staging driver allows adjacent network attackers to read sensitive kernel memory and cause denial of service via a malicious association response. Exploitation requires a rogue access point sending crafted IE data. Patches are available, and no active exploitation or public exploit has been reported.
Out-of-bounds read in the Linux kernel's staging rtl8723bs Wi-Fi driver can be triggered by a malicious Access Point sending a crafted Beacon frame, allowing an adjacent attacker to read sensitive kernel memory and potentially crash the system. Affected kernels from version 4.12 onwards that include the rtl8723bs driver; vendor patches are available.
Memory disclosure in the Linux kernel's SLUB allocator allows local attackers to read uninitialized kernel memory when specific slab debugging options are enabled. The issue occurs when red zoning is active without store_user tracking, causing krealloc() to violate the __GFP_ZERO contract and return partially zeroed allocations. This can leak sensitive data, with an EPSS probability of 0.21% and no known active exploitation, though a vendor patch is available.
Use-after-free in the Linux kernel Bluetooth subsystem's bt_accept_dequeue() function allows an attacker with local or adjacent Bluetooth access to corrupt kernel heap memory or crash the system during L2CAP listening socket teardown. The bug stems from a reference-count sequencing error: the temporary queue-walk reference is dropped before bt_accept_unlink() removes the socket from the accept queue and drops its own reference, so if that was the final reference, the subsequent sock_hold() call dereferences freed slab memory. No public exploit code and no CISA KEV listing exist at time of analysis; EPSS is 0.22% (13th percentile), consistent with low opportunistic exploitation risk.
Local privilege escalation in the Linux kernel's QAT driver allows a low-privileged local attacker to achieve full system compromise by exploiting a legacy character device interface with IOCTLs. The unused /dev/qat_adf_ctl device node increases attack surface and has been the subject of multiple bug reports. With an EPSS score of 0.24%, active exploitation is unlikely, and no public exploit code is known; the vulnerability is addressed by removing the entire character device and IOCTL infrastructure.
Heap buffer overflow in the Linux kernel's rtl8723bs staging WiFi driver (rtw_cfg80211_set_wpa_ie()) allows a local low-privileged user to corrupt kernel memory by one byte via a crafted nl80211 connect request, enabling potential privilege escalation to kernel context. The 256-byte supplicant_ie array in struct security_priv overflows when a WPA IE with length 255 is supplied, writing 257 bytes and clobbering the adjacent last_mic_err_time field; a flawed length check in rtw_parse_wpa_ie() using u8 narrowing silently permits the overflow. Patches are available across all active stable kernels; EPSS is 0.23% and no public exploit or CISA KEV listing exists at time of analysis.
Local privilege escalation via stack buffer overflow in the Linux kernel's hid-goodix-spi driver allows a user with access to a Goodix SPI HID device node to corrupt kernel stack memory and achieve full system compromise. The goodix_hid_set_raw_report() function copies caller-supplied report data into a fixed 128-byte stack buffer without bounds checking, so a hidraw SET_REPORT ioctl carrying more than ~116 bytes overflows it. There is no public exploit identified at time of analysis, and the low EPSS score (0.23%) plus the local-only, hardware-specific attack surface indicate limited real-world exposure despite the high 7.8 CVSS.
Local privilege escalation to root via a use-after-free race condition in the Linux kernel's binder driver allows a low-privileged attacker to exploit a flaw in binder_thread_release() when a thread exit races with a parallel process death. The vulnerability affects Linux kernel versions since commit 7a4408c6bd3e and can lead to full system compromise. EPSS exploitation probability is low (0.22%), and no public exploit or active exploitation is known at time of analysis.
Local privilege escalation in the Linux kernel's binder driver allows a low-privileged attacker to execute arbitrary code with kernel rights. The vulnerability arises from a race condition in binder_free_transaction() where a freed target process can still be accessed, leading to a use-after-free. No active exploitation or public exploit code is currently known, and vendor patches are available across multiple stable kernel branches.
Use-after-free in the Linux kernel IPv4 IGMP subsystem allows a local low-privileged attacker to trigger kernel memory corruption or a system crash by racing network device destruction against concurrent multicast group lookups in softirq context. During ip_mc_destroy_dev(), multicast membership entries are scheduled for RCU reclamation via ip_ma_put() but are not unlinked from the per-device mc_hash table; concurrent softirq-path readers such as ip_check_mc_rcu() can then dereference a freed slab object, as confirmed by the embedded KASAN trace showing a read of freed memory during UDP packet processing. No public exploit code or CISA KEV listing exists at time of analysis; Ubuntu USN-8726/8727-1 and a Siemens ICS advisory confirm active patching across distributions.
Memory leak in the Linux kernel's SMB client encrypted receive path (receive_encrypted_standard()) allows a local low-privileged user or a cooperative malicious SMB server to exhaust kernel heap memory, with potential for heap grooming-based privilege escalation. The bug was introduced with commit b24df3e30cbf and affects multiple stable kernel series from 4.19 onward. No public exploit code exists and EPSS is 0.22%, but the kernel team's classification of CWE-787 and a C:H/I:H/A:H CVSS score reflect the Linux security team's assessment that the leaked kernel buffer is exploitable beyond simple resource exhaustion.
Privilege escalation in the Linux kernel /proc filesystem allows a local attacker to bypass ptrace access restrictions when reading symbolic links in /proc/[pid]/fd/. By racing the task lookup and access check, an unauthenticated local user can gain unauthorized read and write access to sensitive file descriptors of other processes, potentially leading to full system compromise. The vulnerability affects a wide range of kernel versions and has a patch released by the Linux kernel project.
Local privilege escalation in the Linux kernel's pcc-cpufreq driver allows a low-privileged user to gain full root privileges. The vulnerability is a use-after-free and double-free flaw when evaluating ACPI _OSC negotiation, affecting all kernel versions from 2.6.34 until the fixed stable releases (5.10.261, 5.15.212, 6.1.178, 6.6.145, 6.12.96, 6.18.39, 7.1.4, and 7.2-rc1). No active exploitation or public exploit has been identified, and EPSS indicates a low probability of widespread exploitation.
Use-after-free in the Linux kernel HID appleir driver allows a local attacker to corrupt kernel memory during device removal, potentially achieving privilege escalation. The race condition exists between the key_up_timer callback (armed by appleir_raw_event() on each keydown/key-repeat) and hid_hw_stop(), which frees the underlying input_dev before the timer is drained. A second race window, where a USB URB completion during hid_hw_stop() can re-arm the timer via mod_timer(), means a simple teardown reorder is insufficient — the fix introduces a spinlock-gated 'removing' flag combined with timer_shutdown_sync() to permanently disable further callbacks. No public exploit has been identified at time of analysis, and EPSS is 0.22% (13th percentile).
Use-after-free in the Linux kernel HID lg-g15 driver allows a local attacker to trigger kernel memory corruption by racing device input events against USB keyboard removal. The driver allocates lg_g15_data via devm and schedules work items from HID report handlers (backlight cycle key on G15, G15 v2, G510), but lacked a remove callback to cancel pending work before devres freed the allocation. On kernel versions from approximately 5.5 through the unfixed stable branches, unplugging the keyboard while a work item is pending causes the worker to dereference freed memory via container_of, potentially enabling local privilege escalation. No public exploit has been identified and EPSS is 0.22% (13th percentile), indicating no observed widespread exploitation.
Integer wrap-around in the Linux kernel's HFS/HFS+ filesystem driver allows a local low-privileged user to bypass a critical bounds check, triggering a memmove that reads approximately 4GB past a node buffer in kernel memory. The flaw originates in check_and_correct_requested_length(), where u32 arithmetic on off+len wraps silently when len arrives as a large underflowed value from hfs_brec_remove(); the wrapped result passes the node_size guard and proceeds to an out-of-bounds memory operation. No public exploit has been identified at time of analysis, and EPSS stands at 0.22%, reflecting low real-world exploitation expectation despite full C:H/I:H/A:H impact ratings.
Use-after-free in the Linux kernel's idmouse USB fingerprint driver allows a low-privileged local attacker to corrupt kernel memory by racing a device disconnect against a file-descriptor release, potentially enabling local privilege escalation to root. The bug stems from `mutex_unlock()` accessing the freed driver-data structure after the lock is released, a documented non-atomic behavior; the fix introduces a `kref` reference counter to correctly manage object lifetime. Patches are available across all active stable branches; no active exploitation or public exploit has been reported.
Use-after-free in the Linux kernel's USB ldusb driver allows a local unprivileged user to corrupt kernel memory by racing disconnect() against release() on a connected USB device. The root cause is that mutex_unlock() is documented as non-atomic and may access the mutex object after it logically releases the lock, creating a window where the driver data structure can be freed while still in use. No public exploit has been identified at time of analysis, and EPSS is low (0.22%), but the C:H/I:H/A:H CVSS impact vector reflects the potential for full kernel privilege escalation if successfully triggered.
Use-after-free in the Linux kernel's USB iowarrior driver exposes systems with Code Mercantile IO-Warrior USB devices to kernel memory corruption, potentially enabling local privilege escalation to root. The defect exists because submitted write URBs are not cancelled during close(), leaving them in-flight at disconnect time; the completion handler then fires against already-freed device structures. No public exploit code has been identified at time of analysis, and EPSS at 0.22% (13th percentile) reflects minimal observed exploitation pressure, though the C:H/I:H/A:H CVSS impact reflects genuine kernel-level consequence.
The Linux kernel's legousbtower USB driver contains a use-after-free race condition between the release() and disconnect() code paths, present since Linux 2.6.25. An authenticated local user with a LEGO USB Tower device attached can trigger the race at disconnect time to corrupt freed kernel memory, potentially gaining elevated privileges or crashing the system. Patches have been issued across all active stable branches (5.10, 5.15, 6.1, 6.6, 6.12, 6.18, 7.1); no public exploit code or CISA KEV listing exists at time of analysis.
Local privilege escalation in the Linux kernel's digi_acceleport USB serial driver allows authenticated local users to corrupt kernel memory and execute arbitrary code as root. The vulnerability arises from a race condition in the digi_write_inb_command() function that mishandles timeouts and incorrectly updates transfer buffers, leading to write buffer corruption. No active exploitation has been reported, and publicly available exploit code has not been identified; a vendor patch is available across multiple stable kernel branches.
Out-of-bounds array read in the Linux kernel's USB Type-C Port Manager (TCPM) svdm_consume_modes() function allows a physically connected malicious USB-C partner device to read kernel memory beyond the svids[] array boundary and force registration of an arbitrary, attacker-chosen SVID via typec_partner_register_altmode(). The vulnerability arises because pmdata->svid_index - which is incremented in response to partner-supplied SVDM messages - is never validated against SVID_DISCOVERY_MAX (16) before indexing pmdata->svids[]. Patches are confirmed available across eight stable kernel branches (5.10 through 7.2-rc3); no public exploit or CISA KEV listing exists at time of analysis.
Use-after-free in the Linux kernel's USB Type-C UCSI CCG driver allows a local attacker with low privileges to corrupt kernel memory, potentially achieving arbitrary kernel code execution. The flaw exists in the module teardown path of the Cypress CCG UCSI driver: ucsi_ccg_remove() calls ucsi_destroy() - which kfree()s the ucsi object - before calling free_irq(), leaving a window in which the threaded IRQ handler ccg_irq_handler() can access the freed ucsi struct via ucsi_notify_common(). No public exploit code exists and the bug was discovered by static analysis; EPSS is 0.22% (13th percentile), reflecting no observed in-the-wild activity.
Out-of-bounds read and write in the Linux kernel's UDF filesystem driver allows a local attacker with the ability to mount a crafted UDF image to escalate privileges to root. The vulnerability stems from the sparing table length being validated as a byte count but consumed as an entry count, leading to memory corruption. No active exploitation (KEV) or public proof-of-concept is currently known, and EPSS estimates a 0.22% chance of exploitation in the next 30 days.
Out-of-bounds write in the Linux kernel Intel QAT (Quick Assist Technology) RSA CRT driver corrupts kernel DMA memory when a local attacker supplies an RSA private key with CRT components larger than half the modulus size. The QAT driver's qat_rsa_setkey_crt() allocates DMA buffers at key_sz/2 but the right-alignment expression `dst + half_key_sz - len` wraps on unsigned underflow when len > half_key_sz, directing memcpy to write attacker-controlled bytes past the DMA allocation. No public exploit code exists at time of analysis; EPSS is 0.22% and the bug has been present since Linux 4.8 across all maintained stable branches.
Out-of-bounds read and write in the Linux kernel exFAT filesystem driver's `exfat_find_dir_entry()` allows a local attacker with low privileges to corrupt kernel heap memory or read adjacent kernel data by mounting or triggering access to a crafted exFAT filesystem image. The bug arises because the `uniname` output pointer advances by a fixed stride of `EXFAT_FILE_NAME_LEN` (15 code units) per TYPE_EXTEND directory entry regardless of actual content length, while the loop guard only checks accumulated `name_len` — a discrepancy a malicious image can exploit indefinitely. No public exploit code and no CISA KEV listing exist at time of analysis; EPSS is 0.22%.
Out-of-bounds read and write in the Linux kernel's synaptics-rmi4 F3A GPIO driver allows local low-privileged users to leak adjacent kernel slab memory to userspace or perform a controlled heap write via the evdev ioctl interface. The root cause is a size mismatch: gpio_key_map is allocated for at most 6 entries while input->keycodemax is set to the full device-reported gpio_count (up to 127), causing the input core's EVIOCGKEYCODE and EVIOCSKEYCODE ioctls to index past the allocation. No public exploit has been identified at time of analysis; EPSS is 0.22%.
Out-of-bounds read and write in the Linux kernel synaptics-rmi4 input driver allows a local attacker with low privileges to gain full root access by exploiting a bound-check flaw in the F30 GPIO/LED interrupt handler. Affects kernels where gpioled_count exceeds 6 and GPIO support is enabled, leading to memory corruption through the EVIOCGKEYCODE/EVIOCSKEYCODE ioctls. No known active exploitation, no public exploit code, and EPSS risk is very low (0.22%).
Stack out-of-bounds write in the Linux kernel Goodix touchscreen driver allows kernel stack memory corruption through a malicious, counterfeit, or physically tampered Goodix I2C touchscreen controller that advertises more than the supported maximum of 10 contact points. All Linux kernel versions from 4.1 through the pre-patch stable series are affected on systems equipped with Goodix GT-series touchscreen hardware; patched releases are available across all active stable branches. No public exploit code exists and no active exploitation has been reported (absent from CISA KEV), with EPSS placing exploitation probability at 0.22%.
Out-of-bounds heap write in the Linux kernel iforce force-feedback input driver allows a physically connected malicious device to corrupt kernel memory. The iforce driver's status packet handler blindly uses a device-supplied effect index masked only to 0-127 as an array subscript into a 32-entry array, enabling `test_and_set_bit`/`test_and_clear_bit` operations up to 95 entries past the array boundary and into trailing kzalloc'd structure members. No confirmed active exploitation exists (not in CISA KEV), and EPSS probability is very low at 0.22% (13th percentile), but successful exploitation against an unpatched kernel yields high confidentiality, integrity, and availability impact at the kernel heap level.
Heap out-of-bounds write in the Linux kernel's touchwin serial touchscreen driver allows a malicious, malfunctioning, or counterfeit Touchwindow peripheral to corrupt kernel heap memory one attacker-chosen byte at a time, potentially enabling local privilege escalation or kernel crash. The flaw exists since Linux 2.6.19 and affects all stable branches through 7.1.3 and pre-7.2-rc1; patched versions have been released across six stable series (5.10.261, 5.15.212, 6.1.178, 6.6.145, 6.12.96, 6.18.39, 7.1.4). EPSS is 0.22% (13th percentile) and no public exploit or CISA KEV listing has been identified, reflecting the niche hardware prerequisite that sharply limits real-world exposure.
A use-after-free in the FUSE subsystem of the Linux kernel allows a local attacker with permission to mount a FUSE filesystem to escalate privileges or crash the system. The vulnerability exists in fuse_ref_folio() due to improper request locking, and affects kernel versions from 2.6.35 through unpatched longterm branches. Patches are available, and no active exploitation or public exploit code has been identified.
Local privilege escalation in Linux kernel's vme_user staging driver via an out-of-bounds write in slave read/write helpers. A local attacker can overflow the fixed-size kern_buf when the VME window exceeds 128 KiB, leading to arbitrary code execution. No active exploitation or public exploit is known, but the vulnerability has been confirmed dynamically with KASAN; EPSS indicates low exploitation probability.
Heap-based out-of-bounds write in the Linux kernel's ntfs3 filesystem driver during journal replay allows local attackers to achieve kernel code execution by mounting a malicious NTFS image. The vulnerability exists because log_replay() does not validate Dirty Page Table capacity against attacker-controlled fields, leading to a slab corruption. No active exploitation or public exploit code has been identified, and the attack requires user interaction to mount a crafted filesystem.
Local privilege escalation in the Linux kernel's SMB client witness notification handler allows a low-privileged attacker to exploit a use-after-free condition. Affected are Linux kernel versions 5.11 and later that have the CIFS witness feature enabled. Successful exploitation can lead to arbitrary code execution with elevated privileges, fully compromising the system.
The Linux kernel writeback subsystem crashes with a use-after-free during container exit due to a race between cgroup_writeback_umount() and inode_switch_wbs(). An in-flight writeback-context switch can pass the SB_ACTIVE check and take an inode reference before the filesystem unmount clears SB_ACTIVE, but delay queuing its work item - causing the umount path to flush a workqueue that has nothing pending, destroy percpu counters via put_super(), and then have the deferred switch work invoke percpu_counter_dec() on freed memory, triggering a BUG_ON or silent UAF. No public exploit is identified at time of analysis; EPSS stands at 0.21% (12th percentile) with no CISA KEV listing.
Use-After-Free in the Linux kernel HID letsketch driver allows local exploitation during device unbind, potentially enabling kernel memory corruption and privilege escalation on affected systems. The letsketch_probe() function arms a per-device kernel timer (inrange_timer) with a 100 ms timeout, but no .remove callback exists to drain the timer before devm cleanup frees letsketch_data and input_dev structures on USB unplug or rmmod, producing a UAF read/write into freed kernel memory. Patches are backported across six stable kernel branches; no public exploit code exists and EPSS is 0.21% (12th percentile), reflecting the niche device requirement and race-condition complexity.
Incorrect RCU lock annotations in the Linux kernel's BPF LPM trie map implementation (`kernel/bpf/lpm_trie.c`) cause lockdep false positives on debug kernels when sleepable BPF programs access `BPF_MAP_TYPE_LPM_TRIE` maps via lookup, update, or delete operations. The mismatch arises because sleepable BPF programs hold `rcu_read_lock_trace()` while the trie code asserts `rcu_read_lock_bh_held()` or `rcu_read_lock_held()`, producing repeated 'suspicious RCU usage' kernel warnings per distinct callsite. The Linux kernel developers explicitly state no actual use-after-free occurs, since Tasks Trace RCU already serializes against trie node reclaim; however, the incorrect annotation undermines lockdep's ability to detect future regressions and is increasingly impactful as sleepable BPF LSM programs become common in production security tooling. No public exploit exists and no CISA KEV listing has been issued.
Use-after-free and memory leak in the Linux kernel's EHCI and FOTG210 USB isochronous submit paths expose systems running kernel versions from 2.6.15 through 7.1.3 to local kernel memory corruption by a low-privileged user. When an isochronous URB submission fails before the staged schedule handoff - either because the host controller becomes inaccessible or usb_hcd_link_urb_to_ep() returns an error - the ehci_iso_sched allocation is not freed and urb->hcpriv retains a dangling pointer, creating a UAF condition. No public exploit exists and the EPSS score is 0.21% (12th percentile), but vendor-released patches across multiple stable branches are available and should be applied to eliminate the risk.
Use-after-free in the Linux kernel USB gadget UDC subsystem exposes systems with DWC3-based USB controllers to a race condition between usb_del_gadget() and gadget_match_driver(), enabling a NULL pointer dereference that can crash the kernel or enable privilege escalation on unpatched systems. The flaw affects all major Linux stable branches from 5.15.x through 7.1.x prior to the patched releases, and is particularly relevant for embedded Linux, Android-based devices, and IoT hardware that use USB gadget/device mode. No public exploit has been identified at time of analysis, and EPSS remains at 0.21% (12th percentile), reflecting current low exploitation interest.
Local privilege escalation in the Linux kernel's I2C subsystem allows a low-privileged local attacker to compromise system integrity, confidentiality, and availability via a race condition during I2C adapter deregistration. The vulnerability affects kernel versions from 2.6.31 up to unpatched releases, with fixes available in stable trees 5.15.212, 6.1.178, 6.6.145, 6.12.96, 6.18.39, 7.1.4, and 7.2-rc1. No public exploit code or active exploitation is currently reported, and EPSS indicates a low exploitation probability (0.21%).