A flaw was found in the Linux kernel's Intel Trust Domain Extensions (TDX) guest driver used in confidential computing virtual machines. An untrusted host hypervisor can induce unrecoverable errors during memory decryption, causing the guest kernel to return shared, unencrypted memory back into the general memory allocator. A malicious host can leverage this behavior to access confidential guest memory, resulting in information disclosure or system instability.

A flaw was found in the Linux kernel's Operating Performance Points (OPP) subsystem. A missing index boundary check when querying clock frequencies allows an unprivileged local user to trigger an out-of-bounds read. This flaw can lead to a system crash, resulting in a Denial of Service (DoS), or the potential disclosure of sensitive kernel memory.

A flaw was found in the Linux kernel's Controller Area Network (CAN) broadcast manager (BCM). Improper locking during runtime updates of internal counters in the bcm_can_tx() function allows a local attacker to trigger a slab-out-of-bounds read access. This vulnerability can lead to information disclosure or a denial of service (DoS) condition, potentially compromising system stability or sensitive data.

In the Linux kernel, the following vulnerability has been resolved: calipso: Don't call calipso functions for AF_INET sk. syzkaller reported a null-ptr-deref in txopt_get(). [0] The offset 0x70 was of struct ipv6_txoptions in struct ipv6_pinfo, so struct ipv6_pinfo was NULL there. However, this never happens for IPv6 sockets as inet_sk(sk)->pinet6 is always set in inet6_create(), meaning the socket was not IPv6 one. The root cause is missing validation in netlbl_conn_setattr(). netlbl_conn_setattr() switches branches based on struct sockaddr.sa_family, which is passed from userspace. However, netlbl_conn_setattr() does not check if the address family matches the socket. The syzkaller must have called connect() for an IPv6 address on an IPv4 socket. We have a proper validation in tcp_v[46]_connect(), but security_socket_connect() is called in the earlier stage. Let's copy the validation to netlbl_conn_setattr(). [0]: Oops: general protection fault, probably for non-canonical address 0xdffffc000000000e: 0000 [#1] PREEMPT SMP KASAN NOPTI KASAN: null-ptr-deref in range [0x0000000000000070-0x0000000000000077] CPU: 2 UID: 0 PID: 12928 Comm: syz.9.1677 Not tainted 6.12.0 #1 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.15.0-1 04/01/2014 RIP: 0010:txopt_get include/net/ipv6.h:390 [inline] RIP: 0010: Code: 02 00 00 49 8b ac 24 f8 02 00 00 e8 84 69 2a fd e8 ff 00 16 fd 48 8d 7d 70 48 b8 00 00 00 00 00 fc ff df 48 89 fa 48 c1 ea 03 <80> 3c 02 00 0f 85 53 02 00 00 48 8b 6d 70 48 85 ed 0f 84 ab 01 00 RSP: 0018:ffff88811b8afc48 EFLAGS: 00010212 RAX: dffffc0000000000 RBX: 1ffff11023715f8a RCX: ffffffff841ab00c RDX: 000000000000000e RSI: ffffc90007d9e000 RDI: 0000000000000070 RBP: 0000000000000000 R08: ffffed1023715f9d R09: ffffed1023715f9e R10: ffffed1023715f9d R11: 0000000000000003 R12: ffff888123075f00 R13: ffff88810245bd80 R14: ffff888113646780 R15: ffff888100578a80 FS: 00007f9019bd7640(0000) GS:ffff8882d2d00000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00007f901b927bac CR3: 0000000104788003 CR4: 0000000000770ef0 PKRU: 80000000 Call Trace: <TASK> calipso_sock_setattr+0x56/0x80 net/netlabel/netlabel_calipso.c:557 netlbl_conn_setattr+0x10c/0x280 net/netlabel/netlabel_kapi.c:1177 selinux_netlbl_socket_connect_helper+0xd3/0x1b0 security/selinux/netlabel.c:569 selinux_netlbl_socket_connect_locked security/selinux/netlabel.c:597 [inline] selinux_netlbl_socket_connect+0xb6/0x100 security/selinux/netlabel.c:615 selinux_socket_connect+0x5f/0x80 security/selinux/hooks.c:4931 security_socket_connect+0x50/0xa0 security/security.c:4598 __sys_connect_file+0xa4/0x190 net/socket.c:2067 __sys_connect+0x12c/0x170 net/socket.c:2088 __do_sys_connect net/socket.c:2098 [inline] __se_sys_connect net/socket.c:2095 [inline] __x64_sys_connect+0x73/0xb0 net/socket.c:2095 do_syscall_x64 arch/x86/entry/common.c:52 [inline] do_syscall_64+0xaa/0x1b0 arch/x86/entry/common.c:83 entry_SYSCALL_64_after_hwframe+0x77/0x7f RIP: 0033:0x7f901b61a12d Code: 02 b8 ff ff ff ff c3 66 0f 1f 44 00 00 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 a8 ff ff ff f7 d8 64 89 01 48 RSP: 002b:00007f9019bd6fa8 EFLAGS: 00000246 ORIG_RAX: 000000000000002a RAX: ffffffffffffffda RBX: 00007f901b925fa0 RCX: 00007f901b61a12d RDX: 000000000000001c RSI: 0000200000000140 RDI: 0000000000000003 RBP: 00007f901b701505 R08: 0000000000000000 R09: 0000000000000000 R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000 R13: 0000000000000000 R14: 00007f901b5b62a0 R15: 00007f9019bb7000 </TASK> Modules linked in:

A flaw was found in the Linux kernel's Open vSwitch (OVS) component. A race condition can occur during the destruction of a network device (netdev) tunnel, where the `ovs_netdev_tunnel_destroy()` function may attempt to release a device reference while other parts of the system are still actively using it. This timing issue, or race condition, could lead to system instability or a denial of service (DoS) due to improper resource handling.

A flaw was found in the Linux kernel's vhost subsystem. Specifically, a bug in the `vdpa_sim` component allows for an out-of-bounds write when a valid ASID (Address Space ID) is incorrectly assigned to a vDPA (virtio Data Path Acceleration) group. This could lead to memory corruption, potentially resulting in a denial of service or other system instability.

A flaw was found in the Kernel-based Virtual Machine (KVM) nSVM module of the Linux kernel. This vulnerability occurs when an unhandled VMMCALL is not properly intercepted by the Level 1 (L1) hypervisor. A malicious Level 2 (L2) guest operating system could exploit this by making specific hypercalls, leading to an Undefined Opcode exception (#UD) in the host. This could potentially result in a denial of service for the host system.

A flaw was found in the Linux kernel's RDMA/mlx5 component. An error path fall-through in the `mlx5_ib_dev_res_srq_init()` function, specifically when `ib_create_srq()` fails, can lead to the use of freed memory and error pointers. This memory corruption vulnerability could result in system instability, denial of service, or potentially arbitrary code execution.

A flaw was found in the Linux kernel. A race condition in the `act_ct` module, specifically during the flow table lookup, can lead to a Use-After-Free (UAF) vulnerability. This occurs because a critical lock is released prematurely, allowing a memory object to be freed while still in use. An attacker could potentially exploit this to achieve privilege escalation.

A flaw was found in the Linux kernel's networking scheduler, specifically within the `taprio` module. When the system attempts to switch schedules, a use-after-free vulnerability occurs in the `advance_sched()` function. This happens because a pointer to an old schedule entry is still used after the memory for that entry has been queued for release. An attacker could potentially exploit this memory corruption to cause a denial of service or achieve arbitrary code execution.

A flaw was found in the Linux kernel's networking scheduler. A race condition, which is a problem that occurs when multiple operations try to access the same resource at the same time, exists when network filter operations are run concurrently. This can lead to a Use-After-Free (UAF) vulnerability, where the system attempts to use memory that has already been released. This could potentially allow an attacker to cause system instability or execute arbitrary code.

A flaw was found in the Linux kernel's `af_unix` component. A race condition exists within the `unix_gc()` garbage collection function where the `gc_in_progress` flag may not be correctly set. This could lead to `unix_peek_fpl()` misinterpreting garbage collection status when handling `MSG_PEEK` operations, potentially causing unexpected behavior or information disclosure to a local attacker.

A flaw was found in the Linux kernel's `vsock/virtio` component. This vulnerability occurs during zerocopy completion for large messages fragmented into multiple socket kernel buffers (skbs). An issue in how user arguments (uargs) are handled for these buffers can lead to pinned user pages not being properly tracked or released. This prevents the kernel from notifying userspace when these memory pages are safe to reuse, potentially leading to memory leaks or data corruption if pages are prematurely reallocated. This issue could lead to local privilege escalation.

A flaw was found in the Linux kernel's Filesystem in Userspace (FUSE) component. The `fuse_try_move_folio()` function, responsible for managing page cache folios, fails to re-lock a request after initially unlocking it on a successful path. This oversight allows another function, `fuse_chan_abort()`, to prematurely free critical input/output arguments (`fuse_io_args`). Consequently, subsequent operations attempting to access these freed arguments can lead to a use-after-free vulnerability, potentially allowing an attacker to cause a system crash or execute arbitrary code.

A flaw was found in the Linux kernel's Network File System Daemon (NFSD). The nfsd4_decode_secinfo_no_name() function does not properly initialize a pointer (sin_exp) before processing an incoming data stream. If the data stream is malformed or truncated, the uninitialized pointer can retain stale data from previous operations. This can lead to an improper cleanup operation, potentially causing system instability or a denial of service.

A flaw was found in the Linux kernel's Kernel-based Virtual Machine (KVM) module, specifically within the Secure Virtual Machine (SVM) component. The `sev_dbg_crypt()` function, when handling encryption, incorrectly calculates the transfer length, leading to a page overflow. This memory corruption can result in a use-after-free condition. A local attacker could exploit this vulnerability to cause a denial of service or potentially escalate privileges.

A flaw was found in the Linux kernel's USB serial mxuport driver. A malicious Universal Serial Bus (USB) device could exploit this vulnerability by reporting a bulk-out endpoint maximum packet size smaller than eight bytes. This can lead to user-controlled slab corruption, potentially allowing an attacker to achieve arbitrary code execution.

A flaw was found in the Linux kernel's USB Type-C Port Manager (TCPM) driver. A remote attacker, acting as a malicious USB-C port partner, could exploit an out-of-bounds write vulnerability in the svdm_consume_modes() function. By sending an unsolicited 'Discover Modes ACK' with excessive data, the attacker can cause memory corruption. This could lead to a denial of service or potentially arbitrary code execution on the affected system.

A flaw was found in the Linux kernel's vsock/virtio transport. This vulnerability occurs when the system processes zerocopy socket buffers (skbs) and encounters an error during memory allocation for fixed-buffer vectored data. The system may attempt to free memory incorrectly, leading to a use-after-free condition or memory corruption. This can potentially allow a local attacker to cause a denial of service or escalate their privileges on the system.

A flaw was found in the Linux kernel's vfio/pci subsystem. This vulnerability occurs because the Direct Memory Access Buffer (DMABUF) export mechanism does not adequately verify if Base Address Register (BAR) resources are properly reserved before allowing access. A local attacker could exploit this by exporting a DMABUF, potentially gaining unauthorized access to unreserved system resources. This could lead to information disclosure or other unintended system behavior.

A flaw was found in the `vsock/vmci` component of the Linux kernel. A remote attacker could exploit a Use-After-Free (UAF) vulnerability when a peer resets a connection during the handshake process. This occurs because the system incorrectly handles reset packets, leading to a pending socket being left in an invalid state. Exploiting this flaw could cause a system crash, resulting in a Denial of Service (DoS).

A flaw was found in the Linux kernel's Intel Ethernet controller driver (idpf). This vulnerability occurs because a critical synchronization mechanism, known as a spinlock, is accessed before it has been properly initialized. An attacker could potentially exploit this timing issue to cause the system to become unstable or crash, leading to a Denial of Service (DoS).

A flaw was found in the Linux kernel's `i2c-stub` driver. A local user with access to the `/dev/i2c-*` device can exploit this vulnerability by issuing an I2C System Management Bus (SMBus) input/output control (ioctl) command with a specially crafted block transfer length. This invalid length can cause the driver to read or write beyond the allocated buffer, leading to a stack-out-of-bounds error and a system crash, resulting in a Denial of Service (DoS).

A flaw was found in the Linux kernel's FUSE (Filesystem in Userspace) component. The `fuse_ref_folio()` function does not properly re-lock a request after unlocking it, which can lead to a use-after-free vulnerability. A local attacker could exploit this flaw to potentially execute arbitrary code or cause a denial of service.

A flaw was found in the Linux kernel's `fsl-lpspi` driver. This vulnerability occurs when the transmit (TX) Direct Memory Access (DMA) channel fails to prepare, but the receive (RX) DMA channel continues to operate. This can lead to memory corruption or a use-after-free condition, potentially allowing an attacker to compromise system integrity or execute unauthorized code.

A flaw was found in the Linux kernel's ALSA sound driver for the cs35l41 component. This vulnerability occurs because the driver fails to properly remove controls and cancel firmware load work during component unbinding or device removal, especially when firmware autostart is disabled. This can lead to a worker attempting to access driver data that is no longer valid after teardown, resulting in memory corruption. An attacker with local access could potentially exploit this to cause a denial of service or escalate privileges.

A flaw was found in the Linux kernel. This vulnerability involves an incomplete defense against Spectre-v2, a type of attack that can expose sensitive information by exploiting how modern processors predict future operations. Specifically, when the Berkeley Packet Filter (BPF) Just-In-Time (JIT) compiler was active, the system did not adequately clear the processor's branch prediction buffer during BPF JIT memory reuse. This could potentially allow an attacker to bypass existing Spectre-v2 protections, leading to the unauthorized disclosure of information.

A flaw was found in the Linux kernel's Berkeley Packet Filter (BPF) Just-In-Time (JIT) compiler. The BPF JIT allocator reuses memory space, and when new code is written, an indirect jump into the new program can reuse a branch prediction left behind by an old program. This could allow an attacker to bypass security hardening mechanisms, potentially leading to information disclosure or other impacts. The vulnerability is mitigated by flushing indirect branch predictors before reusing JIT memory.

A flaw was found in the `drm/amdgpu/vce` component of the Linux kernel. Malicious VCE (Video Codec Engine) command streams with oversized dimensions can cause a 32-bit integer overflow. This overflow bypasses validation, allowing the GPU firmware to perform out-of-bound memory access. This could lead to system instability or potentially arbitrary code execution.

A flaw was found in the Open vSwitch component of the Linux kernel. This vulnerability arises from an underflow condition when handling Generic Segmentation Offload (GSO) packets in userspace. A length calculation error can lead to a buffer underflow when data is processed by the `skb_zerocopy()` function. This issue could result in memory corruption, potentially leading to a denial of service or other unpredictable system behavior.

A flaw was found in the Linux kernel's SLIP (Serial Line Internet Protocol) network component. A race condition exists during an MTU (Maximum Transmission Unit) change when the system reallocates receive buffers. This can allow a remote attacker to trigger an out-of-bounds write or write to a freed memory region, potentially leading to a denial of service or arbitrary code execution.

A flaw was found in the Linux kernel's ALSA (Advanced Linux Sound Architecture) sequencer component. An unprivileged local user with access to the sound device can exploit a timing window during the cleanup of a queue timer. This allows the user to re-open a timer that has already been closed, leading to a use-after-free vulnerability. This can result in a system crash (denial of service) or potentially lead to arbitrary code execution.

A flaw was found in the Linux kernel's drm/amd/display component. Specifically, within the `dm_update_crtc_state()` function, a stream pointer is released but not subsequently set to NULL. This can lead to a double release of the same pointer if an error occurs later in the process, creating a use-after-free vulnerability. This issue could potentially lead to memory corruption or a denial of service.

A flaw was found in the `drm/amdgpu` component of the Linux kernel. A use-after-unlock vulnerability exists where a virtual machine (VM) pointer is dereferenced after its protective lock has been released. This allows the pointer to be modified, potentially leading to memory corruption. An attacker could exploit this to cause a denial of service or achieve privilege escalation.

A flaw was found in the Linux kernel's DisplayPort (DP) Multi-Stream Transport (MST) subsystem. This vulnerability involves multiple buffer overflows within the `drm_dp_sideband_append_payload()` function when handling data from connected devices. A physically connected, malicious DP MST device can exploit this by sending specially crafted messages, leading to memory corruption. This could potentially allow an attacker to cause system instability or execute unauthorized code.

A flaw was found in the Linux kernel's `act_tunnel_key` module, which manages network traffic tunneling. A race condition, where multiple operations occur in an unpredictable order, can lead to a use-after-free vulnerability. This allows a local attacker to corrupt memory, potentially causing the system to crash and resulting in a denial of service (DoS).

A flaw was found in the Linux kernel's overlayfs component. When copying files across different overlay filesystems, the system incorrectly checked read permissions using the destination filesystem's credentials instead of the source's. This oversight could allow an unauthorized user to read files that should otherwise be restricted, leading to information disclosure.

A flaw was found in the Linux kernel's iSCSI target core. This use-after-free vulnerability occurs in the `core_scsi3_emulate_pro_register_and_move()` function. When processing iSCSI TransportIDs, a memory buffer is prematurely unmapped while still being referenced, particularly when the parameter list spans multiple pages. An attacker could potentially exploit this to cause a system crash, leading to a denial of service.

A flaw was found in the KVM (Kernel-based Virtual Machine) arm64 vgic (Virtual Generic Interrupt Controller) component of the Linux kernel. During interrupt migration, the vgic_prune_ap_list() function temporarily drops and reacquires locks. If an interrupt is removed from the active processor list (ap_list) during this unlocked period, a subsequent check for interrupt affinity may still pass, leading to a double deletion of the interrupt from the list. This double free-like condition could potentially lead to system instability or denial of service.

A flaw was found in the Linux kernel's SUN Remote Procedure Call (SUNRPC) implementation. A use-after-free vulnerability exists in the Transport Layer Security (TLS) connection path. When a TLS handshake fails, the client resource can be prematurely freed, leading to a subsequent attempt to access the freed memory. This can result in a system crash, causing a denial of service.

A flaw was found in the Linux kernel's Transparent Inter-Process Communication (TIPC) version 2 component. This vulnerability allows a local unprivileged attacker to bypass administrative permission checks when performing network link operations. Consequently, the attacker can modify critical TIPC network configurations, such as network and node identities, manage key material, and control UDP bearers. This unauthorized access could lead to significant disruption or compromise of network communication.

A flaw was found in the Linux kernel's Bluetooth subsystem. Specifically, the `hci_sync` component, which manages Bluetooth advertising data, is susceptible to a Use-After-Free (UAF) vulnerability. This occurs when a pointer to advertising data becomes invalid but is still accessed, particularly during interleaved advertising termination and command synchronization events. An attacker could potentially exploit this memory corruption to cause a denial of service (DoS) or other system instability.

A flaw was found in the Linux kernel's Bluetooth management (mgmt) component. A race condition exists during the cancellation of a pairing command and the handling of pairing completion or authentication failure callbacks. This race condition can lead to a use-after-free vulnerability, which may allow a local attacker to cause a denial of service or potentially achieve privilege escalation.

A flaw was found in KVM (Kernel-based Virtual Machine). When the Advanced Virtual Interrupt Controller (AVIC) is inhibited while a nested guest (L2) is active, KVM fails to properly update x2APIC MSR intercepts for the primary guest (L1). This allows the L1 guest to read the host's APIC state, send arbitrary interrupts, and change task priority, ultimately leading to a Denial of Service (DoS) of the host system.

A flaw was found in the Linux kernel's dmaengine IDXD subsystem. A race condition during file-device setup failure cleanup in the idxd_cdev_open() function could lead to a deadlock, causing a denial of service. Furthermore, incorrect cleanup paths could result in operations on a freed memory context, potentially allowing a local attacker to escalate privileges.

A flaw was found in the Advanced Linux Sound Architecture (ALSA) usx2y driver in the Linux kernel. A local attacker, by opening the hwdep node of an attached US-X2Y device, could exploit an unbounded memory mapping (mmap) fault offset. This allows read-write access to arbitrary kernel memory, potentially leading to a denial of service (kernel crash) or privilege escalation.

A flaw was found in the Linux kernel's UDP (User Datagram Protocol) tunnel segmentation. This vulnerability arises when the system attempts to process network packets, specifically in the __skb_udp_tunnel_segment() function. An attacker could potentially exploit a use-after-free condition, where the system attempts to use memory that has already been released, leading to system instability or potentially arbitrary code execution.

A flaw was found in the netfilter flowtable component of the Linux kernel. This vulnerability occurs due to a timing issue where the system's garbage collection can free a network flow while it is still being set up. This can lead to a 'use-after-free' condition, where the system attempts to access memory that has already been released. This memory corruption could potentially result in a system crash (denial of service) or, in certain circumstances, allow for arbitrary code execution.

A flaw was found in the Linux kernel's `af_unix` component. A race condition during concurrent `send()` and `close()` operations can lead to the garbage collector (GC) partially freeing a Strongly Connected Component (SCC). This inconsistent state may cause subsequent GC operations to iterate over a partially freed entry, potentially leading to system instability or a denial of service.

A flaw was found in the Linux kernel's XFS filesystem. A local attacker, by mounting a specially crafted XFS image, could trigger an out-of-bounds write during log recovery. This vulnerability allows for kernel heap corruption, which could lead to a denial of service or potentially arbitrary code execution.

A flaw was found in the Linux kernel's USB subsystem (usbfs). An unprivileged local attacker with read/write access to a /dev/bus/usb node could exploit a use-after-free vulnerability. This occurs because the usb_device structure is prematurely freed before all pending operations are completed. Successful exploitation of this memory corruption flaw could lead to a system crash or potentially privilege escalation.

A flaw was found in the `drm/vmwgfx` component of the Linux kernel. An integer overflow vulnerability exists in the `vmw_shader_define()` function due to improper validation of user-supplied shader window size and offset. When the offset value is close to its maximum, an unsigned addition can wrap around, causing the size check to pass incorrectly. This allows an unbounded offset to be used, which could lead to memory corruption and potentially privilege escalation or denial of service.

A flaw was found in the Linux kernel's KVM s390 Virtual Shared Inter-Partition Emulation (VSIE) component. When shadowing crypto access bits from a format0 apcb, stale crypto bits were not properly cleared. This oversight could allow a nested guest to potentially access a device that should no longer be available, leading to unauthorized information disclosure or access to resources.

A flaw was found in the Linux kernel's TUN/TAP driver. An integer underflow vulnerability exists in the tun_get_user() function when processing oversized headroom requests. This can occur if Open vSwitch (OVS) propagates an excessively large headroom request to the TUN or TAP device. Successful exploitation could lead to memory corruption, where network packet data is written outside its intended buffer, potentially causing a denial of service or other system instability.

A flaw was found in the Linux kernel's AF_IUCV (Advanced Program-to-Program Communication over IUCV) network protocol implementation. The `afiucv_hs_rcv()` function, responsible for receiving frames, does not properly filter incoming frames based on the ingress network device. This oversight allows a local attacker with specific network capabilities or a host on the same HiperSockets segment to send specially crafted frames. Successful exploitation can lead to a Denial of Service (DoS) by exhausting the accept-queue, injecting data into existing sockets, and disrupting established connections.

A flaw was found in the `svcrdma` component of the Linux kernel. A remote attacker can exploit this vulnerability by supplying a crafted `RPC/RDMA Read chunk position` field that is not properly validated against the received inline body length. This can lead to an underflow, exposing adjacent slab memory or allowing data to be copied past the receive buffer into request pages. The most significant impact is information disclosure, potentially leading to memory corruption.

A flaw was found in the Linux kernel's svcrdma component, which handles network communication using Remote Direct Memory Access (RDMA). A remote attacker can send a specially crafted network reply that is larger than expected. This can cause the system to write data beyond the intended memory area, leading to memory corruption. This vulnerability could allow an attacker to cause a denial of service or potentially execute arbitrary code.

A flaw was found in the Linux kernel. A race condition exists where a seccomp filter, intended to restrict system calls, can be bypassed by an unprivileged process. This occurs when a thread is stopped for tracing (ptrace) and another thread attempts to apply a seccomp filter with the `SECCOMP_FILTER_FLAG_TSYNC` flag. Due to a caching issue, the newly installed filter is not properly enforced, allowing the unprivileged process to execute system calls that should have been blocked, potentially leading to a security bypass.

A flaw was found in the Linux kernel's Server Message Block (SMB) client. A remote malicious SMB server could send a specially crafted tree connect response with a byte count that is too small. This incorrect handling can lead to an integer underflow, causing the client to read beyond an allocated memory buffer. Consequently, sensitive information from kernel memory may be exposed to a local user through the `/proc/fs/cifs/DebugData` interface.

A flaw was found in the Linux kernel's Network File System Daemon (nfsd). This vulnerability arises from improper handling of "copy-notify stateids" during their revocation. When a stateid's reference is dropped without unlinking it, the memory can be freed while still in use by a reader, leading to a use-after-free condition. This can cause system instability and potentially allow for unauthorized access.

A flaw was found in the `nfsd` component of the Linux kernel. A use-after-free vulnerability exists due to improper initialization of the copy-notify state ID before its publication. A remote attacker could exploit this by sending a crafted `OFFLOAD_CANCEL` operation, leading to a race condition that frees the state ID prematurely. This could result in a use-after-free, potentially allowing for arbitrary code execution or denial of service.

A flaw was found in the Linux kernel's nfsd component. A race condition exists during asynchronous copy cancellation and shutdown operations, which can lead to a Use-After-Free (UAF) vulnerability. This allows an async copy object to be freed or used after being freed, potentially causing memory corruption and system instability. This issue arises when a teardown caller races with the copy kernel thread, leading to incorrect memory management.

A flaw was found in the Linux kernel's Network File System Daemon (nfsd) component. When performing an asynchronous (async) copy operation, a programming error causes a stale identifier (IDR) entry to point to memory that has already been reused. This can lead to memory corruption, where the system attempts to access or free invalid memory. Such an issue could result in system instability or a denial of service (DoS), making the system unavailable to legitimate users.

A flaw was found in the Linux kernel's Network File System (NFS) daemon, `nfsd`. A remote attacker could exploit a use-after-free vulnerability in the `nfsd4_sequence()` function. This occurs when the system attempts to reduce the number of active session slots while a client is still using one of the slots being freed. Successful exploitation leads to memory corruption, which can result in a denial of service or other system instability.

A flaw was found in the `nfsd` component of the Linux kernel. This vulnerability, a use-after-free, occurs when a specific memory buffer is prematurely released while another process is still trying to access it. This timing issue can lead to memory corruption. This could result in a system crash (denial of service) or potentially allow an attacker to gain elevated privileges.

A flaw was found in the Linux kernel's Kernel-based Virtual Machine (KVM) for arm64 systems. This issue arises when the system's Memory Management Unit (MMU) is inactive, causing an internal calculation for memory translation buffers (TLB) to misinterpret a negative value. This leads to an incorrect determination of the memory region size for invalidation, resulting in an incomplete cleanup of these buffers. Such an incomplete invalidation could lead to unexpected memory behavior within the virtualized environment.

A flaw was found in the Linux kernel's vfio/pci component. During device initialization, a memory pointer is not properly cleared after being freed, leading to a use-after-free and double-free vulnerability. A local attacker could exploit this flaw to cause a system crash, resulting in a denial of service, or potentially execute arbitrary code with elevated privileges.

A flaw was found in the Linux kernel's perf subsystem. A race condition exists between the perf mmap() revival and the last munmap() operation. This allows a local unprivileged user to exploit a use-after-free vulnerability, leading to local privilege escalation to root.

A flaw was found in the Linux kernel's drm/amdkfd component. This vulnerability arises from a race condition where the Micro Engine Scheduler (MES) fails to perform a necessary Translation Lookaside Buffer (TLB) invalidation after unmapping queues. This oversight allows in-flight Direct Memory Access (DMA) descriptors to access memory that has already been unmapped, leading to page faults and potential GPU queue hangs, particularly during Shared Virtual Memory (SVM) page migration.

A flaw was found in the Linux kernel's cx231xx media driver. A local attacker can exploit this vulnerability by manipulating video and Vertical Blanking Interval (VBI) queue operations. This allows for a heap out-of-bounds write, which could lead to arbitrary code execution or a denial of service.

A flaw was found in the `nvmet-auth` component of the Linux kernel. A timing issue during the cleanup of a Submission Queue (SQ) can lead to a use-after-free vulnerability. This occurs when a delayed authentication task attempts to access memory that has already been released or repurposed. An attacker could potentially exploit this to cause a system crash (denial of service) or other memory corruption impacts.

A flaw was found in the NVMe (Non-Volatile Memory Express) driver of the Linux kernel. The nvme_alloc_ns() function's error handling path fails to wait for all SRCU (Sleepable Read-Copy Update) readers to complete before freeing a namespace structure. This oversight allows a concurrent reader to access a freed memory region, leading to a use-after-free vulnerability. A local attacker could potentially exploit this to cause a system crash or achieve arbitrary code execution.

A flaw was found in the Linux kernel's megaraid_sas component. The `megasas_make_prp_nvme()` function, which constructs a list of memory pages for data transfers, fails to verify the allocated buffer's boundaries. This can result in a buffer overrun, potentially leading to a system crash (Denial of Service) or silent corruption of data belonging to other active commands.

A flaw was found in the Linux kernel's iSCSI target component. An unauthenticated remote attacker can exploit this vulnerability by sending a specially crafted login payload to an iSCSI portal configured for Challenge-Handshake Authentication Protocol (CHAP). This can lead to an out-of-bounds read, potentially resulting in information disclosure from adjacent memory or a denial of service.

A flaw was found in the Linux kernel's Network File System Daemon (NFSD). A use-after-free vulnerability can occur during the blocked-lock reaping process. This happens when a client's lock owner, without a proper reference to keep the client alive, leads to the client being prematurely freed. This can result in memory corruption when the system attempts to access freed memory, potentially leading to a denial of service or arbitrary code execution.

A flaw was found in the Linux kernel's NVMe (Non-Volatile Memory Express) input/output control (ioctl) handling. An unprivileged local user could exploit this vulnerability by bypassing access checks in the `NVME_IOCTL_SUBMIT_IO` function. This allows them to perform unauthorized I/O operations on a partition device or write to a read-only file descriptor, potentially leading to privilege escalation or unauthorized data modification.

A flaw was found in the Linux kernel's SUNRPC (Sun Remote Procedure Call) component. Improper handling of credential data during the decoding process can lead to a dangling pointer, a form of memory corruption. This issue may allow a remote attacker to cause a denial of service by triggering early decode failures, leading to incorrect state management and potentially system instability.

A flaw was found in the Linux kernel's Remote Procedure Call over Remote Direct Memory Access (RPC-over-RDMA) server component (svcrdma). A remote peer can exploit this issue by transmitting a malformed Write or Reply chunk with a segment count of zero. Because the kernel fails to validate that the segment count is greater than zero, it accepts and links degenerate chunk structures onto internal processing lists. This flaw may result in unexpected memory traversal or a Denial of Service (DoS).

A flaw was found in the Linux kernel. A local attacker can cause a Denial of Service (DoS) or potentially escalate privileges through a use-after-free vulnerability in the RAID-5 Partial Parity Log (PPL) component. During flush operations, the system improperly continues to access an input/output (I/O) tracking structure after it has already been released. This memory corruption can destabilize the operating system and cause the kernel to crash.

A flaw was found in the Linux kernel's netfilter subsystem. When a network namespace is dismantled, the packet logging component frees memory without waiting for ongoing logging operations to complete, resulting in a use-after-free condition. A local attacker could exploit this flaw during network traffic processing to cause a system crash, leading to a Denial of Service (DoS), or potentially execute arbitrary code.

A flaw was found in the Linux kernel's performance events (perf) subsystem. This vulnerability occurs because memory allocated for event address filters is released prematurely while still in active use by other kernel processes. A local user could exploit this use-after-free flaw during performance monitoring operations to cause a Denial of Service (DoS) through a system crash or potentially corrupt system memory.

A flaw was found in the Linux kernel's virtio-fs file system driver. When queue initialization fails—such as when a device advertises more request queues than supported—the driver fails to clear memory pointers after releasing them, resulting in a double-free condition during error cleanup. An attacker capable of presenting a malformed virtio-fs device can exploit this flaw to cause memory corruption, leading to a system crash and Denial of Service (DoS).

A flaw was found in the Linux kernel's encrypted keys subsystem. An integer overflow occurs during memory size calculations for key data, resulting in an undersized buffer allocation. A local user can exploit this issue by supplying crafted key data to trigger an out-of-bounds write to kernel memory. This flaw can lead to a system crash, resulting in a Denial of Service (DoS), or potentially allow privilege escalation.

A flaw was found in the Linux kernel's signal handling subsystem. A race condition occurs during process execution when managing pending timer signals, allowing the system to reference memory after it has been released. A local attacker could exploit this use-after-free flaw to achieve privilege escalation or trigger a system crash resulting in a Denial of Service (DoS).

A flaw was found in the Linux kernel. When a multi-threaded program sets up a per-thread timer and executes a new program that subsequently fails during startup, the kernel can free timer memory while it remains referenced in an active queue. A local user could exploit this vulnerability to trigger a use-after-free condition, leading to a system crash and Denial of Service (DoS) or potential privilege escalation.

A flaw was found in the Linux kernel's netfilter subsystem. In the flowtable component, connection tracking reference counts are prematurely released before flow entries are fully removed from memory. An attacker could exploit this timing issue during network flow processing, triggering a use-after-free condition. This issue primarily leads to a Denial of Service (DoS) via a system crash or unexpected system instability.

A flaw was found in the Linux kernel's IPsec (XFRM) networking subsystem. A race condition occurs when creating policy bundles while a network device is concurrently removed, leading to a use-after-free condition where the kernel accesses already-freed device memory. A local attacker can exploit this flaw to potentially escalate privileges or cause a Denial of Service (DoS) by crashing the system.

A flaw was found in the Linux kernel's IPv4 networking subsystem. A race condition occurs during concurrent processing of retransmitted Transmission Control Protocol (TCP) connection requests or socket migrations, allowing socket options to be freed while still in use. A remote attacker could exploit this vulnerability by sending specially timed network requests, triggering a use-after-free condition. This could results in system crash leading to a Denial of Service (DoS), memory corruption, or remote code execution.

A flaw was found in the Linux kernel's NVMe over Fabrics (NVMe-oF) target authentication component. A remote attacker connecting to the NVMe target service can exploit this vulnerability by sending a crafted authentication request, causing a Denial of Service (DoS) through a system crash or potential memory corruption. This issue occurs due to an incorrect buffer size calculation during authentication challenge processing, which allows an undersized buffer to bypass validation checks and results in an out-of-bounds write.

A flaw was found in the Linux kernel's XFS file system. This vulnerability allows a local user to cause unauthorized data modification or potential privilege escalation by bypassing Copy-on-Write (CoW) protections. When exchanging file data ranges up to the end of a file, the file system incorrectly calculates file sizes and leaves shared blocks in an inconsistent state. Consequently, a local attacker can directly overwrite shared data blocks belonging to other files without triggering required copy-on-write protections.