A flaw was found in the Linux kernel's qla2xxx SCSI driver. This vulnerability occurs when commands sent to the firmware (FW) are not properly cleared after a chip reset. A local attacker could exploit a race condition during direct memory access (DMA) unmapping, leading to a kernel panic. This can result in a system crash and a Denial of Service (DoS).

A flaw was found in the `drm/xe` component of the Linux kernel. This vulnerability involves insufficient protection of Graphics Translation Table (GGTT) Memory-Mapped I/O (MMIO) access. When the driver fails to load or during certain cleanup operations, the system's memory access protection is inadequate. This could allow a local attacker to potentially cause the system to become unstable or unresponsive, leading to a denial of service.

A flaw was found in the Linux kernel's drm/xe driver. During 3D workload processing, a user process can trigger an issue in the Virtual Memory Area (VMA) management when performing a rebind operation. This can lead to an invalid or overlapping VMA insertion, causing the system to enter an unstable state and potentially resulting in a Denial of Service (DoS).

A flaw was found in the Linux kernel's AMD GPU (amdgpu) driver. An issue in the `amdgpu_amdkfd_submit_ib` function allows a local user to trigger a use-after-free vulnerability. This occurs because a fence reference is incorrectly released before waiting for job completion, potentially freeing the memory prematurely. This could lead to system instability or denial of service.

A flaw was found in the Linux kernel's i915 graphics driver. A race condition exists between the heartbeat worker and `intel_engine_park_heartbeat()` functions when releasing an engine request. This can lead to a reference count (refcount) underflow, resulting in a use-after-free vulnerability. A local attacker could potentially exploit this to cause a denial of service.

A flaw was found in the Linux kernel's rtnetlink component. An unprivileged local user, leveraging a user namespace, can exploit a missing `CAP_NET_ADMIN` capability check in the `rtnl_newlink()` function. This allows the user to create paired network devices in arbitrary network namespaces, including the `init_net` (initial network namespace). Such unauthorized creation of network interfaces could lead to unexpected network configurations and potential system instability or resource exhaustion.

A flaw was found in the Linux kernel's Bluetooth Security Manager Protocol (SMP). An attacker could exploit this vulnerability during the Bluetooth pairing process by manipulating authentication requirements. This could lead to the selection of a weaker pairing method than intended, potentially allowing a remote attacker to conduct a Man-in-the-Middle (MITM) attack and intercept or alter communications between paired devices.

A flaw was found in the Linux kernel's graphics memory management (drm/i915) component. This vulnerability occurs when a large shared memory object's internal list of memory segments, called a scatterlist, is populated. If the total size of these segments exceeds 4 Gigabytes (GB), a numerical overflow can happen in the length calculation. This issue can cause applications using the affected memory to encounter unexpected errors, potentially leading to system instability or a denial of service.

A flaw was found in the Linux kernel's AMD GPU (amdgpu) driver. This vulnerability involves a timing issue, known as a race condition, during the process of acquiring a Virtual Machine (VM). When multiple processes attempt to access the same VM simultaneously, a local attacker could exploit this flaw. Successful exploitation could lead to an escalation of privileges, allowing unauthorized access or control, or cause the system to become unstable and crash (denial of service).

A flaw was found in the Linux kernel's Stream Control Transmission Protocol (SCTP) diagnostics. When performing a socket diagnostic (sock_diag) lookup, the system may attempt to access memory related to an SCTP association that has already been freed. This can lead to an out-of-bounds read from unrelated memory, potentially allowing an attacker to access sensitive information or cause a system crash.

A flaw was found in the Linux kernel's Bluetooth subsystem. A race condition exists in the handling of the `accept_q` within the `bt_sock_poll()` function due to a lack of synchronization. This could allow a local attacker to cause a denial of service by manipulating socket operations during child teardown, leading to system instability.

A flaw was found in the Linux kernel's `qrtr` network subsystem. A race condition exists in the `qrtr_port_remove()` function where the socket reference count is decremented prematurely. This allows a concurrent reader to access a socket whose reference count has dropped to zero, potentially leading to a Use-After-Free (UAF) vulnerability. An attacker could exploit this to cause memory corruption, leading to system instability or a denial of service.

A flaw was found in the Linux kernel's IOMMU (Input/Output Memory Management Unit) AMD driver. The `clone_alias()` function incorrectly uses the device ID (devid) when handling alias devices. This can lead to the propagation of wrong or stale Device Table Entry (DTE) entries to alias devices, potentially impacting system stability or data integrity.

A flaw was found in the Linux kernel's Bluetooth subsystem. Improper handling of locking within the `hci_conn_request_evt()` function, particularly when the `HCI_PROTO_DEFER` protocol is active, can result in a Use-After-Free (UAF) vulnerability. This condition arises when a connection object is accessed after it has been deallocated, potentially allowing a local attacker to cause a system crash or execute arbitrary code.

A flaw was found in the Linux kernel's handling of Generic Segmentation Offload (GSO) packet headers. This vulnerability occurs when the `qdisc_pkt_len_segs_init()` function does not properly pull headers into the expected memory location, which can lead to incorrect processing by network drivers. A remote attacker could exploit this by sending specially crafted malicious packets, potentially causing a denial of service (DoS) or other unexpected system behavior.

A flaw was found in the Linux kernel's nl80211 Wi-Fi subsystem. The nl80211_parse_rnr_elems() function, responsible for parsing EMA RNR (Enhanced Multiple Access Reduced Neighbor Report) lists, does not properly handle an excessive number of nested NL80211_ATTR_EMA_RNR_ELEMS inputs. This improper input validation could allow a remote attacker to cause a denial of service (DoS) by providing an oversized EMA RNR list, potentially leading to system instability or a crash.

A flaw was found in the Bluetooth subsystem of the Linux kernel, specifically within the `hci_sync` component. This vulnerability occurs when the `hci_adv_bcast_annoucement()` function attempts to prepend Broadcast Announcement service data to an existing advertising payload that is already at its maximum size. This can lead to an oversized data packet that may overrun a temporary buffer, potentially causing a denial of service (DoS) or other unpredictable system behavior.

A flaw was found in the Linux kernel's Stream Control Transmission Protocol (SCTP) implementation. A remote attacker could exploit this by sending a specially crafted COOKIE_ECHO chunk to a listening SCTP server. The server's failure to properly validate the length of a cached peer INIT chunk within the COOKIE_ECHO payload could lead to out-of-bounds reads and memory corruption. This could result in a denial of service or potentially information disclosure.

A flaw was found in the Linux kernel's Bluetooth RFCOMM (Radio Frequency Communication) subsystem. A malicious remote device could exploit this vulnerability by sending specially crafted, truncated Multiplexing Control Channel (MCC) frames. This lack of proper validation of incoming data length before processing could lead to out-of-bounds reads, potentially resulting in information disclosure or a denial of service.

A flaw was found in the Linux kernel's Bluetooth RFCOMM (Radio Frequency Communication) subsystem. A race condition in the rfcomm_connect_ind() function, specifically during the handling of listener sockets, can lead to a use-after-free vulnerability. A local attacker could exploit this to cause a denial of service or potentially achieve arbitrary code execution.

A flaw was found in the Linux kernel. A remote attacker could exploit a use-after-free vulnerability in the Transparent Inter-Process Communication (TIPC) cryptographic decryption process. This flaw occurs when a network namespace, a mechanism for isolating network resources, is deallocated before an asynchronous decryption operation completes. This can cause the system to attempt to read from freed memory, potentially leading to a denial of service (DoS) due to a system crash or information disclosure.

A flaw was found in the Linux kernel's Fibre Channel (FC) transport component. An adjacent Fibre Channel fabric actor, such as a compromised switch or fabric controller, can send a specially crafted FPIN ELS (Fabric Performance Incentive Notification Extended Link Service) frame. This malformed frame, specifically with a `pname_count` field that causes an integer overflow, can trigger an infinite loop, leading to a Denial of Service (DoS) in the affected system.

A flaw was found in the Linux kernel's Bluetooth subsystem. This vulnerability, a Use-After-Free (UAF), allows an attacker to access memory after it has been freed. This can lead to a system crash, resulting in a Denial of Service (DoS), or potentially enable an attacker to execute malicious code. The flaw occurs due to improper handling of connection timeouts during concurrent disconnections.

A flaw was found in the Linux kernel's Bluetooth ISO (Isochronous Stream) subsystem. A race condition exists where the `iso_sock_clear_timer()` function can access connection data without proper locking, while another function, `iso_conn_del()`, concurrently modifies the same data. This can lead to a NULL pointer dereference or use-after-free, which may cause a system crash and result in a denial of service.

A flaw was found in the Linux kernel's Bluetooth ISO (Isochronous Stream) subsystem. This vulnerability, known as a Use-After-Free, occurs because the system attempts to use a memory area after it has been released, which can lead to unpredictable behavior. A malicious actor could potentially exploit this flaw to execute unauthorized code, gaining full control over the affected system.

A flaw was found in the Linux kernel's Bluetooth Human Interface Device Protocol (HIDP). A remote attacker, by sending specially crafted truncated packets from a paired Bluetooth device, could trigger an out-of-bounds read in the `hidp_input_report()` function. This vulnerability may lead to unintended input, such as phantom key presses or spurious mouse movements, potentially affecting system integrity or user interaction.

A flaw was found in the Linux kernel's Stream Control Transmission Protocol (SCTP) implementation. A race condition exists in the sctp_wait_for_connect() function, where a socket lock is temporarily released and re-acquired. During this brief period, another process can move the SCTP association to a different socket. This can cause subsequent operations to access memory incorrectly, potentially leading to system instability or denial of service.

A flaw was found in the Bluetooth L2CAP (Logical Link Control and Adaptation Protocol) component of the Linux kernel. When a device receives a connection response with an already-assigned destination Channel Identifier (CID), the system may crash. This occurs because the kernel's procedure for discarding both channels in this scenario can lead to incorrect channel deletion, causing instability. This vulnerability can be triggered by a remote attacker sending a specially crafted Bluetooth L2CAP packet, potentially leading to a denial of service.

A flaw was found in the Linux kernel's iwlwifi MLD driver. When the Aggregated MAC Service Data Unit (AMSDU) feature is disabled, the driver incorrectly processes Transmit Segmentation Offload (TSO) requests. This can lead to a flood of micro-frames on the transmit ring, resulting in memory corruption and a use-after-free vulnerability. Exploitation of this flaw could allow an attacker to cause system instability or potentially execute arbitrary code.

A flaw was found in the Linux kernel's ixgbevf network driver. This vulnerability, a use-after-free, occurs when the driver attempts to process network packets for a specific multicast workaround. An attacker could potentially exploit this by sending specially crafted network traffic, which may lead to a system crash, resulting in a denial of service, or in some cases, could allow for arbitrary code execution.

A flaw was found in the Linux kernel's mac80211 Wi-Fi subsystem. This use-after-free vulnerability arises from incorrect handling of fast-RX rate data during mesh processing. This can lead to memory corruption, which an attacker could potentially exploit to cause a system crash (denial of service) or, in some cases, execute unauthorized code.

A flaw was found in the Linux kernel's iwlwifi (Intel Wireless WiFi) driver. This vulnerability allows an attacker to cause an out-of-bounds memory access in the WiFi Block Acknowledgement (BA) session handlers. This occurs when the `sta_mask` value is zero, leading to an incorrect station ID calculation and potential system instability or denial of service.

A flaw was found in the Linux kernel's mac80211 Wi-Fi subsystem. This vulnerability arises from incorrect handling of Multi-Link Element (MLE) defragmentation. When a reconf or EPCS (Enhanced Power Save) MLE is present in a non-transmitted profile, the defragmentation routine uses an incorrect pointer. This can lead to a heap data overrun, which is a form of memory corruption that may result in system instability or unexpected behavior.

A flaw was found in the Linux kernel's memory management (mm/khugepaged) component. A local user could trigger an edge case where unsaved changes to file data (dirty folios) are improperly discarded. This occurs when a file with previous writes is subjected to a specific sequence of memory advice (madvise) operations for transparent huge pages (THPs), leading to data loss.

A flaw was found in the Linux kernel's TIPC (Transparent Inter-Process Communication) protocol. A local attacker could exploit this vulnerability by repeatedly creating and failing to insert new sockets, causing the `tipc_sk_create()` function to leave a dangling pointer to a freed socket object. This use-after-free condition can lead to a system crash, resulting in a denial of service, or potentially allow for arbitrary code execution.

A flaw was found in the Linux kernel's drm/xe/pt module. During certain memory management operations, an internal counter is not properly reset. Repeated attempts to perform these operations, possibly due to resource contention or out-of-memory conditions, can cause this counter to exceed its allocated bounds. This leads to an out-of-bounds write and a subsequent use-after-free vulnerability, which can result in a system crash, causing a denial of service.

A flaw was found in the Stream Control Transmission Protocol (SCTP) authentication mechanism within the Linux kernel. The `sctp_auth_chunk_verify()` function incorrectly processes authentication chunks, leading to authentication requirements being silently bypassed. This can occur under specific conditions, such as when memory allocation fails or when an authentication chunk is missing before a COOKIE-ECHO message. An attacker could potentially exploit this to bypass intended security controls.

A flaw was found in the Linux kernel's Stream Control Transmission Protocol (SCTP) implementation. When processing a Stream Reset Incoming Request (RESET_IN_REQUEST) from a peer, the kernel does not properly validate the stream count. This can lead to an integer overflow when calculating the size for the corresponding outgoing request, resulting in an undersized memory allocation. A remote attacker could exploit this vulnerability on interfaces supporting large Maximum Transmission Units (MTU) to trigger a kernel bug, causing a denial of service.

A flaw was found in the Linux kernel's Stream Control Transmission Protocol (SCTP) implementation. An incorrect array size calculation for the `auth_hmacs` field within the `sctp_cookie` structure could lead to a buffer overflow. During the initialization of an SCTP association, if four HMAC identifiers are configured, the system attempts to copy data beyond the allocated buffer. This results in the corruption of an adjacent memory field (`auth_chunks`) and can subsequently cause an out-of-bounds read when processing HMAC identifiers.

A flaw was found in the Linux kernel's Wi-Fi subsystem (cfg80211). The `cfg80211_is_element_inherited()` function does not properly validate the length of extension elements. A remote attacker, by sending a specially crafted Wi-Fi frame from an Access Point (AP), could trigger a one-octet slab-out-of-bounds read during element parsing. This could lead to information disclosure or potentially other impacts.

A flaw was found in the `cfg80211` component of the Linux kernel's Wi-Fi subsystem. This vulnerability allows the PMSR FTM request parser to accept preamble values outside the defined `nl80211` range. An attacker could exploit this by providing malformed input, potentially leading to unexpected system behavior or resource exhaustion.

A flaw was found in the dm-verity component of the Linux kernel. A buffer overflow occurs during Forward Error Correction (FEC) calculation, allowing an attacker to write past the end of an allocated buffer. This out-of-bounds write can corrupt the syndrome buffer, potentially leading to system instability or other undefined behavior.