Linux kernel vulnerabilities

In the Linux kernel, in the s390/vfio_ccw subsystem, there is a lack of range checking for read/write region indexes. The introduction of the capability chain clamped indexes only for capabilities, but not for existing regions.

In the Linux kernel, in the s390/vfio_ccw subsystem, there is an out-of-bounds check on the CCW array. The loop may check a 257th element, which is out of bounds.

In the Linux kernel, in the s390/vfio_ccw subsystem, cleanup of cp resources is performed in fsm_notoper(), which can be called asynchronously while holding other locks. This can lead to deadlocks or malfunction.

In the Linux kernel, in the s390/vfio_ccw subsystem, the scope of io_mutex has been expanded to close remaining synchronization gaps. It also takes advantage of moving cp_free() to a workqueue, allowing safe lock management.

In the Linux kernel, in the s390/vfio_ccw subsystem, there is a lack of locking mechanism for the CRW region, which relies solely on asynchronous hardware events. A lock has been added to ensure consistent reading of the payload list.

In the Linux kernel, the xcrb_msg_to_type6cprb_msgx() function for s390/zcrypt lacks proper input validation, leading to integer overflow, missing minimum size validation, and arithmetic overflow in sum calculations. This can result in undersized buffer allocations, uninitialized memory access, and buffer overflows.

In the Linux kernel, the xcrb_msg_to_type6_ep11cprb_msgx() function for s390/zcrypt lacks minimum size validation, has arithmetic overflow in length calculations, and improper ASN.1 payload parsing. This can lead to uninitialized memory access and buffer overflows.

In the Linux kernel, the zcrypt_msgtype6_send_ep11_cprb() function for s390/zcrypt uses fragile struct overlays to access and modify the domain field in the EP11 CPRB payload, causing maintainability and security concerns. It lacks validation of actual ASN.1 encoding and has error-prone length format detection.

In the Linux kernel, the amdgpu driver's AMDGPU_GEM_CREATE checked domain bits against AMDGPU_GEM_DOMAIN_MASK but did not validate domain combinations. Userspace could combine CPU|GTT|VRAM with DOORBELL, GDS, GWS, or OA, causing amdgpu_bo_placement_from_domain() to exceed AMDGPU_BO_MAX_PLACEMENTS and hit BUG_ON().

In the Linux kernel, the amdgpu driver incorrectly calculates the minimum size for UVD decode images because it uses width instead of pitch. Additionally, it does not reject pitch over 4096, which could lead to overflow.

In the Linux kernel, the amdgpu driver's amdgpu_cs_pass1() does not reject repeated chunk IDs, allowing multiple FENCE chunks in one submit. This causes amdgpu_cs_p1_user_fence() to run twice, overwriting p->uf_bo and leaking a BO reference.

In the Linux kernel, the XFS filesystem's xfs_rtginode_ensure() treats every error from xfs_rtginode_load() other than -ENOENT as success. This can leave the realtime group inode unset after an I/O, allocation, or corruption error, and growfs continues as though the inode had been loaded.

In the Linux kernel, the XFS filesystem has a vulnerability due to an off-by-one error in the validation of the root level of the rtrefcount B-tree. A crafted filesystem image with metadir, realtime, and reflink enabled can cause a slab-out-of-bounds write during mount or recovery, leading to a kernel panic.

In the Linux kernel XFS filesystem, during log recovery, the function xlog_recover_do_reg_buffer() copies data into a buffer based on a dirty bitmap without proper bounds checking. An attacker can supply a crafted filesystem image that causes an out-of-bounds write and corrupts the kernel heap. The issue is fixed by replacing the ASSERT with a real XFS_IS_CORRUPT() check that aborts recovery with -EFSCORRUPTED.

In the Linux kernel XFS filesystem, the function xfs_dq_get_next_id() acquires the ILOCK on the quota inode before calling xfs_iread_extents(). If xfs_iread_extents() fails, the function returns without releasing the lock, causing a lock leak. This can leave the quota inode locked and cause subsequent quota operations to hang.

In the Linux kernel XFS filesystem, the function xrep_tempfile_create can lead to a use-after-free (UAF) if the tempfile creation code fails after setting sc->tempip. The fix addresses this issue.

In the Linux kernel XFS filesystem, during exchange-range operations with the XFS_EXCHMAPS_INO1_WRITTEN flag, the function xmi_can_exchange_reflink_flags() may move the reflink flag to another file, but not all mappings are exchanged, which can lead to clearing the reflink flag on a file that still has shared written extents. This can result in data corruption. The fix disables the reflink flag exchange when XFS_EXCHMAPS_INO1_WRITTEN is requested.

A vulnerability in the Linux kernel's Ceph filesystem can cause read operations to hang indefinitely. The issue stems from an incorrect mds_wanted flag state, where a client may wait forever for FILE_RD rights after they were revoked by the MDS. The patch introduces a bounded wait and forces a synchronous OPEN renew when the required caps are not actually held.

In the Linux kernel, the ASoC tas2562 driver's tas2562_volume_control_put() function does not validate the value written by userspace. This value is used as an index into a fixed-size array, which can lead to buffer overflow and writing incorrect data to the device.

In the Linux kernel, the clk spacemit k3 driver does not mark the HDMA clock as critical. This clock is responsible for the internal TCM access path of the X100 RISC-V core, and turning it off can cause the system to hang, e.g., on a page fault during vector access.

In the Linux kernel, the crypto tegra driver's tegra_gcm_do_one_req() function incorrectly calculates rctx->cryptlen, which can lead to a write beyond the rctx->dst_sg buffer during decryption if ctx->authsize remains zero.

In the Linux kernel, the af_unix function unix_del_edge() does not unlink the scc_entry before freeing the vertex, which can lead to partial freeing of a dead SCC by the garbage collector, causing errors.

In the Linux kernel, the ovpn driver's ovpn_crypto_kill_key function assumes both crypto slots are populated and dereferences each slot before checking it. This can lead to a NULL pointer dereference when a peer has only one key or when the key to be removed is not present.

In the Linux kernel, the perf subsystem's perf_event_open() accepts events in the EXIT state as group leaders, which can lead to use-after-free when the leader is closed and a new sibling retains a pointer to the freed event.

In the Linux kernel's ovpn module, key slot crypto freeing is performed from an RCU callback, which is unsafe because crypto_free_aead can sleep (e.g., for hardware implementations). The fix defers the freeing to a workqueue where sleeping is allowed.

A vulnerability in the Linux kernel netfilter ipset module involves a race condition between list:set garbage collection and set swap operations. The issue causes a reference count decrement on a set whose reference has already moved to another index, leading to a BUG_ON and kernel panic.

In the Linux kernel's IPVS module, ip_vs_nat_icmp() does not revalidate the ihl field after reading from skb fragments, which can lead to out-of-bounds access. A local process can change the ihl field, causing issues in ip_send_check() calls.

In the Linux kernel, the bnxt driver has a deadlock vulnerability when canceling the IRQ affinity notifier. The notifier restarts the queue under the netdev instance lock, and cancellation waits for the callback, causing a deadlock.

In the Linux kernel, the veth interface has a bug in veth_poll that uses an incorrect queue index to wake the peer TX queue. Without an XDP program, the index remains 0, which can lead to a permanent stall of the TX queue and loss of transmission.

In the Linux kernel, the ngbe driver has a NULL pointer dereference vulnerability when enabling interrupts in non-MSI-X mode. In such mode, wx->msix_entry is not allocated, and calling NGBE_INTR_MISC leads to a crash.

In the Linux kernel, the net/sched cls_u32 module has a slab-out-of-bounds read vulnerability in u32_bind_class(). The function does not check whether the object is an hnode, leading to invalid memory access.

In the Linux kernel, the cls_bpf module did not verify that a device-bound (offloaded) eBPF program is bound to the same network interface to which the classifier is being attached. This allowed attaching a program intended for device A to device B, and after deleting device A it caused a system panic.

In the Linux kernel, in the gpio: pca953x driver, the function pca953x_irq_bus_sync_unlock did not hold the i2c_lock during regmap calls, which could lead to incorrect register read/write under concurrent access. A previous patch only protected the write to the interrupt mask register, not the read from the direction register.

In the Linux kernel, in sched_ext, when a sub-scheduler enable fails before scx_link_sched(), the cleanup still runs the full scx_sub_disable(), which can race with root disable and lead to use-after-free. The fix skips the cgroup ownership reset and task walk if the scheduler was never linked.

In the Linux kernel bonding driver (ALB mode), bond_alb_monitor() reads primary_is_promisc under RCU, then drops RCU and takes RTNL via rtnl_trylock() before undoing promiscuity on the active slave. In that window the active slave can change, leading to a null-pointer dereference (kernel panic) or an underflow of the promiscuity counter, leaving the interface in IFF_PROMISC.

In the Linux kernel, in the enic driver, enic_remove does not cancel the tx_hang_reset work, which can lead to use-after-free after free_netdev(). The fix uses disable_work_sync() instead of cancel_work_sync() to block re-scheduling of the work.

In the Linux kernel, in IPVS, the function ip_vs_nat_icmp can write out of bounds because the ihl field in the IPv4 header is read multiple times, and a local attacker can modify the packet during processing. The fix reads ihl only once and uses ciph->len as the offset to the transport header.

In the Linux kernel, the amdxdna_insert_pages() function in the accel/amxdna driver has two error paths that incorrectly call vma->vm_ops->close(vma) before returning an error code. This causes premature resource release, and later unmapping by the process leads to a double close and reference count underflow.

In the Linux kernel BPF subsystem, when handling scalar += pointer in adjust_ptr_min_max_vals(), copying only selected fields of pointer state is fragile because pointer provenance is tracked by several bpf_reg_state fields. The fix uses the caller's temporary offset register to preserve the scalar operand while replacing the destination with the full pointer state.

In the Linux kernel's mlx5 driver, a vulnerability exists where the firmware tracer creation function can return either NULL or ERR_PTR. The return value is stored without a check, and during core dump generation, an invalid pointer is dereferenced, causing a kernel panic.

A vulnerability in the Linux kernel's BPF conntrack kfuncs was found, where the opts argument can point to a shared map value. Inconsistent reads of the netns_id field during acquisition and release of network namespace references can lead to reference imbalance, potentially destroying a live namespace and crashing the system.

A use-after-free vulnerability was found in the Linux kernel's bpf_iter_tcp_established_batch() for TCP_NEW_SYN_RECV sockets. The request_sock is published on the ehash chain before its refcount is set, and the BPF iterator uses plain sock_hold() instead of refcount_inc_not_zero(), leading to a race that overwrites the refcount and causes use-after-free.

A vulnerability in the Linux kernel's vhost_iotlb mechanism allows IOTLB entries to be allocated beyond the configured limit, leading to uncontrolled memory consumption. Affected components include vhost, vDPA, VDUSE, and vhost-vDPA devices that may create tables with zero or no limits. The fix enforces the limit and rejects invalid values.

A type confusion vulnerability was found in the Linux kernel's hwmon driver for PMBus devices. The pmbus_notify() function incorrectly casts different attribute types to sensor_device_attribute, which may lead to an out-of-bounds read or incorrect mask matching during alerts. The fix changes the attribute structures and sets the index to -1 for attributes that do not trigger notifications.

In the Linux kernel, AF_XDP accepts a TX metadata length as small as eight bytes, but every supported request needs flags plus at least one eight-byte field. Such short metadata can let the kernel read beyond the registered area.

In the Linux kernel, AF_XDP launch-time metadata extends beyond the first 16 bytes of struct xsk_tx_metadata. The vulnerability allows rejecting the request when the registered metadata area does not contain the complete field. The fix also snapshots validated flags for the generic transmit path to avoid inconsistent decisions if user space changes flags concurrently.

In the Linux kernel, the zero-copy path validates TX metadata while obtaining the descriptor context, then reads it again later when preparing the hardware request. User space can change the metadata between those operations and bypass the original validation. The fix validates metadata in xsk_tx_metadata_request() and uses the resulting flags snapshot for every feature check.

In the Linux kernel, the sch_cake ACK filter contains a WARN_ON(1) that can be triggered by a malformed IP header. Depending on system configuration, this leads to spamming dmesg with warnings or a panic if panic_on_warn is set. The fix removes the WARN_ON because the code already correctly skips the offending packet.

In the Linux kernel, the vhost-scsi subsystem has a vulnerability due to missing validation of T10 PI scatterlist counts. A malformed request can claim protection bytes that cover or exceed the payload length, leading to a zero data SGL count reaching sg_alloc_table_chained(), which triggers BUG_ON(!nents).

A vulnerability in the Linux kernel's vhost-scsi allows feature changes after endpoint activation, leading to a kernel panic. Enabling T10-PI after setup leaves protection scatterlists uninitialized, triggering a BUG_ON in sg_alloc_table_chained().