In the Linux kernel, the following vulnerability has been resolved: keys: make keyring key-chunk byte order agree with keyring_diff_objects() keyring_get_key_chunk() loads description bytes into the index chunk low address first, while keyring_diff_objects() numbers the first differing bit from the low end and folds the absolute byte index into the level without removing the inline-prefix offset the level already carries. The two disagree on byte order and bit position, so the array can be told two keys first differ at a bit that does not differ in the chunk the walker uses, letting crafted descriptions collide into one node. Load the chunk in the order keyring_diff_objects() assumes and drop the inline-prefix length when folding the byte index into the level. This only changes the in-memory ordering used to place keys within a keyring; add, search and read of non-colliding keys are unaffected.
In the Linux kernel, the following vulnerability has been resolved: keys: fix out-of-bounds read in keyring_get_key_chunk() For description-level chunks keyring_get_key_chunk() advances the read pointer by level * sizeof(long) past the inline prefix but only bounds-checks the prefix, so a long enough key description is read past its kmemdup(desc, desc_len + 1) allocation. Compute the full byte offset and bounds-check the description against it before reading. The walk only reaches a description-level chunk when two keys collide through the hash, x, type and domain_tag chunks, so this is reached from an unprivileged add_key(2) with a crafted pair of same-type keys whose index hashes collide; KASAN reports a slab-out-of-bounds read.
In the Linux kernel, the following vulnerability has been resolved: can: peak_usb: add bounds check for USB channel index The channel control index ctrl_idx is derived from rx->len which comes directly from a device USB payload. The mask 0x0f allows values 0-15, but the array size of usb_if->dev[] is only 2. Values 2-15 cause heap out-of-bounds read, eventually causing kernel panic in the IRQ context. Add bounds checking for ctrl_idx before the array access in both pcan_usb_pro_handle_canmsg() and pcan_usb_pro_handle_error().
In the Linux kernel, the following vulnerability has been resolved: ALSA: usb-audio: fix stack info leak in RME Digiface status snd_rme_digiface_read_status() reads a four-word status block from the device into an uninitialised on-stack __le32 buf[4] and, whenever the vendor control-IN transfer does not return a negative error, copies all four words into the caller's status[]. snd_usb_ctl_msg() copies the full requested size back into the caller's buffer regardless of how many bytes the data stage actually delivered: buf = kmemdup(data, size, GFP_KERNEL); err = usb_control_msg(dev, pipe, request, requesttype, value, index, buf, size, timeout); memcpy(data, buf, size); usb_control_msg() returns the transferred length on a short control-IN, which is a non-negative value, and writes only that many bytes. The remainder of the copy back is the kmemdup()ed image of the caller's buffer, so a device answering with a short data stage leaves the trailing words of buf[] holding leftover kernel stack. The only guard in the caller is err < 0, so those words are stored into status[]. They then reach user space: snd_rme_digiface_get_status_val() selects a 16-bit halfword of status[] per the control's reg/mask, and the eight Digiface status controls together expose the whole 16-byte frame to an unprivileged reader of /dev/snd/controlC*. Zero-initialise the buffer so a short read yields zeros instead of stack residue. This mirrors snd_rme_get_status1(), which already clears its output word before the same kind of vendor read. Discovered by XBOW, triaged by Baul Lee <baul.lee@xbow.com>
In the Linux kernel, the following vulnerability has been resolved: riscv: mm: Fix out-of-bounds page-table walk during memory hot-remove remove_pud_mapping() and remove_p4d_mapping() obtain a child table base with pud_offset(p4dp, 0) and p4d_offset(pgd, 0), then add the index for addr. RISC-V folds page-table levels at runtime. When a level is folded, its offset helper returns the parent entry itself, but the index can still be nonzero. Adding it walks past the parent table. Sv48 folds P4D, while Sv39 folds both P4D and PUD, so memory hot-remove can descend into unrelated memory and pass an invalid page to __free_pages(). This can trigger: kernel BUG at include/linux/mm.h:1810! VM_BUG_ON_PAGE(page_ref_count(page) == 0) arch_remove_memory+0x1e/0x5c try_remove_memory+0x15e/0x200 remove_memory+0x24/0x3c Only add the index when the corresponding page-table level is enabled, matching p4d_offset() and pud_offset().
A speculative memory read vulnerability was identified and fixed in the Linux kernel's s390/zcrypt component. The issue involved a user-controlled domain value used as an array index without a speculation barrier, potentially allowing speculative execution to read unintended memory. The vulnerability affects Linux kernel version 5.18. A patch has been applied to add the missing speculation barrier, mitigating the risk.
A vulnerability in the Linux kernel's vhost subsystem was fixed, addressing incorrect behavior in the vhost_get_avail_idx function. This function incorrectly reported whether all entries in a ring buffer had been consumed, which could cause a livelock condition in the host when mergeable buffers were enabled and the guest was not making progress. The issue was introduced by changes in how the avail index was cached and compared. The fix ensures vhost_get_avail_idx correctly reports updates to the available index.
A vulnerability in the Linux kernel's mlx5 network driver related to Link Aggregation Group (LAG) handling was fixed. The issue involved an off-by-one error in the rollback logic during single-FDB error handling, which could cause operations on uninitialized state or double teardown of rules. This flaw was corrected by adjusting the rollback loop to start from the correct index. The vulnerability affects specific Linux kernel versions and has a CVSS score of 7.8, indicating a high impact on confidentiality, integrity, and availability. A patch is available to address this issue.
A vulnerability in the Linux kernel's ocfs2 filesystem was fixed to address an out-of-bounds array access triggered by corrupted inode embedded extent lists. The flaw caused a UBSAN panic due to invalid indexing when l_next_free_rec was zero or exceeded the count, potentially leading to on-disk corruption. The fix validates the inode's embedded extent list during read operations to reject corrupt lists before unsafe indexing occurs.
CVE-2026-72129 is a critical vulnerability in the Linux kernel's nvmet-rdma subsystem related to handling inline data with a nonzero offset. The flaw arises from improper mapping of inline data offsets when the inline_data_size exceeds the system page size, causing an integer underflow that leads to an excessively large length value. This results in the block backend reading memory beyond the intended inline page boundary. The issue is fixed by correctly splitting the offset into page index and in-page offset, ensuring proper scatterlist mapping and preventing erroneous memory access.
A high-severity vulnerability in the Linux kernel's cxl/region driver allows out-of-bounds memory access due to improper handling of an index variable in the cxl_cancel_auto_attach() function. The flaw arises when cxled->pos is set to a negative error code but is used directly as an array index, leading to invalid memory access.
CVE-2026-74411 is a vulnerability in the Linux kernel's rtw89 Wi-Fi driver where an incorrect data type for the scan index caused an infinite loop during Wi-Fi scanning on the 6GHz band. This results in a kernel soft lockup, causing the CPU to become stuck for over 20 seconds and potentially leading to a system panic. The issue occurs in the function rtw89_hw_scan_add_chan_ax due to the scan index counter overflowing and not terminating the loop properly. The vulnerability has been fixed in multiple Linux kernel versions.
CVE-2026-74383 is a high-severity vulnerability in the Linux kernel's nvme-pci driver. It involves an out-of-bounds array access in the nvme_setup_descriptor_pools function caused by improper handling of the NUMA node index when the kernel is configured without NUMA support. This can lead to a kernel fault during NVMe namespace allocation, potentially causing system instability or denial of service. The issue affects specific Linux kernel versions prior to 7.0.0-1014.14~24.04.1 and similar builds. A patch is available that corrects the parameter type and defaults to node 0 when NUMA is not enabled.
A critical vulnerability (CVE-2026-74361) in the Linux kernel's NVMe driver was fixed by correcting a bounds check error in the fdpcidx validation logic. The flaw involved an incorrect comparison operator that allowed an out-of-bounds index to be accepted, potentially leading to system compromise. This issue affects multiple Linux kernel versions prior to 7.0.0 updates and has been addressed in the 7.0.0 series kernel releases. The vulnerability has a high CVSS score of 9.8, indicating severe impact on confidentiality, integrity, and availability. No known exploits in the wild have been reported. Users should apply the official patches and reboot to mitigate the risk.
A vulnerability in the Linux kernel's ixgbe driver was fixed to prevent configuration of XPS for XDP Tx queues, which are not netdev-exposed. On systems with 64 or more CPUs using the E610 adapter, configuring XDP could cause a kernel warning and a KASAN slab-out-of-bounds error due to an out-of-range queue index. This issue has been resolved by skipping XPS configuration for XDP Tx queues.
CVE-2026-74312 is a high-severity vulnerability in the Linux kernel's vhost/vdpa subsystem where the virtqueue index used in mmap and fault paths is not properly validated. This flaw allows out-of-range queue indices to reach driver-specific callbacks, potentially causing out-of-bounds access, invalid page frame number remaps, and system crashes or denial of service. The issue has been fixed by consolidating and enforcing proper bounds checking in a unified helper function. Multiple Linux kernel versions prior to fixed releases are affected.
CVE-2026-74296 is a high-severity vulnerability in the Linux kernel's RDMA/mlx5 subsystem where the hardware-provided UAR index was not properly released, instead the software one was freed. This flaw has been fixed in multiple Linux kernel versions starting from 6.8.0-147.147 and others. The vulnerability could allow an attacker with local privileges to cause a high impact on confidentiality, integrity, and availability. The issue is addressed by releasing the correct hardware-provided UAR index. No known exploits are reported in the wild.
CVE-2026-74295 is a vulnerability in the Linux kernel's ASoC hdac_hdmi codec driver where an out-of-range enum value is used to index an array before validation, potentially causing a read past the array bounds. This issue was fixed by reordering the validation to occur before the array lookup. The vulnerability affects multiple versions of the linux-azure kernel prior to specific fixed releases. It has a high severity with a CVSS score of 7.1 and impacts confidentiality and availability. No known exploits in the wild have been reported. Patches are available in the fixed kernel versions.
A critical vulnerability in the Linux kernel's Marvell OcteonTX cryptographic driver was fixed. The issue involved incorrect DMA cleanup using the wrong loop index, causing some DMA buffers to be leaked and others to be unmapped repeatedly. This flaw could lead to memory corruption and privilege escalation. Multiple Linux kernel versions prior to 5.15.0-1117.124~20.04.1 and related builds are affected. A patch is available and has been released in fixed kernel versions.