By weakness (CWE)

CWE-401: related vulnerabilities

CVEs classified under CWE-401. Understanding the weakness class helps prioritize systemic fixes over one-off patches.

72 published vulnerabilities

• CVE-2026-46303HIGH 8.2

  A vulnerability exists in the Linux kernel's ISO 9660 filesystem (isofs) Rock Ridge extension handler. When processing a specially crafted ISO image, the kernel fails to validate that continuation extent block numbers fall within the mounted volume's boundaries. An attacker with the ability to mount a malicious ISO—either through unprivileged auto-mounting via udisks2 on a desktop, or through privileged mount access—can cause the kernel to read data from arbitrary blocks on the same device. While memory safety is preserved because out-of-range reads cleanly fail, reads into adjacent filesystems can leak directory metadata through symbolic link text exposed to userspace. This is a validation gap in an existing security check that should have been closed alongside prior CE (continuation extent) fixes.

• CVE-2026-46178HIGH 7.8

  A resource management flaw exists in the Linux kernel's RDMA/mlx4 subsystem where memory allocated for Shared Receive Queues (SRQs) is not properly freed when the queue creation process encounters an error. This leaked memory accumulates over time, potentially degrading system performance or causing denial of service if the condition is repeatedly triggered. The issue affects systems using the Mellanox InfiniBand adapter driver on Linux.

• CVE-2026-46201HIGH 7.8

  A memory management flaw exists in the Linux kernel's display driver for Intel Xe graphics. When importing external memory buffers (dma-buf), the kernel fails to properly clean up an attachment if initialization of the buffer object encounters an error. This leaves orphaned kernel resources and can be exploited by a local user to cause denial of service or potentially escalate privileges.

• CVE-2026-52923HIGH 7.8

  A memory safety bug in the Linux kernel's IPC (Inter-Process Communication) subsystem allows a local attacker with limited privileges to cause a denial of service or potentially leak sensitive information. The vulnerability exists in how the kernel allocates System V IPC identifiers during checkpoint/restore operations. When the valid ID space becomes full, the kernel can mistakenly allocate IDs beyond the legitimate range, creating orphaned memory references that may be accessed later through proc filesystem enumeration, leading to use-after-free conditions.

• CVE-2026-10699HIGH 7.5

  Progress MOVEit Transfer's Custom Reports modules contain a memory leak vulnerability that can be exploited to exhaust system resources and cause the application to become unavailable. An attacker on the network can trigger this condition without authentication, leading to a denial of service. The issue affects specific versions released in 2025 and early 2026.

• CVE-2026-13474HIGH 7.5

  A denial-of-service vulnerability exists in Citrix NetScaler ADC and NetScaler Gateway when HTTP/2 support is enabled. An unauthenticated attacker can send specially crafted HTTP/2 requests to crash or disable the appliance, causing service interruptions without needing valid credentials or user interaction.

• CVE-2026-13698HIGH 7.5

  OpenVPN has a memory leak vulnerability affecting versions 2.5.0 through 2.5.11, 2.6.0 through 2.6.20, and 2.7_alpha1 through 2.7.4. An attacker with a valid tls-crypt-v2 client key can trigger this leak repeatedly, eventually exhausting server memory and causing the VPN service to become unavailable. The vulnerability requires network access and a legitimate cryptographic key, but no user interaction is needed to exploit it.

• CVE-2026-13708HIGH 7.5

  A memory leak vulnerability in Imager::File::JPEG (and the bundled Imager distribution) allows attackers to cause denial of service by uploading specially crafted JPEG files containing repeated APP13 markers. Each time the file is read, the application fails to free memory from previous APP13 payloads, causing heap memory to accumulate and eventually exhaust available system resources. This is particularly dangerous in long-lived services like image upload handlers or thumbnail generators that process many files over time.

• CVE-2026-35505HIGH 7.5

  CVE-2026-35505 is a remote memory leak vulnerability that allows unauthenticated attackers to trigger uncontrolled memory growth in affected services. By repeatedly sending specially crafted connection requests, attackers can exhaust memory resources, causing single-process deployments to crash and become unavailable until manual restart. The vulnerability requires no authentication, no special privileges, and can be triggered over the network without user interaction.

• CVE-2026-46679HIGH 7.5

  A flaw in the @libp2p/gossipsub library allows a single attacker to remotely crash any gossipsub node running the default configuration by exhausting its heap memory. No authentication is required—the attacker needs only network access to the target node. This denial-of-service attack exploits three related implementation gaps that compound to trigger excessive memory allocation. The vulnerability affects libp2p versions prior to 15.0.23 and has been patched.

• CVE-2026-48006HIGH 7.5

  Netty's Redis message aggregator has a memory leak that can crash applications. When a Redis client closes its connection mid-request, the handler doesn't clean up buffered data, leaving memory fragments locked in the heap. Attackers can exploit this by repeatedly opening and closing connections, slowly poisoning the shared memory pool until the entire application runs out of buffer space and fails to handle new network traffic.

• CVE-2026-48059HIGH 7.5

  Netty, a widely-used Java framework for building networked applications, contains a memory leak in its HAProxy PROXY protocol v2 decoder. When a client sends a specially crafted but valid header containing nested SSL metadata records, the decoder fails to properly release the underlying memory buffer. This happens silently—no errors are reported, the connection appears to handle normally, and the leak accumulates with each affected connection. Over time, this can exhaust server memory and cause denial of service. The issue affects Netty versions before 4.1.135.Final and 4.2.15.Final.

• CVE-2026-50254HIGH 7.5

  CVE-2026-50254 is a memory leak vulnerability in storescp that allows an attacker to remotely trigger service degradation without authentication. By sending repeated crafted connection requests, an attacker can exhaust memory until the service crashes and stops accepting new connections. Recovery requires manual operator intervention to restart the service. The vulnerability affects the default single-process deployment mode.

• CVE-2026-52974HIGH 7.5

  A memory leak exists in the Linux kernel's TLS (Transport Layer Security) implementation that occurs when the system attempts to offload TLS processing to network hardware and the operation fails. Specifically, when the kernel tries to hand off TLS decryption work to a hardware accelerator and encounters an error, it fails to properly release a temporary data buffer (called an anchor skb) that was allocated during setup. This buffer is never freed, causing memory to leak. The vulnerability only manifests when hardware offload initialization fails; successful offloads and normal connection closures do not trigger the leak.

• CVE-2026-52981HIGH 7.5

  A memory leak has been identified in the Linux kernel's neighbor table networking subsystem. The vulnerability exists in the `neigh_xmit()` function, which is responsible for transmitting network packets through the kernel's neighbor discovery mechanism. Under specific conditions—particularly when a neighbor table is not initialized (such as when IPv6 is disabled but the function is still called)—the function returns an error without properly freeing the associated network buffer (SKB). This means memory is consumed and never released, potentially exhausting system memory over time.

• CVE-2026-53087HIGH 7.5

  A memory leak exists in the Linux kernel's Broadcom GENET network driver. When the driver cleans up the transmit queue during error recovery or shutdown, it discards frames still in flight but fails to return the associated memory buffers back to the free pool. This causes those buffers to become unavailable for reuse, gradually depleting the driver's ability to transmit new data until the system may become unresponsive or crash.

• CVE-2026-53229HIGH 7.5

  A memory leak vulnerability exists in the Linux kernel's mlx5e network driver, specifically in the XSK (AF_XDP zero-copy socket) transmission path. When the driver attempts to transmit an XDP frame but fails because its transmit queue is full, it neglects to release DMA mappings and free the frame buffer. Over time, this causes accumulated DMA memory leaks that are particularly visible when the driver is unloaded. The vulnerability is triggered during normal XDP_TX operations on systems using Mellanox network adapters with AF_XDP sockets.

• CVE-2026-56018HIGH 7.5

  JavaScript::Minifier::XS is a Perl module that compresses JavaScript code. Versions before 0.16 have a memory leak bug: every time the minify() function runs, it fails to properly free memory used for processing tokens. In server environments where minification happens repeatedly—like web asset pipelines or API endpoints that minify on demand—this leak causes the process to consume more memory with each request. Eventually the server runs out of memory and crashes, disrupting service. The vulnerability requires no authentication or user interaction; an attacker can trigger it by simply making repeated minification requests.

• CVE-2026-53132HIGH 7.1

  A flaw in the Linux kernel's vsock (virtual socket) transport layer could allow an attacker to exhaust system memory by flooding the network queue with malformed packets. An attacker with local access can craft packets with zero payload length but marked as end-of-message (EOM), bypassing the kernel's normal quota checks. Because these packets consume almost no actual data bytes, the kernel's safeguards fail to detect the buildup, allowing an unbounded number of empty packets to accumulate in the receive queue. This eventually starves legitimate network traffic and system processes of available memory, causing a denial of service.

• CVE-2026-46309HIGH 7.0

  CVE-2026-46309 is a memory access control flaw in the Linux kernel's GPU driver (xe) that can leak sensitive data. When a privileged process uses a low-coherency GPU memory mode on CPU-cached buffers, the GPU can bypass CPU caches and read stale data directly from RAM—including sensitive information from previously freed memory of other processes. The fix validates GPU memory configuration requests to prevent this dangerous combination.

• CVE-2026-13593MEDIUM 6.5

  CSS::Minifier::XS is a Perl library that compresses CSS code by removing unnecessary characters like whitespace and comments. Versions before 0.14 contain a memory leak that occurs specifically when the minify function processes CSS files that consist entirely of removable content—essentially documents that should compress to nothing. This causes the application to consume memory that is never released, potentially degrading performance over time if such documents are processed repeatedly.

• CVE-2026-56116MEDIUM 6.5

  dhcpcd, a widely-used DHCP client daemon on Unix-like systems, contains a memory leak flaw in how it processes IPv6 Router Advertisements. An attacker on the same network link can repeatedly send specially crafted Router Advertisements to exhaust the daemon's memory, eventually crashing it and disrupting network connectivity. The attacker needs no credentials and the traffic stays local to the link, making this a concern primarily for shared networks or systems where untrusted devices can reach the same link segment.

• CVE-2026-57027MEDIUM 6.5

  Juniper Junos OS running on EX4100 and EX4400 Series switches contains a memory leak in the packet forwarding engine when sFlow monitoring is enabled in a Virtual Chassis configuration. When multicast traffic crosses between chassis members, memory accumulates and is never freed, eventually exhausting buffer capacity and crashing the forwarding processor. An attacker on the adjacent network segment can trigger this condition repeatedly to deny service to the affected switch.

• CVE-2026-41840MEDIUM 5.9

  Spring WebFlux applications running affected versions of Spring Framework contain a denial-of-service vulnerability triggered by specially crafted multipart requests. An unauthenticated remote attacker can exploit this to disrupt application availability without requiring special network access or user interaction. The vulnerability affects a wide range of Spring Framework versions spanning multiple release lines, making it broadly relevant to organizations using Spring-based web services.

• CVE-2026-46109MEDIUM 5.5

  A memory leak exists in the Linux kernel's USB ULPI (UTMI Low Pin Interface) driver registration code. When certain initialization steps fail early in the device registration process, allocated memory is not properly freed, allowing memory to accumulate over repeated failures. This is a residual issue from a prior fix that addressed a different memory safety problem. The vulnerability requires local access and elevated privileges to trigger.

• CVE-2026-46141MEDIUM 5.5

  A memory leak vulnerability exists in the Linux kernel's PowerPC XIVE interrupt handling code. When allocating MSI-X interrupt vectors for NVMe devices, the kernel creates interrupt data structures but fails to properly clean them up when the interrupt domain is freed. This occurs because the code looks for the data in the wrong place during cleanup, causing allocated memory to be abandoned. While this is a localized memory management issue, repeated device allocation and deallocation cycles could gradually consume system memory and degrade performance.

• CVE-2026-46143MEDIUM 5.5

  CVE-2026-46143 is a memory leak vulnerability in the Linux kernel's QCOM audio subsystem. The issue occurs in the ASoC (ALSA System on Chip) driver for QCOM Q6APM LPASS audio interfaces, where the prepare function can be invoked multiple times. Each invocation opens a new graph for the playback path without checking if one is already open, resulting in cumulative resource exhaustion. While the vulnerability requires local access and low-privilege execution context, the impact is availability disruption through memory exhaustion.

• CVE-2026-46147MEDIUM 5.5

  A flaw in the Linux kernel's ARM64 KVM (virtualization) implementation can cause system resource leaks and expose partially initialized virtual CPU objects to concurrent access. When vCPU initialization encounters an error partway through, cleanup code fails to release pinned memory references, accumulating leak over time. Additionally, the vCPU object is published to shared state without proper synchronization barriers, risking observers seeing an incompletely initialized structure. This affects hypervisor deployments using ARM64-based KVM virtualization.

• CVE-2026-46151MEDIUM 5.5

  A flaw in the Linux kernel's USB printer driver (usblp) allows a malicious or malfunctioning printer to leak uninitialized kernel memory to local users. When a printer responds to a device ID request with fewer bytes than claimed in its length header, the driver fails to zero out the remaining buffer before exposing it via sysfs or an ioctl. An attacker with local access could craft a printer (or intercept USB traffic) to trigger this and read sensitive kernel memory.

• CVE-2026-46171MEDIUM 5.5

  A memory leak exists in the Linux kernel's RISC-V KVM (virtualization) subsystem. When the kernel attempts to allocate memory for virtual CPU vector context during guest setup, it allocates two separate memory blocks. If the second allocation fails, the first block is not freed, causing a memory leak. This leak occurs in unprivileged code paths and can gradually exhaust kernel memory, leading to system denial of service.

• CVE-2026-46182MEDIUM 5.5

  A vulnerability in the Linux kernel's IBM POWER Systems (pseries) PAPR hypervisor pipe driver allows uninitialized kernel memory to be exposed to unprivileged users. When the driver copies a header structure to userspace, it fails to zero out reserved padding fields within that structure, inadvertently leaking sensitive kernel data. An attacker with local access could read this leaked memory to potentially gather information about the running kernel state.

• CVE-2026-46207MEDIUM 5.5

  A flaw in the Linux kernel's vsock/virtio module causes monitoring tools to receive incomplete data when handling certain network packets. Specifically, when the kernel processes non-linear network buffers for the virtual socket monitoring interface (vsockmon), it fails to properly initialize a data structure that controls how much information gets copied. This leaves monitoring tools unable to see the full payload of these packets, potentially obscuring network activity. The issue affects local processes with standard privileges and could be exploited to hide data from network inspection.

• CVE-2026-46221MEDIUM 5.5

  A memory leak exists in the Linux kernel's EDAC (Error Detection and Correction) versalnet driver. When the driver initializes memory controller devices, it allocates memory for a device name string but fails to properly free it during normal driver removal. The kernel's device registration process copies the name internally and then loses track of the original allocation, leaving orphaned memory that cannot be reclaimed. This gradually consumes system memory over repeated device initialization and removal cycles.

• CVE-2026-46224MEDIUM 5.5

  A memory leak vulnerability exists in the Linux kernel's DRM (Direct Rendering Manager) Xe driver. When the driver attempts to initialize a DMA buffer object and encounters an allocation failure, it fails to properly clean up a pre-allocated buffer object, causing it to leak into memory. The vulnerability requires local system access and affects the kernel's ability to manage GPU memory correctly. While this is not a critical security issue, it can lead to denial of service through memory exhaustion over time.

• CVE-2026-46228MEDIUM 5.5

  A memory management flaw in the Linux kernel's SPI CH341 USB driver can cause memory to persist after the driver is unloaded, potentially leading to denial of service. The issue arises because device resources tied to a USB driver are incorrectly managed at the parent device level rather than at the individual interface level, preventing proper cleanup when drivers unbind without physical device disconnection.

• CVE-2026-47326MEDIUM 5.5

  Ubuntu Linux versions 6.8, 6.17, and 7.0 contain a memory leak flaw in how the kernel handles large responses from AppArmor (the mandatory access control framework). An unprivileged local user can trigger this leak repeatedly, causing the system to exhaust available memory and potentially become unstable or unresponsive. The vulnerability requires local access and does not compromise data confidentiality or integrity, but can degrade or deny service to legitimate users.

• CVE-2026-52904MEDIUM 5.5

  A memory leak exists in the Linux kernel's Nouveau graphics driver. During the device initialization process, if a specific system configuration check fails, the driver fails to properly clean up an allocated device object, leaving resources dangling in kernel memory. This is a kernel-level resource exhaustion issue that can be triggered by unprivileged users on affected systems.

• CVE-2026-52937MEDIUM 5.5

  A vulnerability in the Linux kernel's tap network interface driver leaks sensitive kernel memory to unprivileged local users. When a user queries the hardware address of a tap or macvtap device using standard network tools, the kernel copies an incompletely initialized data structure to userspace, inadvertently disclosing 8 bytes of kernel stack contents. On systems running macvtap, this leak can expose kernel code pointers and direct-map memory addresses, undermining KASLR (kernel address space layout randomization) protections and providing attackers with information useful for exploiting other vulnerabilities.

• CVE-2026-52996MEDIUM 5.5

  A resource leak vulnerability exists in the Linux kernel's SMB server implementation (ksmbd). When a client attempts to reconnect to a file using durable handle version 2, the server may fail to properly release a reference to a file descriptor if the client's identifier doesn't match what's stored on the server. This causes server memory and file table entries to accumulate over time, potentially degrading performance or causing denial of service as the system exhausts resources.

• CVE-2026-53030MEDIUM 5.5

  A memory leak vulnerability exists in the Linux kernel's Renesas i3c master driver. When the driver processes i3c transfer operations, it allocates internal data structures that are never properly freed, causing memory to accumulate over time. This can lead to denial of service if an attacker with local access repeatedly triggers the affected code path, eventually exhausting system memory and causing the kernel to become unstable or crash.

• CVE-2026-53060MEDIUM 5.5

  CVE-2026-53060 is a memory leak in the Linux kernel's device mapper cache subsystem. When the cache metadata system attempts to abort operations while the underlying block manager is in read-only mode, it fails to release a temporary block manager object, causing memory to accumulate. This occurs specifically during certain cache device table reload and resume operations. The leak is triggered by a sequence of suspend/resume cycles combined with metadata I/O errors, which can occur in production environments when cache devices encounter transient or permanent storage faults.

• CVE-2026-53065MEDIUM 5.5

  A memory resource leak has been identified in the Linux kernel's STi audio driver. When the driver is loaded and unloaded, certain internal data structures are not properly cleaned up, allowing memory to accumulate over time. While this doesn't directly compromise data or enable unauthorized access, repeated driver loads and unloads can degrade system stability and consume available memory resources. The fix is straightforward: the kernel team updated the code to use automatic resource management, ensuring these structures are freed when the driver is no longer needed.

• CVE-2026-53079MEDIUM 5.5

  A memory leak exists in the Linux kernel's network packet scheduling subsystem. When the kernel defers cleanup of dropped packets, a mechanism designed to optimize performance can fail to free memory properly if certain conditions aren't met. Specifically, if a network queue (qdisc) doesn't have the TCQ_F_DEQUEUE_DROPS optimization flag enabled, packets marked for deletion get stranded in memory instead of being released. This causes the kernel to gradually consume more memory over time as network traffic is processed, potentially leading to system slowdown or denial of service if memory exhaustion occurs.

• CVE-2026-53102MEDIUM 5.5

  A memory leak vulnerability exists in the Linux kernel's MediaTek WiFi driver (mt76) where allocated memory is not properly freed when certain operations fail during station configuration. The vulnerability occurs when intermediate functions encounter errors after memory is allocated but before it can be properly released, potentially leading to memory exhaustion over time. This is a kernel-level issue that affects systems with MediaTek WiFi hardware running vulnerable kernel versions.

• CVE-2026-53104MEDIUM 5.5

  A memory leak exists in the Linux kernel's MT76 WiFi driver that occurs during device destruction or module unload. The issue affects how receive (RX) queues manage associated memory pools—specifically, page pools are not properly cleaned up even when queues lack NAPI association, such as WED RRO (Ring Resource Optimize) queues when WED (Wireless Ethernet Dispatch) is enabled. This causes memory to remain allocated and inaccessible after the driver unloads, degrading system resource availability over time or after repeated driver restarts.

• CVE-2026-53106MEDIUM 5.5

  CVE-2026-53106 is a deadlock vulnerability in the Linux kernel's eBPF (extended Berkeley Packet Filter) local storage subsystem. The issue occurs when code running in NMI (Non-Maskable Interrupt) context attempts to delete local storage entries, which can cause the system to hang. The kernel developers have implemented a targeted fix that prevents deletion operations from proceeding when called from NMI context, returning an error instead of allowing the unsafe operation to proceed.

• CVE-2026-53113MEDIUM 5.5

  A memory leak vulnerability exists in the Linux kernel's WiFi driver (ath11k) that affects beacon template setup functions. When these functions encounter errors during parameter setup, they fail to properly release allocated memory for beacon templates. This can cause memory to accumulate over time, eventually degrading system performance or causing denial of service on affected devices, particularly WiFi access points and embedded systems running the vulnerable kernel code.

• CVE-2026-53121MEDIUM 5.5

  A memory leak has been identified in the Linux kernel's AMD P-State driver, specifically in the CPU initialization code path. When the driver fails to configure power efficiency settings during CPU initialization, it deallocates resources improperly, leaving allocated memory orphaned in the system. Over time, repeated initialization failures could accumulate unused memory, degrading system stability and performance. This vulnerability requires local access to trigger and affects systems running vulnerable kernel versions with AMD P-State enabled.

• CVE-2026-53127MEDIUM 5.5

  CVE-2026-53127 is a memory leak vulnerability in the Linux kernel's block device subsystem. When the kernel attempts to revalidate disk zones—a routine operation for certain storage hardware—and encounters an error, it fails to properly clean up allocated memory. This leaked memory accumulates over time, potentially causing system instability or service disruption on affected Linux systems.

• CVE-2026-53134MEDIUM 5.5

  A flaw in the Linux kernel's netfilter subsystem can leak uninitialized kernel memory to unprivileged local users. When the netfilter FIB module processes certain lookup failures or network interface checks, it fails to properly clear all memory locations it claims to initialize, leaving stale stack data accessible to userspace code. An attacker with local access could read sensitive kernel information through carefully crafted netfilter rules.

• CVE-2026-53140MEDIUM 5.5

  A memory leak vulnerability exists in the Linux kernel's Direct Rendering Manager (DRM) v3d driver. When processing compute shader dispatch (CSD) jobs with indirect workgroup counts, the driver fails to properly clean up memory mappings if any workgroup count is zero. This causes virtual address mappings to remain allocated, gradually consuming kernel memory. The issue is localized to a single code path and requires local access to exploit, making it a moderate risk to systems where untrusted local users can submit graphics workloads.

• CVE-2026-53181MEDIUM 5.5

  A flaw in the Linux kernel's virtual socket (vsock) implementation causes a resource leak when establishing connections between a guest and host via VMCI (VMware Communications Interface). When a server fails to complete the connection handshake—due to malformed packets, memory allocation issues, or event subscription problems—the kernel fails to properly clean up its internal connection tracking. Each failed attempt leaves a small piece of state behind, and after enough failures, the system silently rejects all new connection attempts. Restarting the affected process is the only recovery mechanism.

• CVE-2026-53210MEDIUM 5.5

  CVE-2026-53210 is a memory leak vulnerability in the Linux kernel's TEE (Trusted Execution Environment) shared memory handler. When a user attempts to register shared memory with zero length via the TEE_IOC_SHM_REGISTER ioctl, the kernel allocates memory but fails to free it before exiting the error path, causing the allocated memory to leak. While the immediate impact is resource exhaustion rather than data exposure or privilege escalation, repeated triggering can degrade system stability on TEE-enabled systems.

• CVE-2026-53211MEDIUM 5.5

  A flaw in the Linux kernel's netfilter module causes uninitialized kernel memory to leak when certain network filtering rules access bridge device hardware addresses. When a netfilter rule requests the hardware address of an incoming interface on a bridge, the kernel writes only 6 bytes of the address into a register that is 8 bytes long, leaving 2 bytes of stale stack memory exposed. If a rule subsequently reads from that register, the uninitialized kernel data can be disclosed to a user-space application. The fix involves zeroing the full register before writing the hardware address.

• CVE-2026-53213MEDIUM 5.5

  A memory leak vulnerability exists in the Linux kernel's Direct Rendering Manager (DRM) video core (vc4) driver. The issue occurs when the krealloc() function is called to resize allocated memory without properly checking its return value before overwriting the original pointer. If krealloc() fails and returns NULL, the original memory block becomes unreachable and is leaked. An unprivileged local user could trigger this condition repeatedly, exhausting system memory and causing a denial of service.

• CVE-2026-53222MEDIUM 5.5

  A resource management issue exists in the Linux kernel's PTP (Precision Time Protocol) OCP driver. When the driver is unloaded, it frees pin resources before properly unregistering the PTP clock device. A recent kernel change causes the unregister process to reconfigure those already-freed pins, creating a use-after-free condition that can crash the system. The fix reorders operations so the clock is unregistered before pin resources are released, and ensures interrupt handlers are fully synchronized before cleanup.

• CVE-2026-53226MEDIUM 5.5

  A flaw in the Linux kernel's Rockchip GPIO driver causes memory and resource leaks when the driver is unloaded. Specifically, interrupt-handling structures allocated during driver initialization are not properly freed during removal. These orphaned structures remain registered globally and can be accessed by system callbacks after the hardware driver has already shut down, risking a crash. The fix requires explicitly cleaning up these structures before the driver fully unloads.

• CVE-2026-53227MEDIUM 5.5

  A memory management bug exists in the Linux kernel's Open vSwitch networking subsystem. When a network packet buffer fails to allocate during certain locking operations, the kernel attempts to free an invalid memory pointer, causing a crash. This vulnerability affects systems running vulnerable kernel versions, particularly in environments using Open vSwitch for virtualized networking.

• CVE-2026-53252MEDIUM 5.5

  A memory leak has been discovered in the Linux kernel's Bluetooth HCI subsystem. When Bluetooth device initialization fails early in the startup process, before the device is fully registered, a cleanup function is incorrectly skipped. This leaves behind unreleased memory from the SRCU (Sleepable RCU) synchronization mechanism, which accumulates per-CPU allocations that are never freed. While the leak itself doesn't directly compromise data confidentiality or integrity, repeated device failures can exhaust available memory and degrade system stability or cause denial of service.

• CVE-2026-53258MEDIUM 5.5

  A memory leak exists in the Linux kernel's WiFi scanning code that occurs when 6 GHz band scanning fails. When cfg80211_scan() encounters an error during split 6 GHz scanning, the kernel allocates memory for an internal scan request (rdev->int_scan_req) but fails to properly release it. This happens because the cleanup function checks for rdev->scan_req being populated before freeing resources, but in this error condition both pointers end up NULL, causing the allocated memory to never be released. The leak is triggered through normal WiFi scanning operations, typically initiated by user-space tools like wpa_supplicant.

• CVE-2026-53261MEDIUM 5.5

  A memory leak exists in the Linux kernel's devlink subsystem where relationship state is not properly released in certain failure scenarios. Specifically, when a device driver (particularly SubFunction or SF drivers) creates a nested devlink relationship to its parent before completing registration, and then fails during the probe process, the relationship reference is leaked because the normal cleanup path is bypassed. This affects only systems where drivers follow this specific initialization pattern and experience probe failures.

• CVE-2026-53308MEDIUM 5.5

  A memory management flaw exists in the Linux kernel's max77705 power supply driver. The driver fails to properly clean up a work queue when the module is removed, causing a memory leak. Additionally, the order in which components are initialized and destroyed creates a race condition: if an interrupt fires after the work queue is destroyed but before the interrupt handler is cleaned up, the handler will attempt to schedule work on freed memory, potentially causing a system crash. The vulnerability requires local access and elevated privileges to trigger.

• CVE-2026-53345MEDIUM 5.5

  CVE-2026-53345 is a memory leak vulnerability in the Linux kernel's KVM (Kernel-based Virtual Machine) hypervisor that affects systems running SEV-ES (Secure Encrypted Virtualization with Encrypted State) virtual machines. The issue occurs when KVM fails to properly clean up a writable page mapping during virtual machine destruction, particularly when userspace never completes operations after certain VM exits. This leaves memory incorrectly marked as dirty without proper cleanup, resulting in a resource leak. The vulnerability is triggered only during the shutdown sequence of affected VMs and does not allow remote exploitation or privilege escalation beyond the local user's existing permissions.

• CVE-2026-48043MEDIUM 5.3

  Netty's HTTP/2 decompression logic has a resource leak that can exhaust memory and crash the JVM. When a remote attacker sends specially crafted HTTP/2 frames, the decompressor fails to properly release memory buffers, and repeated exploitation can lead to out-of-memory errors. This affects Netty versions before 4.1.135.Final and 4.2.15.Final.

• CVE-2026-48141MEDIUM 5.3

  A memory leak exists in National Instruments' grpc-device BeginSidebandStream function that can be exploited to exhaust server memory and cause denial of service. An authenticated attacker can trigger this leak repeatedly, eventually forcing the affected service to crash or become unresponsive. The vulnerability affects NI grpc-device version 2.17.0 and earlier.

• CVE-2026-56371MEDIUM 5.3

  ImageMagick, a widely-used image processing library, contains a memory leak when handling specially crafted TXT files that include texture attributes. The vulnerability occurs because the software fails to properly clean up memory allocated during texture processing when a subsequent operation fails, causing memory to be progressively consumed with each malicious file processed. An attacker can exploit this by sending or hosting a crafted TXT file that, when processed by a vulnerable ImageMagick installation, exhausts available memory and causes a denial of service.

• CVE-2026-45682MEDIUM 5.1

  OpenTelemetry's eBPF Instrumentation agent for Java contains a memory leak in its TLS connection state tracking. When Java applications handle repeated connection churn (connections opening and closing), the instrumentation fails to properly clean up its internal tracking queue, causing heap memory to grow indefinitely until the application runs out of memory and crashes. This affects long-running production JVMs where connection pools are regularly recycled. The issue is resolved in version 0.9.0.

• CVE-2026-53464MEDIUM 4.0

  ImageMagick versions before 7.1.2-25 leak a small amount of memory when the wand option parser receives invalid input. An attacker with local access could trigger this repeatedly to consume system memory and degrade performance or cause denial of service. The issue is low-impact but present in all affected versions.

• CVE-2026-56365LOW 3.7

  ImageMagick versions before 7.1.2-19 contain a memory leak in their PNG encoder when processing MNG (Multiple-image Network Graphics) files. An attacker can craft a malicious MNG image that triggers a failure condition in the encoder, causing the application to leak memory repeatedly. If an ImageMagick instance processes many such images without restarting, available memory will eventually be exhausted, causing the service to become unresponsive or crash—a denial-of-service condition. This is a low-severity issue because it requires specific conditions to be met and does not allow unauthorized access or data compromise.

• CVE-2026-56368LOW 3.7

  ImageMagick versions before 7.1.2-15 contain a memory leak flaw in the image processing code that handles raw pixel data. When processing specially crafted images, the software fails to release memory properly, allowing attackers to exhaust available system memory and cause the application to become unresponsive or crash. This is a network-accessible denial-of-service vector that requires no authentication or user interaction to trigger.

• CVE-2026-56366LOW 3.3

  ImageMagick versions before 7.1.2-18 have a memory leak flaw in how they process certain image metadata. When an attacker sends a specially crafted APP1JPEG image file, ImageMagick fails to properly release memory, causing it to consume increasing amounts of system resources until the application crashes or becomes unresponsive. This is a local denial-of-service issue that requires user interaction to trigger.

• CVE-2026-56364LOW 1.9

  ImageMagick versions prior to 7.1.2-13 contain a memory leak in code that processes OpenCL device configuration files. An attacker with write access to ImageMagick's OpenCL cache directory can place a specially crafted XML file with incomplete device elements. When ImageMagick reads this file, the memory leak causes the application to consume increasing amounts of memory until it runs out, rendering the service unavailable. This requires both local file system access and knowledge of where the cache directory is located, significantly limiting real-world attack scenarios.