CVE-2025-39704 is a vulnerability in the Linux kernel's KVM subsystem for LoongArch architecture. It involves a stack protector issue in the send_ipi_data() function due to a buffer overflow caused by improper handling of an 8-byte buffer parameter. This flaw can lead to kernel stack corruption and a kernel panic when stack protection is enabled.
CVE-2025-39700 is a vulnerability in the Linux kernel's memory management subsystem (mm/damon/ops-common) where the function damon_migrate_pages() attempts to migrate pages to invalid NUMA nodes. This can cause a kernel BUG and lead to a kernel crash (Oops) when users issue invalid migration requests via DAMOS_MIGRATE_{HOT,COLD} actions. The issue is fixed by adding a validity check for the target node in damon_migrate_pages().
CVE-2025-39708 is a medium severity vulnerability in the Linux kernel's media iris driver involving a NULL pointer dereference. The flaw was identified by static analysis (smatch) where an argument to the function iris_hfi_gen2_handle_system_error could be null, leading to a potential crash. The issue was fixed by adding a null check before accessing the argument's members.
CVE-2025-39712 addresses a deadlock vulnerability in the Linux kernel media driver for the mt9m114 device. The issue occurs in the get_frame_interval and set_frame_interval functions, where locks are improperly acquired both in the V4L2 subdev core and again within the driver, causing a deadlock. The fix involves removing redundant lock acquisitions in the driver code, aligning with the documented responsibility that the caller manages locking.
A null pointer dereference vulnerability was identified and resolved in the Linux kernel's AMDGPU driver. The issue occurs because the HUBBUB structure is not initialized on DCE hardware, leading to a potential null dereference when accessing the amdgpu_dm_capabilities file in debugfs. This flaw could cause a denial of service due to kernel crash.
CVE-2025-39723 is a high-severity vulnerability in the Linux kernel's netfs subsystem related to unbuffered write error handling. When all subrequests in an unbuffered write stream fail, the system incorrectly returns a large transferred value (LONG_MAX) instead of an error, leading to kernel NULL pointer dereference and potential system crash. The issue was discovered during testing with CIFS and fixed by properly tracking the validity of transferred values and initializing them correctly.
CVE-2025-39722 addresses a vulnerability in the Linux kernel's crypto CAAM driver for iMX8QM and iMX8ULP SoCs. The issue causes a system crash during suspend operations due to improper handling of a reserved register page (page 0) managed by a separate ARM core (SECO or Secure Enclave). The fix introduces a new state variable to track if page 0 is reserved and adjusts suspend/resume checks accordingly to prevent the crash.
CVE-2025-39717 is a high-severity vulnerability in the Linux kernel related to the open_tree_attr system call. It involves improper restrictions on changing id-mappings without the OPEN_TREE_CLONE flag, allowing detached mounts to have their id-mappings altered. This can lead to use-after-free (UAF) and locking issues. The vulnerability arises from a bug in a previous patch that intended to restrict id-mapping changes to only cloned mounts. The flaw does not affect attached mounts due to additional checks. No specific affected versions are stated. The CVSS score is 7.8, indicating a high impact on confidentiality, integrity, and availability.
CVE-2025-38733 is a vulnerability in the Linux kernel on s390 architecture where the lowcore memory region is improperly mapped with identity mapping at address zero. This causes the lowcore to be mapped twice if the relocate_lowcore option is used, allowing NULL pointer accesses to succeed instead of triggering exceptions. The issue is fixed by preventing the first two pages of physical memory from being mapped with identity mapping.
CVE-2025-38737 is a medium severity vulnerability in the Linux kernel's CIFS module caused by an uninitialized variable leading to a kernel oops (crash). The issue arises because the smb3_init_transform_rq() function does not initialize a buffer pointer before passing it to netfs_alloc_folioq_buffer(), which expects a NULL pointer to start a fresh buffer. This flaw can cause a denial of service due to kernel instability.
CVE-2025-39679 is a medium severity vulnerability in the Linux kernel's drm/nouveau/nvif component. It involves a potential memory leak in the nvif_vmm_ctor() function when an invalid nvif_vmm_type is encountered. The issue occurs because the function returns an error without freeing allocated arguments, leading to resource leakage. This flaw has been fixed by properly setting the error return value and ensuring cleanup is performed.
CVE-2025-39678 is a medium severity vulnerability in the Linux kernel's platform/x86/amd/hsmp component. It involves a NULL pointer dereference caused by accessing a metrics_bin when the metric table address (sock->metric_tbl_addr) is not allocated. This issue can lead to a denial of service (system crash).
CVE-2025-39695 is a vulnerability in the Linux kernel's RDMA/rxe subsystem related to the handling of delayed socket buffers (SKBs) during resource release. The issue arises because SKB packets depend on RXE resources such as queue pairs and sockets when they are destroyed. If these resources are released prematurely while SKB packets are still being processed, call traces (errors) can occur. A timestamp mechanism was introduced to track SKB packet age and allow network devices to free them if they hang too long, preventing resource hangs.
CVE-2025-39680 is a high-severity vulnerability in the Linux kernel's i2c rtl9300 driver. It involves an out-of-bounds bug in the rtl9300_i2c_smbus_xfer function caused by improper validation of user-controlled data->block[0]. This can lead to memory corruption. The issue has been fixed by adding proper checks on the data->block[0] value.
CVE-2025-39690 is a medium severity vulnerability in the Linux kernel's Industrial I/O (iio) subsystem, specifically in the sca3300 accelerometer driver. The flaw involves uninitialized scan data that could lead to leakage of stack data to userspace. The issue is addressed by zeroing the channels array before use to prevent potential information leakage.
CVE-2025-39674 is a medium severity vulnerability in the Linux kernel's UFS Qualcomm driver (ufs-qcom) that causes a null pointer dereference during Enhanced System Interrupt (ESI) configuration. The flaw arises from improper cleanup of MSI resources when MSI allocation fails, leading to a kernel crash. The issue has been fixed by restructuring the ESI configuration logic to allocate MSI resources first and using explicit cleanup to avoid freeing unallocated resources.
CVE-2025-39696 is a vulnerability in the Linux kernel ALSA hda driver for the tas2781 device. A wrong reference to tasdevice_priv was introduced during calibration data management unification, causing memory corruption and potential crashes. The issue arises because a void pointer was incorrectly assigned, which the compiler could not detect. This vulnerability has been resolved in the Linux kernel.
CVE-2025-38731 is a high-severity vulnerability in the Linux kernel's drm/xe component involving a double free bug in the vm_bind_ioctl function. The flaw occurs when an argument check during an array bind fails, causing the bind_ops structure to be freed twice. This issue has been fixed by setting bind_ops to NULL after freeing it to prevent the double free. The vulnerability can lead to memory corruption with potential confidentiality, integrity, and availability impacts.
In the Linux kernel, the following vulnerability has been resolved:
net: hibmcge: fix the division by zero issue
When the network port is down, the queue is released, and ring->len is 0.
In debugfs, hbg_get_queue_used_num() will be called,
which may lead to a division by zero issue.
This patch adds a check, if ring->len is 0,
hbg_get_queue_used_num() directly returns 0.
A general protection fault vulnerability in the Linux kernel's hfs_find_init() function can cause a system crash when a NULL tree pointer is dereferenced. This issue leads to a kernel oops and denial of service. The vulnerability has been fixed in recent kernel updates.