Red Hat
Monthly
Improper error handling in the Linux kernel's netfs (network filesystem) subsystem allows a local user with low privileges to corrupt kernel folio state or trigger a kernel hang. The writeback_iter() loop fails to re-invoke itself with the error code set when a write operation fails, leaving folios unlocked and non-redirtied, which produces incorrect iteration state with high integrity and availability consequences. No public exploit code has been identified, and EPSS places exploitation probability at 0.21% (11th percentile), consistent with a constrained local kernel defect rather than a broadly weaponized vulnerability.
Integrity and availability compromise in the Linux kernel's Intel Xe GPU Physical Function (PF) driver allows a low-privileged local user operating within a guest Virtual Function (VF) environment to trigger PF-side assertion failures and ABI protocol breakage by sending FAST_REQUEST or EVENT relay messages - message types the PF handler is not designed to process. The vulnerability crosses a privilege boundary from guest to host, reflected in the CVSS scope-changed rating of 8.4. No public exploit code exists and no active exploitation has been confirmed; EPSS stands at 0.21% (11th percentile). Vendor-released patches are available across multiple stable kernel branches.
Invalid cursor access in the Linux kernel's Intel Xe GPU (drm/xe) page table subsystem allows local low-privileged users to trigger kernel warnings and potentially exploit uninitialized memory during page table binding walks involving purged buffer objects. Affected kernel versions span Linux 7.1 up to the fix points in 7.1.5 and 7.2-rc2, and only systems equipped with Intel Xe GPU hardware are at risk. No public exploit identified at time of analysis; EPSS at 0.20% (10th percentile) reflects minimal current exploitation interest, though the kernel memory-management context elevates the theoretical impact ceiling.
Context confusion in the Linux kernel's uprobes/x86 subsystem allows a local attacker with low privileges to trigger incorrect VMA lookups by exploiting the use of `current->mm` (the tracer's memory map) instead of the traced process's `mm_struct` during uprobe unregistration. Affected are kernel versions in the 6.18.x, 7.1.x, and pre-rc2 7.2 branches originating from commit ba2bfc97b462. Patches are confirmed in 6.18.40, 7.1.5, and 7.2-rc2; no public exploit code has been identified and the vulnerability is not listed in CISA KEV, with EPSS at a low 0.21% (11th percentile).
Credit resource leak in the Linux kernel CIFS client function cifs_issue_read() enables a server-side actor to exhaust the SMB flow-control credit pool on a connected Linux host, producing a denial of service for all I/O on the affected CIFS mount. Linux kernel versions from commit 69c3c023af25edb5433a2db824d3e7cc328f0183 onward are affected until stable-tree patches landing in 6.12.97, 6.18.40, 7.1.5, and 7.2-rc2. No public exploit identified at time of analysis; EPSS of 0.21% (11th percentile) confirms very low real-world exploitation probability and no CISA KEV listing exists.
Memory-ordering (barriering) defect in the Linux kernel's netfs subsystem allows a subrequest that was just added by an application thread to be observed inconsistently while the retry path walks the subrequest list, risking use of partially-initialized data. The flaw affects netfs-backed network filesystems (e.g. AFS, Ceph, CIFS, 9p) in kernels from 6.10 onward and has been resolved upstream. There is no public exploit identified at time of analysis, and the EPSS score is very low (0.20%, 10th percentile), indicating negligible observed exploitation interest despite the NVD's 9.8 rating.
Use-after-free in the Linux kernel's legacy NTFS filesystem driver (ntfs_mft_writepages) allows a local low-privileged attacker to corrupt kernel slab memory by winning a timing race between MFT writeback and concurrent MFT allocation extension. Affected kernels span the Linux 7.1 stable series up through 7.1.4; fix commits are confirmed in the upstream stable tree targeting 7.1.5 and 7.2-rc3. No public exploit is identified at time of analysis and EPSS is low (0.20%), but the confirmed slab-use-after-free in ring-0 writeback code represents a high-severity memory safety defect warranting scheduled patching.
Use-after-free race condition in the Linux kernel's legacy NTFS driver (ntfs.ko) exposes systems with NTFS-mounted volumes to kernel heap memory corruption, enabling local privilege escalation, information disclosure, or kernel panic. The flaw in ntfs_attr_fallocate() releases a read lock before consuming a borrowed runlist pointer, while a concurrent mmap page_mkwrite path can simultaneously reallocate and free the underlying array - confirmed by a KASAN slab-use-after-free trace in the CVE description. No public exploit or CISA KEV entry exists; EPSS of 0.20% (10th percentile) reflects the difficulty of reliably winning this race, though successful exploitation carries severe kernel-level impact.
Integer wraparound in the Linux kernel HID-BPF subsystem's hid_bpf_get_data() helper allows a local low-privileged user to bypass a buffer range check and obtain an out-of-bounds pointer into kernel memory, potentially enabling privilege escalation or memory corruption. Affected kernels span from Linux 6.3 (commit 658ee5a64fcfbbf) through versions prior to 6.12.97, 6.18.40, 7.1.5, and 7.2-rc3, where upstream fix commits have landed. No public exploit has been identified at time of analysis and EPSS remains at 0.21%, but the CVSS 7.8 local-privilege score reflects a high-impact, low-complexity code path once local access is established.
Out-of-bounds read in the Linux kernel's Generic UDP Encapsulation (GUE) tunnel receive path lets remote attackers read adjacent packet memory by sending malformed GUE packets that set the GUE_PFLAG_REMCSUM private flag without carrying the corresponding remote-checksum start/offset bytes. Because guehdr_priv_flags_len() failed to account for GUE_PLEN_REMCSUM, such truncated packets slipped past validate_gue_flags() and were then processed by gue_remcsum()/gue_gro_remcsum(), which read the missing fields from following bytes. There is no public exploit identified at time of analysis; EPSS is low (0.22%, 13th percentile) and the flaw is not in CISA KEV, so despite the headline CVSS 9.8 the realistic impact is information disclosure/instability rather than confirmed remote code execution.
Undefined-behavior shift in the Linux kernel's netfilter xt_u32 match module allows a local attacker with CAP_NET_ADMIN to supply malformed packet-filter rules containing shift counts of 32 or more, triggering out-of-bounds shift operations on 32-bit values in u32_match_it() during live packet evaluation. The vulnerability affects all kernel versions from 2.6.23 (when xt_u32 was introduced) through the stable-branch fix commits, with patched versions confirmed across six stable trees. No active exploitation (KEV) or public proof-of-concept has been identified; EPSS sits at the 13th percentile, reflecting currently limited exploitation probability.
Netfilter ip6tables rule evasion in the Linux kernel allows remote attackers to slip malformed IPv6 packets past firewall policy. The ah, hbh, and rt matches for IPv6 extension headers derived the header length without fully validating it against available skb data, so a packet whose advertised extension-header length exceeded the real data was treated as a rule mismatch (returning false) rather than being dropped - letting it bypass ip6tables rules specifically written to drop such traffic. The fix sets hotdrop=true so malformed packets are discarded. No public exploit identified at time of analysis; EPSS is low (0.23%, 14th percentile) and this is not in CISA KEV.
Undefined-shift undefined behavior in the Linux kernel netfilter subsystem (xt_connmark) allows a local attacker with low privileges to trigger kernel crashes, potential memory corruption, and limited information disclosure. The flaw resides in the CONNMARK target revision 2, introduced in Linux 4.17, where user-supplied shift_bits values of 32 or greater are passed unchecked to 32-bit bitshift operations in connmark_tg_shift(), invoking C undefined behavior at packet-processing time. Exploitation is not confirmed active (not in CISA KEV) and EPSS sits at 0.21% (12th percentile), but the kernel-level impact and wide Linux deployment make patching a clear priority for exposed hosts.
Off-by-one memory corruption in the Linux kernel's mlx5 LAG (Link Aggregation) subsystem exposes systems with Mellanox/NVIDIA ConnectX NICs to local privilege escalation via a defective error rollback loop in `mlx5_lag_create_single_fdb()`. When rule installation fails at index `i`, the cleanup loop incorrectly begins teardown at `i` rather than `i-1`, operating on uninitialized kernel state or double-freeing a rule the `add_one` path already rolled back - resulting in heap corruption with C:H/I:H/A:H impact potential. No public exploit or CISA KEV listing exists at time of analysis; EPSS probability stands at 0.20% (10th percentile), and upstream fix commits are confirmed available.
Kernel crash via bad memory access in the mlx5e traffic control peer flow cleanup path affects Linux systems running Mellanox/NVIDIA mlx5 NICs in LAG (Link Aggregation Group) mode. When mlx5_lag_get_dev_seq() returns an error during device teardown - because the peer is absent from the LAG or no master device is marked - the driver proceeds to dereference an invalid pointer in mlx5e_tc_del_fdb_peers_flow, causing a kernel panic. No public exploit exists and EPSS is 0.20% (10th percentile), but the crash is deterministically reproducible on affected hardware configurations during device removal or driver teardown sequences.
Memory corruption in the Linux kernel mlx5e driver's Hyper-V VHCA statistics subsystem causes a kernel fault when running as a Hyper-V guest with a Mellanox/NVIDIA ConnectX NIC. The driver initializes the stats buffer with a zero-size allocation that returns ZERO_SIZE_PTR (0x10) instead of NULL, bypasses the NULL guard, and stores the sentinel pointer; once channels open and the hypervisor enables stats reporting, a subsequent memset on address 0x10 faults the kernel. No public exploit identified at time of analysis; EPSS is 0.21% (12th percentile), reflecting minimal real-world exploitation likelihood despite the high official CVSS score.
The mlx5e HV VHCA stats agent registration in the Linux kernel contains an initialization race condition that can produce NULL pointer dereferences or kernel timer list corruption, crashing a Hyper-V guest VM. Affected systems are those running Linux on Microsoft Hyper-V with a Mellanox mlx5e NIC across stable kernel trees spanning 6.1 through 7.1, with the root cause being that mlx5_hv_vhca_agent_create() publishes the agent and triggers an asynchronous workqueue callback before the caller has initialized the associated delayed_work structure and agent pointer. No public exploit code has been identified and EPSS exploitation probability is 0.21% (12th percentile); vendor patches have been released across all active stable branches and upstream commit references are available via kernel.org.
Race condition in the Linux kernel's Microchip VCAP network driver corrupts hardware forwarding table entries on systems using sparx5 or lan969x switching ASICs. A local authenticated user can simultaneously trigger a debugfs VCAP rule dump and a tc-flower rule write to different Super VCAP instances, causing shared cache registers to be overwritten mid-transaction and committing corrupt data directly into hardware forwarding entries. No public exploit code or CISA KEV listing exists; EPSS is 0.21%, reflecting low exploitation likelihood in practice.
Memory corruption in the Linux kernel qede network driver (QLogic/Marvell FastLinQ 40/100GbE) arises because qede_rx_build_skb() and qede_tpa_rx_build_skb() do not check for a NULL return from qede_build_skb(), consuming an extra buffer descriptor and desynchronizing the RX BD ring. The resulting off-by-one can corrupt DMA page reference counts and trigger SLUB freelist corruption, most plausibly a kernel-crash denial of service rather than reliable code execution. No public exploit has been identified and it is not in CISA KEV; the low EPSS (0.22%, 13th percentile) reflects that the bug only manifests under kernel memory pressure.
Heap out-of-bounds write in the Linux kernel's act_pedit TC offload path allows a local attacker holding CAP_NET_ADMIN to corrupt kernel slab memory with attacker-controlled content, potentially leading to privilege escalation or denial of service. The flaw affects Linux kernel versions from approximately 4.11 through the stable branches patched in 6.6.145, 6.12.97, 6.18.40, 7.1.5, and 7.2-rc3. Trend Micro ZDI researchers confirmed exploitability via KASAN trace using a targeted POC; no public exploit has been released and this CVE is not listed in the CISA KEV catalog.
Use-after-free in the Linux kernel Bluetooth MGMT advertising monitor subsystem allows a local attacker with low privileges to corrupt kernel heap memory, potentially achieving privilege escalation. The flaw arises from a ownership race: hci_add_adv_monitor() publishes a new adv_monitor into the hdev->adv_monitors_idr before the MSFT HCI offload setup step completes, allowing the MSFT callback to free the monitor on failure while the MGMT completion path still holds a dangling pointer. KASAN confirmed the slab-use-after-free in mgmt_add_adv_patterns_monitor_complete; no public exploit or active exploitation (CISA KEV) has been identified, and EPSS is 0.21% (12th percentile).
Bluetooth ISO packet reassembly in the Linux kernel mishandles malformed ISO_CONT and ISO_END packets, exposing adjacent attackers to three distinct kernel-level impacts: a conn->rx_skb memory leak via abnormal ISO_START sequences, a kernel panic triggered by an unchecked skb_put call on oversized ISO_END frames, and silent acceptance of undersized ISO_END packets. All Linux kernel versions from 6.0 through the fix commits on affected stable branches are impacted, with fixes confirmed in 7.1.5 and 7.2-rc3. No public exploit or CISA KEV listing exists at time of analysis, but the CVSS 8.8 AV:A/PR:N vector and the availability of upstream fix commits make this an actionable patching priority for any Bluetooth-enabled Linux deployment.
Use-after-free in the Linux kernel's accel/amdxdna driver exposes systems with AMD XDna NPU hardware to local privilege escalation by a low-privileged attacker. The race condition exists between `aie2_populate_range()` and `amdxdna_umap_release()`, both of which dereference a stale VMA pointer after the underlying virtual memory area may have been freed by the kernel memory manager. With EPSS at 0.20% (10th percentile), no CISA KEV listing, and no public exploit identified at time of analysis, active exploitation is not currently observed - though the CVSS 7.8 score correctly reflects the theoretical potential for full kernel compromise on affected hardware configurations.
Denial of service in the Linux kernel's kernel TLS (kTLS) subsystem allows a remote peer to permanently stall a TLS connection by sending a single zero-length TLS 1.3 application_data record. The `tls_sw_read_sock()` function misinterprets the empty record's zero-length return as a backpressure signal, requeuing the record indefinitely at the head of rx_list and blocking all subsequent TLS data on that connection. No public exploit code exists, the CVE is absent from the CISA KEV catalog, and EPSS sits at 0.21% (11th percentile), indicating low current exploitation interest despite the 7.5 CVSS score.
Kernel-memory corruption in the Linux kernel's net/liquidio (Marvell/Cavium LiquidIO SmartNIC) SR-IOV driver stems from caching virtual-function pci_dev pointers that hold no reference; the stale pointer is later dereferenced when servicing an OCTEON_VF_FLR_REQUEST, yielding a use-after-free reachable from a virtual function. Affected systems are hosts running the liquidio PF driver with SR-IOV enabled and VFs assigned to guests. Successful triggering can crash the host or corrupt kernel memory (potential privilege/scope escalation from a VF into the host); this is no public exploit identified at time of analysis, EPSS is low (0.20%), and a vendor fix is available.
Use-after-free race condition in the Linux kernel's AMD XDNA accelerator driver (accel/amdxdna) allows a local, low-privileged attacker on systems with AMD XDNA hardware to corrupt kernel memory, potentially achieving full privilege escalation. The race window opens because amdxdna_umap_release() calls the blocking mmu_interval_notifier_remove() before removing the object from abo->mem.umap_list, permitting aie2_populate_range() to obtain a stale reference concurrently. No public exploit has been identified at time of analysis, and an EPSS of 0.21% (11th percentile) signals minimal current exploitation interest.
Kernel panic (and potential memory corruption) in the Linux kernel's IPv6 multicast stack arises from a use-after-free in the MLD delayed-work path, where a race between network-device teardown and incoming MLD query processing lets igmp6_event_query() take a reference on an inet6_dev whose refcount has already reached zero. Affected systems run kernels across the 2.6.12-through-7.x range prior to the fixed stable releases, and successful triggering causes a refcount 'addition on 0' warning followed by access to freed memory once the scheduled work runs. There is no public exploit identified at time of analysis, EPSS risk is low (0.22%, 13th percentile), and it is not listed in CISA KEV.
Firewall policy bypass in the Linux kernel's netfilter nftables subsystem allows remote attackers to evade packet-filtering rules that use inverted set lookups. The flaw lives in nft_lookup_eval(), where the match result for negated lookups ('!= @set') is computed before the catchall element used by interval sets is folded in, so rules resolve to the wrong verdict. It affects the nf_tables classifier across a wide range of kernel branches; there is no public exploit identified at time of analysis and EPSS probability is low (0.21%).
Improper handling of ICMP error packets in the Linux kernel's IPVS (IP Virtual Server) subsystem allows crafted ICMP errors from tunneled traffic to reference inner IP headers that are not guaranteed to reside in the skb headroom after pskb_pull() strips the outer headers, leading to out-of-bounds access in path-MTU update, icmp_send() and debug paths. The flaw affects hosts using IPVS load balancing with tunnel encapsulation; the practical consequence is an out-of-bounds read (information disclosure per source tags) or kernel crash rather than code execution. No public exploit identified at time of analysis, EPSS is low (0.22%, 13th percentile), and it is not listed in CISA KEV.
Out-of-bounds kernel memory read in the Linux kernel's CIFS/SMB client (parse_dfs_referrals) affects hosts that mount SMB shares involving DFS referrals. A malicious or man-in-the-middle SMB server can return a referral whose server-supplied string offsets point beyond the received response buffer; the unchecked offset yields a negative max_len that reaches kstrndup()/strnlen() as a size_t, causing an out-of-bounds read that can leak adjacent kernel memory or crash the client. CVSS is 9.4, but there is no public exploit identified at time of analysis, it is not in CISA KEV, and EPSS is low (0.21%, 12th percentile), indicating no observed exploitation.
Use-after-free (refcount_t underflow) in the Linux kernel's SUNRPC TLS connect path lets a failing TLS-secured RPC transport dereference an already-freed upper rpc_clnt, corrupting kernel memory. It affects systems using RPC-with-TLS transports (notably NFS-over-TLS/mTLS mounts) where a fatal handshake failure races the delayed connect_worker. There is no public exploit identified at time of analysis and EPSS is low (0.21%, 11th percentile); the input's 9.8 CVSS reflects Linux's automated scoring rather than the local, config-dependent trigger described.
Linux kernel SMB/CIFS client exposes a race condition between direct I/O (DIO) write completion and filesystem unmount that leaves dentry reference counts unreleased, triggering a kernel BUG warning and potential use-after-free condition. Local users with access to CIFS-mounted shares can trigger this by initiating a DIO write and concurrently unmounting the filesystem, allowing the kernel's shrink_dcache_for_umount() to fire before deferred workqueue cleanup has decremented the dentry refcount. With CVSS 7.8 and C:H/I:H/A:H, the theoretical impact is full kernel compromise, though no public exploit and an EPSS of 0.20% (10th percentile) indicate this remains a low-exploitation-probability vulnerability at time of analysis.
The regulator subsystem in the Linux kernel contains a deadlock-handling defect where `regulator_lock_two()` compares the return value of `ww_mutex_lock()` against `-EDEADLOCK` instead of the correct `-EDEADLK` constant. On MIPS architecture - the only platform where the regulator core is active and these two error constants carry different numeric values - the mismatch causes the kernel to skip the mandatory unlock-and-retry backoff sequence, fire `WARN_ON`, and return to the caller with only one of the two regulators locked, producing corrupted locking state. No public exploit has been identified and EPSS is very low (0.22%, 13th percentile), but the high CVSS impact ratings (C:H/I:H/A:H) reflect the potential for kernel panic or local privilege escalation on affected MIPS systems.
The octeontx2-af driver in the Linux kernel mishandles SR-IOV mailbox requests for nix_set_rx_mode, allowing a low-privileged user controlling a Virtual Function on Marvell OcteonTX2 hardware to silently delete the Physical Function's MCAM promiscuous and allmulti filtering rules through ordinary interface bringup or teardown operations. Affected Linux kernel versions span 5.14 through multiple stable branches, patched in 6.1.178, 6.6.145, 6.12.97, 6.18.40, 7.1.5, and 7.2-rc3. No public exploit identified at time of analysis; EPSS is 0.21% (12th percentile), consistent with negligible observed exploitation activity and the hardware-specific attack surface.
Integer overflow in the Linux kernel SMB client's smb2_ioctl_query_info() function enables a malicious SMB server to bypass bounds checking during PASSTHRU_FSCTL response processing, leading to an out-of-bounds kernel memory read disclosed to userspace. Affected systems are Linux kernels across multiple stable branches where OutputOffset and qi.input_buffer_length are summed without overflow protection, allowing a server-controlled 32-bit wrap to defeat the bounds check and cause copy_to_user() to read beyond the response buffer. No public exploit has been identified at time of analysis, and the EPSS score of 0.22% reflects low current exploitation probability, but the network-reachable attack surface and high confidentiality impact (CVSS 8.1) make patching a near-term priority for any Linux host using SMB client connectivity.
Kernel memory corruption in the Linux ASoC Sound Open Firmware (SOF) IPC4 control subsystem allows a low-privileged local user to trigger incorrect buffer copy lengths in sof_ipc4_bytes_put(), potentially achieving high confidentiality, integrity, and availability impact. The root cause is a logic error - not a race - where the copy size is sourced from the stale in-kernel buffer's size field rather than from the incoming user-supplied sof_abi_hdr.size in ucontrol, enabling data truncation or stale-byte copying into kernel structures. No public exploit code or active exploitation has been identified at time of analysis; patch commits are available across multiple stable kernel series.
Missing payload size validation in the Linux kernel's ASoC SOF IPC4 control subsystem allows a local low-privileged attacker to trigger out-of-bounds memory access when the kernel processes MODULE_NOTIFICATION messages. Affected systems are those running Linux kernel 7.0 and related stable branches where the SOF IPC4 audio driver is active - typically Intel hardware using Sound Open Firmware. No public exploit or CISA KEV listing exists, and EPSS sits at 0.20% (10th percentile), indicating low current exploitation interest, though the CVSS 7.8 score reflects real kernel-level impact potential.
Integer overflow in the Linux kernel's ASoC Sound Open Firmware (SOF) IPC3 control handler allows a local, low-privileged attacker on 32-bit platforms to bypass buffer size validation and trigger out-of-bounds memory access in `snd_sof_update_control`. The flaw exists because `sof_ipc3_control_update()` performs unguarded arithmetic on firmware-supplied `cdata->num_elems`, which wraps on 32-bit integer arithmetic and causes the subsequent header size check to pass with mismatched values. No public exploit code exists and no CISA KEV listing is present; EPSS probability is 0.23% at the 14th percentile, with vendor patches available across multiple stable kernel branches.
Memory corruption and information disclosure in the Linux kernel's ASoC Sound Open Firmware (SOF) IPC3 control subsystem allows local users with low privileges to corrupt kernel memory or leak sensitive data. The flaw affects sof_ipc3_bytes_put() and sof_ipc3_bytes_get() functions, where wrong-size memcpy operations and an off-by-sizeof bounds check create exploitable memory safety violations. No public exploit or CISA KEV listing exists at time of analysis; the EPSS score of 0.21% (12th percentile) reflects a low but non-negligible near-term exploitation probability.
Integer overflow in the Linux kernel's QRTR (Qualcomm IPC Router) subsystem on 32-bit platforms allows an out-of-bounds kernel heap write via a crafted incoming packet. On 32-bit builds where size_t is four bytes, passing size >= 0xfffffffd to ALIGN(size, 4) wraps the result to zero, bypassing the packet validation check in qrtr_endpoint_post() and allowing skb_put_data() to write attacker-controlled data far beyond the allocated socket buffer. This is the 32-bit residual of commit ad9d24c9429e2, which fixed only the 64-bit case; 64-bit kernels are structurally unaffected. No public exploit is identified at time of analysis, and EPSS at 0.22% reflects low exploitation probability.
Out-of-bounds read in the Linux kernel ATM networking subsystem (`net/atm`) allows local low-privileged users to disclose kernel memory or crash the system by supplying an out-of-range `traffic_class` value via the `SO_ATMQOS` socket option. The flaw persists because `check_tp()` fails to reject traffic class values above `ATM_ANYCLASS`, leaving the invalid value in `vcc->qos` where it is later used as an unguarded array index in `pvc_info()` when `/proc/net/atm/pvc` is read. EPSS sits at 0.22% (13th percentile) with no CISA KEV listing and no public exploit identified, making real-world exploitation risk considerably lower than the CVSS 7.1 score implies, particularly given that ATM networking is a legacy subsystem absent from most modern deployments.
Denial-of-service in the Linux kernel's IFE (Inter-Forwarding-Element) traffic-control action allows a crafted, malformed IFE frame to crash the host, because ife_decode() only guaranteed the outer IFE header was pullable before handing the decapsulated packet to eth_type_trans(), which then reads an inner Ethernet header that may be shorter than ETH_HLEN in the linear skb area. Only systems that have the tc act_ife action configured are exposed. There is no public exploit identified at time of analysis, EPSS is low (0.22%, 13th percentile), and it is not in CISA KEV; the fix adds ETH_HLEN to the pull check.
Out-of-bounds array indexing in the Linux kernel's KVM irqfd routing for LoongArch allows a local user with KVM access to index past the routing table's chip array boundary, potentially exposing host kernel memory or enabling a hypervisor boundary breach with full triad impact. Patches are available in stable releases 6.18.40, 7.1.5, and 7.2-rc1 across three upstream commits. No public exploit code exists and EPSS sits at 0.21% (11th percentile), indicating negligible active exploitation probability despite the elevated CVSS 8.8 score.
Missing interrupt request (IRQ) validity checking in the LoongArch KVM subsystem of the Linux kernel allows a local low-privileged user with access to KVM device nodes to pass malformed IRQ values via the kvm_vcpu_ioctl_interrupt() ioctl, potentially causing memory corruption or privilege escalation that crosses the guest-to-host boundary. The CVSS scope change (S:C) signals that successful exploitation could compromise the hypervisor host, making this significant for LoongArch-based virtualization environments. No public exploit code has been identified and EPSS probability sits at 0.21%, suggesting exploitation remains theoretical at this time.
Local privilege/information-disclosure risk in the Linux kernel's s390 KVM subsystem stems from an unlikely race in try_get_locked_pte(), where puds or pmds can be unmapped between the p?dp_get() and p?d_offset() calls, leaving code operating on a stale or freed page-table entry. The flaw affects s390 (IBM Z mainframe) systems running KVM virtualization and has now been patched upstream; no public exploit identified at time of analysis and EPSS exploitation probability is low (0.20%, 10th percentile).
Memory corruption in the Linux kernel's KVM/arm64 GICv3 virtualization (vgic) subsystem allows a local attacker on an ARM64 KVM host to trigger a double list removal, corrupting the ap_list and enabling a use-after-free style condition. The flaw lives in vgic_prune_ap_list(), where an interrupt can be pruned from a vCPU's active/pending list a second time after vgic_flush_pending_lpis() already removed it, because the affinity re-check does not confirm the interrupt is still owned by the vCPU. No public exploit is identified at time of analysis, and EPSS is low (0.22%), consistent with a race-condition kernel bug that is difficult to weaponize.
Local privilege escalation / host memory corruption in the Linux kernel's arm64 KVM vGIC subsystem allows a malicious or compromised guest VM to trigger a use-after-free by racing an LPI (Locality-specific Peripheral Interrupt) disable against an interrupt affinity migration across vCPUs. When vgic_prune_ap_list() drops and reacquires the irq and ap_list locks, a concurrent affinity change can free the interrupt out from under it, leading to a kernel UAF that can crash the host or potentially enable host-kernel code execution. This is not in CISA KEV and no public exploit identified at time of analysis; EPSS is low (0.21%, 11th percentile), consistent with a hard-to-win race rather than a turnkey exploit.
Improper state unwinding in the Linux kernel KVM nested VMX (nVMX) subsystem allows a low-privileged local attacker operating within an L1 guest to potentially escape the virtualization boundary and gain control over the host hypervisor's page table base register (CR3). When EPT is disabled and the deferred vTPR-vs-TPR Threshold consistency check fails, KVM does not restore vmcs01.GUEST_CR3 to its own value, leaving it set to an L1-controlled address - enabling a malicious guest to redirect hypervisor memory mappings to attacker-controlled structures. No public exploit has been identified and no CISA KEV listing exists; EPSS at 0.20% (10th percentile) confirms currently low observed exploitation probability.
Incomplete SEV-SNP state handling in the Linux kernel's KVM subsystem breaks AMD Secure Encrypted Virtualization isolation when intra-host VM migration or mirroring is attempted on SNP guests, potentially exposing encrypted guest memory to confidentiality and integrity breaches. The vulnerability affects multiple stable kernel branches from commit 1dfe571c12cf99244b933208fb77f29471ded677 onward, with fixes backported to 6.12.97, 6.18.40, 7.1.5, and 7.2-rc4. No public exploit code exists at time of analysis, and the EPSS score of 0.21% at the 11th percentile places real-world exploitation probability as very low despite the high official CVSS score of 8.8.
Out-of-bounds kernel memory access in Linux KVM's Intel TDX subsystem allows a local, low-privileged user to exploit a TOCTOU race condition during TD virtual machine initialization, potentially achieving kernel memory disclosure, corruption, or denial of service. The vulnerable path exists in tdx_td_init(), where the cpuid.nent field is read once to size a flexible allocation and then again from the copied structure - allowing userspace to change the count between those two references. No active exploitation has been confirmed and EPSS probability is very low (0.20%, 10th percentile), limiting immediate real-world risk to TDX-enabled production environments.
Denial-of-service in the Linux kernel's KVM x86 subsystem allows a guest VM to crash the host hypervisor by exploiting a state inconsistency in PV EOI (paravirtual end-of-interrupt) handling. When a guest triggers a memory read failure in `pv_eoi_get_user()` while concurrently disabling PV EOI, KVM fires a fatal assertion in `kvm_lapic_sync_from_vapic()` at `lapic.c:3338`, producing a kernel BUG and crashing the host. This takes down all co-resident virtual machines. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but vendor-confirmed patches are available across multiple stable kernel branches.
Use-after-free in the Linux kernel's KVM x86 irqfd subsystem exposes hypervisor hosts to potential privilege escalation and VM escape when VFIO PCI device passthrough is in use. The flaw arises because a failed IRTE bypass update leaves irqfd->producer as a dangling pointer; if the VFIO PCI vector is subsequently disabled-an event independent of KVM routing-the now-freed vfio_pci_irq_ctx struct can be dereferenced through KVM's routing table, corrupting kernel memory. No public exploit has been identified at time of analysis and EPSS is low (0.22%, 13th percentile), but the S:C scope change in the CVSS vector reflects the potential for a low-privilege local attacker to escape VM boundaries into the host kernel.
Improper locking scope in the Linux kernel KVM subsystem exposes a use-after-free race condition through `kvm_io_bus_get_dev()`, where the function drops the SRCU lock before returning a device pointer, leaving a window in which the referenced object may be freed before the caller can safely inspect it. All Linux kernel versions from the introducing commit (approximately 4.8) through the 7.1 and 6.x stable series are affected until patched releases across eight stable branches are applied. No public exploit has been identified at time of analysis, and the EPSS score of 0.22% reflects a low current probability of exploitation despite the High CVSS severity rating.
Denial of service in the Linux kernel's KVM arm64 nested virtualization subsystem allows a guest to crash the host hypervisor by writing to the ZCR_EL2 system register alias during a nested context. Affected systems run arm64 Linux kernel builds where FEAT_NV2 is advertised to an L1 guest hypervisor; the write is architecturally legitimate in this context, but a misplaced WARN triggers a hyp_panic, taking down the KVM hypervisor layer. No public exploit or CISA KEV listing exists, and EPSS probability sits at 0.21% (11th percentile), reflecting low observed exploitation activity.
Improper permission handling in the KVM ARM64 nested-virtualization (NV) subsystem of the Linux kernel (6.16 through fixes in 6.18.40/7.1.5) lets a malicious L1 guest hypervisor write to a read-only backing page and trigger a page reference leak on the host. When mapping the L1 VNCR page into the host stage-1, KVM trusted only the guest stage-1 permissions and ignored that the backing PFN may be read-only (e.g. a read-only memslot), permitting writes to memory that should be immutable and leaking pages on the read-only early-return path. There is no public exploit identified at time of analysis; EPSS is low (0.21%, 11th percentile) and the issue is not in CISA KEV.
Guest-to-host memory corruption in the Linux kernel's arm64 KVM nested-virtualization (NV) path arises from mishandling of the VNCR page translation: when a nested guest reads the VNCR page before writing, the host maps the PFN read-only and fails to re-fetch a writable translation on the subsequent write abort. The fix invalidates the VNCR TLB and re-translates before injecting the abort, restoring correct write-fault handling and satisfying FEAT_ETS2/3 ordering. There is no public exploit identified at time of analysis, EPSS is low (0.21%), and it is not on CISA KEV.
Denial-of-service in the Linux kernel's arm64 KVM nested-virtualization (NV) support allows an L1 guest to trigger a host System Error (SError) by pointing its VNCR mapping at a non-memory PFN. Because kvm_translate_vncr() unconditionally applies cacheable memory attributes without checking whether the backing PFN is real memory, a writeback to a device/non-cacheable endpoint can raise an uncontained SError on the host. The upstream fix makes KVM reject non-memory backing and inject a Synchronous External Abort (SEA) into the guest instead. There is no public exploit identified at time of analysis and EPSS is low (0.21%).
Server-Side Request Forgery in Red Hat Quay's build API allows an authenticated user with repository write access to pivot into internal network segments via the Quay builder service. Exploitation requires FEATURE_BUILD_SUPPORT to be enabled and the attacker to hold at least write-level repository permissions. The CVSS vector (PR:L, C:H) reflects a meaningful but bounded threat: internal network reconnaissance and sensitive data disclosure are achievable, though no public exploit exists and EPSS sits at 0.13% (3rd percentile), indicating no observed widespread exploitation at time of analysis.
Red Hat Quay 3's exported action logs download endpoint fails to enforce authorization, permitting any network-accessible party who holds a valid file ID to retrieve full audit log exports without authenticating. The file IDs, while complex and not publicly guessable, are transmitted in plaintext via email notifications and webhook callbacks - creating a realistic interception pathway for adversaries with network positioning. No active exploitation or public POC has been identified; EPSS at 0.31% (23rd percentile) reflects low automated exploitation probability, though targeted disclosure remains credible wherever log export notifications traverse unencrypted channels.
Red Hat Quay's Stripe billing webhook handler at /webhooks/stripe processes inbound JSON payloads without verifying the Stripe-Signature HMAC header, enabling any network-reachable unauthenticated attacker to forge billing events. Successful exploitation resets the targeted namespace's build quota to its configured maximum and dispatches unsolicited billing notification emails to namespace administrators. No public exploit has been identified and EPSS is 0.14% (4th percentile), but the zero-prerequisite attack path makes exploitation trivially scriptable by any attacker with HTTP access to the endpoint.
Red Hat Quay 3 and Red Hat OpenShift Update Service expose an unauthenticated security scanner notification endpoint when the SECURITY_SCANNER_V4_PSK (pre-shared key) is absent, enabling remote unauthenticated attackers to flood the notification queue and inject path traversal characters into outbound Clair API URL paths. The primary impact is worker resource exhaustion leading to denial of service, with a secondary low-integrity impact from blind path manipulation against the configured Clair vulnerability scanner host. No public exploit identified at time of analysis, and EPSS of 0.26% (17th percentile) indicates low current exploitation probability.
Cross-site scripting in JupyterLab 3.3.0 through 4.5.9 and 4.6.0 through 4.6.1 enables arbitrary code execution in a victim's browser session through a crafted overrides.json settings file. The sideBySideLeftMarginOverride and sideBySideRightMarginOverride notebook extension settings are inserted unsanitized into CSS style content, allowing a payload to execute with full JupyterLab API access - enabling notebook reads/writes and arbitrary kernel command execution under the victim's credentials. No public exploit has been identified at time of analysis and the vulnerability is not in CISA KEV, but the CVSS 4.0 score of 8.6 with high confidentiality and integrity impact reflects meaningful real-world risk, particularly in multi-user JupyterHub deployments.
Arbitrary OS command injection in FreePBX Music on Hold module versions 17.0.1 through 17.0.6 allows an authenticated administrator to execute commands as the asterisk service user by supplying dangerous player arguments through the custom application configuration interface. The validateCustomConfiguration() function in Music.class.php accepted player command-line options for mpg123, mpg321, madplay, ogg123, and cvlc without blocking file-write, FIFO, or network control flags, because the applicationUsesDisallowedPlayerOption() function lacked the blocklist logic needed to reject them. No public exploit code or active exploitation has been identified at time of analysis; the issue is patched in version 17.0.7.
Improper transparency log verification in the Go module checksum database (GOSUMDB) client allows a coordinating malicious GOPROXY and GOSUMDB pair to serve arbitrary, tampered module content to developers without triggering any client-side integrity error. All cmd/go versions before 1.25.13, 1.26.6, and 1.27.0-rc.3, as well as golang.org/x/mod/sumdb before 0.40.0, are affected. No public exploit code has been identified at time of analysis and CISA has not listed this in KEV, but the supply chain attack surface means developers may have silently pulled poisoned dependencies before patching, making retrospective verification via re-fetching module sums mandatory.
Exponential parsing time in js-yaml 5.0.0 through 5.2.1 enables unauthenticated remote denial of service via a crafted YAML payload under 200 bytes. The parser's flow-collection logic re-parses nested flow-sequence keys rather than caching results, producing O(2^n) work per nesting level - approximately 30 levels suffices to stall a Node.js process for over two minutes on a single CPU. A functional proof-of-concept is published in the GHSA advisory; no special YAML features or non-default configuration options are required to trigger the flaw.
Entity expansion limit bypass in fast-xml-parser 5.9.3-5.10.0 enables remote unauthenticated denial of service against any Node.js service parsing untrusted XML. The parser's OrderedObjParser.js passes each encountered DOCTYPE declaration through addInputEntities(), which reinitializes the entity-expansion safety counters (maxTotalExpansions, maxExpandedLength) on every call - a crafted document with multiple DOCTYPE blocks therefore resets these guards to zero repeatedly within a single parse operation, nullifying protections against billion-laughs-style exponential entity expansion. The result is excessive CPU consumption, event-loop blocking, memory exhaustion, and process termination. No active exploitation has been confirmed (not in CISA KEV), but exploitation requires zero authentication or special configuration beyond the default entity-processing behavior.
Out-of-bounds read in PostGIS before 3.7.0beta2 enables low-privileged database users to disclose server process memory or crash the PostgreSQL backend by passing malformed FlatGeobuf geometry data to the extension's property metadata decoder. The decoder validates that a string length prefix is present but omits a bounds check confirming the string body falls within the supplied buffer before materializing it as a SQL-visible value, creating both a memory disclosure and denial-of-service path. A publicly available exploit demonstrates successful memory disclosure against managed PostgreSQL platforms including NeonDB and Supabase; exploitation is not confirmed in CISA KEV but the public proof-of-concept and multi-tenant exposure substantially elevate real-world risk.
Out-of-bounds write in rsync 3.2.3 through 3.4.x corrupts .bss-segment memory via misuse of snprintf() return semantics in parse_size_arg(), enabling remote denial-of-service and potential memory corruption with high availability impact. The CVSS 4.0 score of 8.3 with AV:N/PR:N reflects that an unauthenticated remote attacker can reach the vulnerable code path, though AC:H indicates the truncation condition requires a specifically crafted size argument. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis. The fix is confirmed in v3.5.0, designated a major security release by the maintainers.
Authorization bypass in rsync 3.1.0 through 3.4.x allows authenticated users to circumvent module-level access controls when group-based deny rules are configured with space-containing group names. The auth users directive's comma-only parser silently discards deny rules for any @Group Name entry whose group name contains a space, granting unintended access to restricted rsync modules regardless of the administrator's intended group-based exclusions. The rsync project designated v3.5.0 a major security release to address this flaw; no CISA KEV listing or public exploit code has been identified at time of analysis.
Symlink race condition in rsync before 3.5.0 allows directory traversal beyond the configured module root during sender-side scanning. Attackers with write access to a path component of the scanned tree can exploit a TOCTOU window between lstat() and opendir() system calls to redirect traversal outside the module boundary, causing rsync to enumerate and transfer files from unintended filesystem locations. This affects both daemon-mode and non-daemon sender-side scanning configurations; no public exploit has been identified at time of analysis, and the vulnerability is not listed in CISA KEV.
Symlink race condition in rsync before 3.5.0 enables local privilege escalation by allowing an attacker to redirect ACL and extended attribute application to arbitrary files outside the intended destination tree. A low-privileged local attacker exploits the timing window between rsync's file write and the subsequent acl_set_file() or lsetxattr() call by substituting a crafted symlink at a predictable destination path, causing rsync to stamp permissions onto unintended files. No public exploit code has been identified at time of analysis, and the flaw is not listed in CISA KEV; however, the CVSS 4.0 score of 7.2 reflects genuine high confidentiality and integrity impact when successfully timed.
Arbitrary file deletion in rsync before 3.5.0 allows a malicious sender to expand the scope of --delete operations beyond the intended destination subtree by sending a crafted file list. All rsync versions prior to 3.5.0 are affected through multiple attack variants including implied parent directory reclassification, synthetic root path construction, legacy protocol behavior (protocol version below 30), and non-directory root handling. No public exploit has been identified at time of analysis, though the CVSS 4.0 score of 7.1 with network vector and low complexity reflects meaningful real-world risk for any deployment that syncs from potentially untrusted or compromised senders with --delete enabled.
Path traversal in rsync daemon before 3.5.0 allows remote rsync clients to read and write files outside the configured module root. The root cause is the daemon calling chdir() to the module root at session start without resolving symlinks via realpath(), so if the module root path or any path component is a symlink, subsequent relative-path operations resolve against the symlink target instead of the intended directory. Exploitation requires two server-side conditions - use chroot disabled and a symlink anywhere in the module root path - but no special conditions on the attacker side beyond having rsync client access to the module. No public exploit code or CISA KEV listing is identified at time of analysis.
Arbitrary file read in rsync before 3.5.0 enables attackers with local low-privilege access to read files accessible to the rsync daemon process by exploiting improper symlink resolution in input configuration file handling. The vulnerability affects --files-from, --password-file, and filter merge file paths, allowing placement of a symlink at a predictable argument path or supply of a --files-from path that escapes the daemon module root. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis; the vendor has released a confirmed fix in rsync 3.5.0.
Remote code execution in PostgreSQL logical decoding (versions before 18.5, 17.11, 16.15, 15.19, and 14.24) allows any database user holding REPLICATION privilege - a role explicitly below superuser - to load arbitrary shared libraries via dlopen by specifying a malicious logical decoding plugin name, executing arbitrary code as the OS account running the server. This is a missing authorization flaw (CWE-862): the REPLICATION privilege was not intended to grant the ability to load native code. No public exploit code or CISA KEV listing has been identified at time of analysis, though the high-impact CVSS 7.2 vector and RCE outcome make this a high-priority patching target for any deployment that grants REPLICATION to non-superusers.
Command injection in the PostgreSQL psql client (versions before 18.5, 17.11, 16.15, 15.19, and 14.24) allows an attacker who controls both a malicious server and the supplied data rows to execute arbitrary psql meta-commands on the connecting client host. The flaw is triggered when a COPY FROM STDIN or \copy FROM STDIN operation fails with a premature server-side error - before the server signals readiness to receive data rows - causing psql to misinterpret the inline data stream as client-side command input rather than row data. No public exploit code has been identified at time of analysis, but the CVSS 8.1 score reflects the potential for full confidentiality, integrity, and availability impact when the dual-control preconditions are met.
Code injection in PostgreSQL's pg_dump, pg_dumpall, and pg_restore (plain-format mode) allows a malicious superuser of an origin database server to embed arbitrary OS-level commands into a dump file, which execute on the restoring client's operating system account when psql processes the dump. This is a confirmed bypass of the CVE-2025-8714 patch: the \unrestrict meta-command introduced by that fix is itself exploitable via psql meta-command input expansion, negating the protection that \restrict was intended to provide. No public exploit has been identified at time of analysis, but the high CVSS score (8.8) and full RCE impact make this urgent for any organization that accepts and restores PostgreSQL dumps from external or untrusted sources.
SQL injection in PostgreSQL's EXTRACT() expression deparse enables a database object owner to escalate privileges and execute arbitrary SQL with superuser rights. Affected across the active PostgreSQL release tree - versions before 14.24, 15.19, 16.15, 17.11, and 18.5 - the flaw is triggered when deparse consumers such as pg_dump or psql's \sf command process a hostile object definition crafted by a low-privilege but authenticated database user. No public exploit code or CISA KEV listing exists at time of analysis; however, the superuser privilege-escalation impact and broad reach of affected deparse consumers make this a high-priority upgrade, particularly for multi-tenant or shared PostgreSQL environments.
Stack buffer overflow in PostgreSQL's argument name matching logic allows a database object creator to crash backend processes and achieve low integrity impact by supplying a crafted OUT parameter count. Affected are all active major branches: versions 14.x before 14.24, 15.x before 15.19, 16.x before 16.15, 17.x before 17.11, and 18.x before 18.5. No public exploit or CISA KEV listing has been identified at time of analysis; however, the constrained-write nature of the overflow (limited to 0x0 and 0x1 bytes) caps realistic impact at availability loss rather than arbitrary code execution, making this a high-priority patch rather than an emergency incident response trigger.
Type confusion in PostgreSQL's 'refint' contrib module enables any low-privileged database user with object creation rights to execute arbitrary code as the operating system user hosting the PostgreSQL service. Affected are all active PostgreSQL branches prior to versions 18.5, 17.11, 16.15, 15.19, and 14.24. Notably, the fix was silently committed to the PostgreSQL git repository under the subject 'refint: Remove plan cache.' without a CVE assignment, meaning vulnerable installations may have remained unpatched far longer than typical because administrators had no security signal to act on. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
Heap buffer overflow in PostgreSQL's plperl extension allows a database function owner to execute arbitrary code as the OS-level user running the database server by crafting a function body that returns a tied hash. Affected versions span the four active PostgreSQL major release lines prior to 18.5, 17.11, 16.15, 15.19, and 14.24. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
PostgreSQL's ctid data type selectivity estimator mishandles non-ctid input through a type confusion flaw (CWE-843), enabling any low-privileged database user with object-creation rights to read approximately 4 bytes of arbitrary server memory per query. All supported major versions prior to 18.5, 17.11, 16.15, 15.19, and 14.24 are affected. No public exploit code or CISA KEV listing has been identified at time of analysis, but the vendor explicitly acknowledges that substantial memory value recovery is possible.
Authentication bypass in the kin-openapi Go library (getkin/kin-openapi) before 0.144.0 lets unauthenticated remote attackers reach protected routes when an application uses openapi3filter.ValidationHandler as its enforcement middleware without explicitly setting an AuthenticationFunc. Because Load() silently substitutes a no-op callback for a nil AuthenticationFunc, every OpenAPI security requirement is treated as satisfied and the fail-closed guard is never reached. There is no public exploit identified at time of analysis and it is not in CISA KEV, but the flaw is fail-open by default, disclosed with source-level detail in GHSA-r277-6w6q-xmqw, and carries a vendor CVSS of 9.1.
Memory exhaustion in etcd's TLS acceptor loop allows unauthenticated network attackers to crash etcd clusters - and the Kubernetes control planes they back - without completing a TLS handshake. The vulnerable code path in `client/pkg/transport/listener_tls.go` spawns a goroutine per inbound TCP connection with no timeout, meaning connections that never send a ClientHello block indefinitely inside `tls.Conn.Handshake()` and accumulate in an unbounded `pending` map. Exploitation is trivially automatable: no special protocol knowledge is needed beyond initiating TCP connections. No public exploit code or CISA KEV listing exists at time of analysis, but the Kubernetes control plane dependency elevates real-world blast radius well beyond a standalone etcd outage.
Watch API authorization bypass in etcd allows any authenticated low-privilege user to silently read the entire keyspace beyond their granted key. A user holding a READ grant on a single exact key can invoke the Watch gRPC API with clientv3.WithFromKey() to receive streaming events for every key lexicographically greater than or equal to their permitted key - an unbounded confidentiality breach against etcd's RBAC model. Affected versions span etcd prior to 3.5.33, 3.6.0-3.6.13, and 3.7.0 pre-releases; fixes are released as 3.5.33, 3.6.14, and 3.7.1. No public exploit code or CISA KEV listing exists at time of analysis, but the trivial exploit path (a single standard gRPC flag) makes weaponization straightforward for any attacker with valid credentials.
Privilege escalation in Red Hat Advanced Cluster Management for Kubernetes 2 lets a namespace-scoped tenant abuse the multicloud-operators-subscription controller as a confused deputy: by crafting Subscription Custom Resources, a namespace-admin causes the controller's highly privileged ServiceAccount to deploy attacker-chosen cluster-scoped resources. This breaks tenant isolation and can yield cluster-wide privilege escalation and arbitrary code execution. Rated CVSS 9.9 (scope-changing), with no public exploit identified at time of analysis and no active exploitation reported (not in CISA KEV).
Unauthorized cross-tenant Secret and ConfigMap access in the multicloud-operators-channel component of Red Hat Advanced Cluster Management for Kubernetes 2 allows a compromised managed-cluster agent to read all Secrets and ConfigMaps within any Channel namespace on the hub cluster. The Changed scope (S:C) in the CVSS vector confirms that exploitation pivots from a managed cluster context into the hub, exposing Git and Helm repository credentials belonging to other tenants. No public exploit has been identified at time of analysis, but the network-reachable, low-privilege vector makes this a high-priority finding in any multi-tenant RHACM deployment.
Cross-tenant bearer-token disclosure in Red Hat Advanced Cluster Management for Kubernetes 2 (RHACM) lets an authenticated tenant abuse the GitOpsCluster controller in the multicloud-integrations component to redirect spoke-cluster credentials into a namespace they control. Because the controller acts on the tenant's behalf across trust boundaries (a confused-deputy flaw), a low-privileged user can obtain tokens that grant access to managed spoke clusters and bypass ArgoCD AppProject scoping controls. No public exploit identified at time of analysis, and it is not listed in CISA KEV; the CVSS base score is 9.6 (Critical).
Incorrect JSON Pointer escape-sequence decoding in cJSON versions 1.5.0 through 1.7.19 allows unauthenticated network attackers to redirect RFC 6902 JSON Patch operations to unintended object keys by supplying crafted ~0 or ~1 sequences in patch paths. Any application that exposes cJSONUtils_ApplyPatches() or cJSONUtils_ApplyPatchesCaseSensitive() to external input is vulnerable to silent data corruption, unintended key deletion, and potential authorization bypass when JSON Patch is used to gate access-controlled modifications. No public exploit code or CISA KEV listing has been identified at time of analysis, but the network-accessible, zero-authentication attack surface and high integrity impact (CVSS 4.0: 8.7) make this a meaningful risk for any service built on cJSON's utility layer.
Server-impersonation via broken TLS hostname verification affects Apache HttpComponents Client 5.4 through 5.6.3 when applications use the asynchronous HttpClient, where the HostnameVerificationPolicy#BUILTIN setting is silently ignored. An adversary positioned to intercept and modify network traffic can present a valid certificate issued for an unrelated domain and the async client will accept it, defeating the core TLS server-identity check and exposing transmitted data. There is no public exploit identified at time of analysis and EPSS is very low (0.09%), but the CVSS base score is 9.1 and the classic (synchronous) HttpClient is explicitly unaffected.
Improper error handling in the Linux kernel's netfs (network filesystem) subsystem allows a local user with low privileges to corrupt kernel folio state or trigger a kernel hang. The writeback_iter() loop fails to re-invoke itself with the error code set when a write operation fails, leaving folios unlocked and non-redirtied, which produces incorrect iteration state with high integrity and availability consequences. No public exploit code has been identified, and EPSS places exploitation probability at 0.21% (11th percentile), consistent with a constrained local kernel defect rather than a broadly weaponized vulnerability.
Integrity and availability compromise in the Linux kernel's Intel Xe GPU Physical Function (PF) driver allows a low-privileged local user operating within a guest Virtual Function (VF) environment to trigger PF-side assertion failures and ABI protocol breakage by sending FAST_REQUEST or EVENT relay messages - message types the PF handler is not designed to process. The vulnerability crosses a privilege boundary from guest to host, reflected in the CVSS scope-changed rating of 8.4. No public exploit code exists and no active exploitation has been confirmed; EPSS stands at 0.21% (11th percentile). Vendor-released patches are available across multiple stable kernel branches.
Invalid cursor access in the Linux kernel's Intel Xe GPU (drm/xe) page table subsystem allows local low-privileged users to trigger kernel warnings and potentially exploit uninitialized memory during page table binding walks involving purged buffer objects. Affected kernel versions span Linux 7.1 up to the fix points in 7.1.5 and 7.2-rc2, and only systems equipped with Intel Xe GPU hardware are at risk. No public exploit identified at time of analysis; EPSS at 0.20% (10th percentile) reflects minimal current exploitation interest, though the kernel memory-management context elevates the theoretical impact ceiling.
Context confusion in the Linux kernel's uprobes/x86 subsystem allows a local attacker with low privileges to trigger incorrect VMA lookups by exploiting the use of `current->mm` (the tracer's memory map) instead of the traced process's `mm_struct` during uprobe unregistration. Affected are kernel versions in the 6.18.x, 7.1.x, and pre-rc2 7.2 branches originating from commit ba2bfc97b462. Patches are confirmed in 6.18.40, 7.1.5, and 7.2-rc2; no public exploit code has been identified and the vulnerability is not listed in CISA KEV, with EPSS at a low 0.21% (11th percentile).
Credit resource leak in the Linux kernel CIFS client function cifs_issue_read() enables a server-side actor to exhaust the SMB flow-control credit pool on a connected Linux host, producing a denial of service for all I/O on the affected CIFS mount. Linux kernel versions from commit 69c3c023af25edb5433a2db824d3e7cc328f0183 onward are affected until stable-tree patches landing in 6.12.97, 6.18.40, 7.1.5, and 7.2-rc2. No public exploit identified at time of analysis; EPSS of 0.21% (11th percentile) confirms very low real-world exploitation probability and no CISA KEV listing exists.
Memory-ordering (barriering) defect in the Linux kernel's netfs subsystem allows a subrequest that was just added by an application thread to be observed inconsistently while the retry path walks the subrequest list, risking use of partially-initialized data. The flaw affects netfs-backed network filesystems (e.g. AFS, Ceph, CIFS, 9p) in kernels from 6.10 onward and has been resolved upstream. There is no public exploit identified at time of analysis, and the EPSS score is very low (0.20%, 10th percentile), indicating negligible observed exploitation interest despite the NVD's 9.8 rating.
Use-after-free in the Linux kernel's legacy NTFS filesystem driver (ntfs_mft_writepages) allows a local low-privileged attacker to corrupt kernel slab memory by winning a timing race between MFT writeback and concurrent MFT allocation extension. Affected kernels span the Linux 7.1 stable series up through 7.1.4; fix commits are confirmed in the upstream stable tree targeting 7.1.5 and 7.2-rc3. No public exploit is identified at time of analysis and EPSS is low (0.20%), but the confirmed slab-use-after-free in ring-0 writeback code represents a high-severity memory safety defect warranting scheduled patching.
Use-after-free race condition in the Linux kernel's legacy NTFS driver (ntfs.ko) exposes systems with NTFS-mounted volumes to kernel heap memory corruption, enabling local privilege escalation, information disclosure, or kernel panic. The flaw in ntfs_attr_fallocate() releases a read lock before consuming a borrowed runlist pointer, while a concurrent mmap page_mkwrite path can simultaneously reallocate and free the underlying array - confirmed by a KASAN slab-use-after-free trace in the CVE description. No public exploit or CISA KEV entry exists; EPSS of 0.20% (10th percentile) reflects the difficulty of reliably winning this race, though successful exploitation carries severe kernel-level impact.
Integer wraparound in the Linux kernel HID-BPF subsystem's hid_bpf_get_data() helper allows a local low-privileged user to bypass a buffer range check and obtain an out-of-bounds pointer into kernel memory, potentially enabling privilege escalation or memory corruption. Affected kernels span from Linux 6.3 (commit 658ee5a64fcfbbf) through versions prior to 6.12.97, 6.18.40, 7.1.5, and 7.2-rc3, where upstream fix commits have landed. No public exploit has been identified at time of analysis and EPSS remains at 0.21%, but the CVSS 7.8 local-privilege score reflects a high-impact, low-complexity code path once local access is established.
Out-of-bounds read in the Linux kernel's Generic UDP Encapsulation (GUE) tunnel receive path lets remote attackers read adjacent packet memory by sending malformed GUE packets that set the GUE_PFLAG_REMCSUM private flag without carrying the corresponding remote-checksum start/offset bytes. Because guehdr_priv_flags_len() failed to account for GUE_PLEN_REMCSUM, such truncated packets slipped past validate_gue_flags() and were then processed by gue_remcsum()/gue_gro_remcsum(), which read the missing fields from following bytes. There is no public exploit identified at time of analysis; EPSS is low (0.22%, 13th percentile) and the flaw is not in CISA KEV, so despite the headline CVSS 9.8 the realistic impact is information disclosure/instability rather than confirmed remote code execution.
Undefined-behavior shift in the Linux kernel's netfilter xt_u32 match module allows a local attacker with CAP_NET_ADMIN to supply malformed packet-filter rules containing shift counts of 32 or more, triggering out-of-bounds shift operations on 32-bit values in u32_match_it() during live packet evaluation. The vulnerability affects all kernel versions from 2.6.23 (when xt_u32 was introduced) through the stable-branch fix commits, with patched versions confirmed across six stable trees. No active exploitation (KEV) or public proof-of-concept has been identified; EPSS sits at the 13th percentile, reflecting currently limited exploitation probability.
Netfilter ip6tables rule evasion in the Linux kernel allows remote attackers to slip malformed IPv6 packets past firewall policy. The ah, hbh, and rt matches for IPv6 extension headers derived the header length without fully validating it against available skb data, so a packet whose advertised extension-header length exceeded the real data was treated as a rule mismatch (returning false) rather than being dropped - letting it bypass ip6tables rules specifically written to drop such traffic. The fix sets hotdrop=true so malformed packets are discarded. No public exploit identified at time of analysis; EPSS is low (0.23%, 14th percentile) and this is not in CISA KEV.
Undefined-shift undefined behavior in the Linux kernel netfilter subsystem (xt_connmark) allows a local attacker with low privileges to trigger kernel crashes, potential memory corruption, and limited information disclosure. The flaw resides in the CONNMARK target revision 2, introduced in Linux 4.17, where user-supplied shift_bits values of 32 or greater are passed unchecked to 32-bit bitshift operations in connmark_tg_shift(), invoking C undefined behavior at packet-processing time. Exploitation is not confirmed active (not in CISA KEV) and EPSS sits at 0.21% (12th percentile), but the kernel-level impact and wide Linux deployment make patching a clear priority for exposed hosts.
Off-by-one memory corruption in the Linux kernel's mlx5 LAG (Link Aggregation) subsystem exposes systems with Mellanox/NVIDIA ConnectX NICs to local privilege escalation via a defective error rollback loop in `mlx5_lag_create_single_fdb()`. When rule installation fails at index `i`, the cleanup loop incorrectly begins teardown at `i` rather than `i-1`, operating on uninitialized kernel state or double-freeing a rule the `add_one` path already rolled back - resulting in heap corruption with C:H/I:H/A:H impact potential. No public exploit or CISA KEV listing exists at time of analysis; EPSS probability stands at 0.20% (10th percentile), and upstream fix commits are confirmed available.
Kernel crash via bad memory access in the mlx5e traffic control peer flow cleanup path affects Linux systems running Mellanox/NVIDIA mlx5 NICs in LAG (Link Aggregation Group) mode. When mlx5_lag_get_dev_seq() returns an error during device teardown - because the peer is absent from the LAG or no master device is marked - the driver proceeds to dereference an invalid pointer in mlx5e_tc_del_fdb_peers_flow, causing a kernel panic. No public exploit exists and EPSS is 0.20% (10th percentile), but the crash is deterministically reproducible on affected hardware configurations during device removal or driver teardown sequences.
Memory corruption in the Linux kernel mlx5e driver's Hyper-V VHCA statistics subsystem causes a kernel fault when running as a Hyper-V guest with a Mellanox/NVIDIA ConnectX NIC. The driver initializes the stats buffer with a zero-size allocation that returns ZERO_SIZE_PTR (0x10) instead of NULL, bypasses the NULL guard, and stores the sentinel pointer; once channels open and the hypervisor enables stats reporting, a subsequent memset on address 0x10 faults the kernel. No public exploit identified at time of analysis; EPSS is 0.21% (12th percentile), reflecting minimal real-world exploitation likelihood despite the high official CVSS score.
The mlx5e HV VHCA stats agent registration in the Linux kernel contains an initialization race condition that can produce NULL pointer dereferences or kernel timer list corruption, crashing a Hyper-V guest VM. Affected systems are those running Linux on Microsoft Hyper-V with a Mellanox mlx5e NIC across stable kernel trees spanning 6.1 through 7.1, with the root cause being that mlx5_hv_vhca_agent_create() publishes the agent and triggers an asynchronous workqueue callback before the caller has initialized the associated delayed_work structure and agent pointer. No public exploit code has been identified and EPSS exploitation probability is 0.21% (12th percentile); vendor patches have been released across all active stable branches and upstream commit references are available via kernel.org.
Race condition in the Linux kernel's Microchip VCAP network driver corrupts hardware forwarding table entries on systems using sparx5 or lan969x switching ASICs. A local authenticated user can simultaneously trigger a debugfs VCAP rule dump and a tc-flower rule write to different Super VCAP instances, causing shared cache registers to be overwritten mid-transaction and committing corrupt data directly into hardware forwarding entries. No public exploit code or CISA KEV listing exists; EPSS is 0.21%, reflecting low exploitation likelihood in practice.
Memory corruption in the Linux kernel qede network driver (QLogic/Marvell FastLinQ 40/100GbE) arises because qede_rx_build_skb() and qede_tpa_rx_build_skb() do not check for a NULL return from qede_build_skb(), consuming an extra buffer descriptor and desynchronizing the RX BD ring. The resulting off-by-one can corrupt DMA page reference counts and trigger SLUB freelist corruption, most plausibly a kernel-crash denial of service rather than reliable code execution. No public exploit has been identified and it is not in CISA KEV; the low EPSS (0.22%, 13th percentile) reflects that the bug only manifests under kernel memory pressure.
Heap out-of-bounds write in the Linux kernel's act_pedit TC offload path allows a local attacker holding CAP_NET_ADMIN to corrupt kernel slab memory with attacker-controlled content, potentially leading to privilege escalation or denial of service. The flaw affects Linux kernel versions from approximately 4.11 through the stable branches patched in 6.6.145, 6.12.97, 6.18.40, 7.1.5, and 7.2-rc3. Trend Micro ZDI researchers confirmed exploitability via KASAN trace using a targeted POC; no public exploit has been released and this CVE is not listed in the CISA KEV catalog.
Use-after-free in the Linux kernel Bluetooth MGMT advertising monitor subsystem allows a local attacker with low privileges to corrupt kernel heap memory, potentially achieving privilege escalation. The flaw arises from a ownership race: hci_add_adv_monitor() publishes a new adv_monitor into the hdev->adv_monitors_idr before the MSFT HCI offload setup step completes, allowing the MSFT callback to free the monitor on failure while the MGMT completion path still holds a dangling pointer. KASAN confirmed the slab-use-after-free in mgmt_add_adv_patterns_monitor_complete; no public exploit or active exploitation (CISA KEV) has been identified, and EPSS is 0.21% (12th percentile).
Bluetooth ISO packet reassembly in the Linux kernel mishandles malformed ISO_CONT and ISO_END packets, exposing adjacent attackers to three distinct kernel-level impacts: a conn->rx_skb memory leak via abnormal ISO_START sequences, a kernel panic triggered by an unchecked skb_put call on oversized ISO_END frames, and silent acceptance of undersized ISO_END packets. All Linux kernel versions from 6.0 through the fix commits on affected stable branches are impacted, with fixes confirmed in 7.1.5 and 7.2-rc3. No public exploit or CISA KEV listing exists at time of analysis, but the CVSS 8.8 AV:A/PR:N vector and the availability of upstream fix commits make this an actionable patching priority for any Bluetooth-enabled Linux deployment.
Use-after-free in the Linux kernel's accel/amdxdna driver exposes systems with AMD XDna NPU hardware to local privilege escalation by a low-privileged attacker. The race condition exists between `aie2_populate_range()` and `amdxdna_umap_release()`, both of which dereference a stale VMA pointer after the underlying virtual memory area may have been freed by the kernel memory manager. With EPSS at 0.20% (10th percentile), no CISA KEV listing, and no public exploit identified at time of analysis, active exploitation is not currently observed - though the CVSS 7.8 score correctly reflects the theoretical potential for full kernel compromise on affected hardware configurations.
Denial of service in the Linux kernel's kernel TLS (kTLS) subsystem allows a remote peer to permanently stall a TLS connection by sending a single zero-length TLS 1.3 application_data record. The `tls_sw_read_sock()` function misinterprets the empty record's zero-length return as a backpressure signal, requeuing the record indefinitely at the head of rx_list and blocking all subsequent TLS data on that connection. No public exploit code exists, the CVE is absent from the CISA KEV catalog, and EPSS sits at 0.21% (11th percentile), indicating low current exploitation interest despite the 7.5 CVSS score.
Kernel-memory corruption in the Linux kernel's net/liquidio (Marvell/Cavium LiquidIO SmartNIC) SR-IOV driver stems from caching virtual-function pci_dev pointers that hold no reference; the stale pointer is later dereferenced when servicing an OCTEON_VF_FLR_REQUEST, yielding a use-after-free reachable from a virtual function. Affected systems are hosts running the liquidio PF driver with SR-IOV enabled and VFs assigned to guests. Successful triggering can crash the host or corrupt kernel memory (potential privilege/scope escalation from a VF into the host); this is no public exploit identified at time of analysis, EPSS is low (0.20%), and a vendor fix is available.
Use-after-free race condition in the Linux kernel's AMD XDNA accelerator driver (accel/amdxdna) allows a local, low-privileged attacker on systems with AMD XDNA hardware to corrupt kernel memory, potentially achieving full privilege escalation. The race window opens because amdxdna_umap_release() calls the blocking mmu_interval_notifier_remove() before removing the object from abo->mem.umap_list, permitting aie2_populate_range() to obtain a stale reference concurrently. No public exploit has been identified at time of analysis, and an EPSS of 0.21% (11th percentile) signals minimal current exploitation interest.
Kernel panic (and potential memory corruption) in the Linux kernel's IPv6 multicast stack arises from a use-after-free in the MLD delayed-work path, where a race between network-device teardown and incoming MLD query processing lets igmp6_event_query() take a reference on an inet6_dev whose refcount has already reached zero. Affected systems run kernels across the 2.6.12-through-7.x range prior to the fixed stable releases, and successful triggering causes a refcount 'addition on 0' warning followed by access to freed memory once the scheduled work runs. There is no public exploit identified at time of analysis, EPSS risk is low (0.22%, 13th percentile), and it is not listed in CISA KEV.
Firewall policy bypass in the Linux kernel's netfilter nftables subsystem allows remote attackers to evade packet-filtering rules that use inverted set lookups. The flaw lives in nft_lookup_eval(), where the match result for negated lookups ('!= @set') is computed before the catchall element used by interval sets is folded in, so rules resolve to the wrong verdict. It affects the nf_tables classifier across a wide range of kernel branches; there is no public exploit identified at time of analysis and EPSS probability is low (0.21%).
Improper handling of ICMP error packets in the Linux kernel's IPVS (IP Virtual Server) subsystem allows crafted ICMP errors from tunneled traffic to reference inner IP headers that are not guaranteed to reside in the skb headroom after pskb_pull() strips the outer headers, leading to out-of-bounds access in path-MTU update, icmp_send() and debug paths. The flaw affects hosts using IPVS load balancing with tunnel encapsulation; the practical consequence is an out-of-bounds read (information disclosure per source tags) or kernel crash rather than code execution. No public exploit identified at time of analysis, EPSS is low (0.22%, 13th percentile), and it is not listed in CISA KEV.
Out-of-bounds kernel memory read in the Linux kernel's CIFS/SMB client (parse_dfs_referrals) affects hosts that mount SMB shares involving DFS referrals. A malicious or man-in-the-middle SMB server can return a referral whose server-supplied string offsets point beyond the received response buffer; the unchecked offset yields a negative max_len that reaches kstrndup()/strnlen() as a size_t, causing an out-of-bounds read that can leak adjacent kernel memory or crash the client. CVSS is 9.4, but there is no public exploit identified at time of analysis, it is not in CISA KEV, and EPSS is low (0.21%, 12th percentile), indicating no observed exploitation.
Use-after-free (refcount_t underflow) in the Linux kernel's SUNRPC TLS connect path lets a failing TLS-secured RPC transport dereference an already-freed upper rpc_clnt, corrupting kernel memory. It affects systems using RPC-with-TLS transports (notably NFS-over-TLS/mTLS mounts) where a fatal handshake failure races the delayed connect_worker. There is no public exploit identified at time of analysis and EPSS is low (0.21%, 11th percentile); the input's 9.8 CVSS reflects Linux's automated scoring rather than the local, config-dependent trigger described.
Linux kernel SMB/CIFS client exposes a race condition between direct I/O (DIO) write completion and filesystem unmount that leaves dentry reference counts unreleased, triggering a kernel BUG warning and potential use-after-free condition. Local users with access to CIFS-mounted shares can trigger this by initiating a DIO write and concurrently unmounting the filesystem, allowing the kernel's shrink_dcache_for_umount() to fire before deferred workqueue cleanup has decremented the dentry refcount. With CVSS 7.8 and C:H/I:H/A:H, the theoretical impact is full kernel compromise, though no public exploit and an EPSS of 0.20% (10th percentile) indicate this remains a low-exploitation-probability vulnerability at time of analysis.
The regulator subsystem in the Linux kernel contains a deadlock-handling defect where `regulator_lock_two()` compares the return value of `ww_mutex_lock()` against `-EDEADLOCK` instead of the correct `-EDEADLK` constant. On MIPS architecture - the only platform where the regulator core is active and these two error constants carry different numeric values - the mismatch causes the kernel to skip the mandatory unlock-and-retry backoff sequence, fire `WARN_ON`, and return to the caller with only one of the two regulators locked, producing corrupted locking state. No public exploit has been identified and EPSS is very low (0.22%, 13th percentile), but the high CVSS impact ratings (C:H/I:H/A:H) reflect the potential for kernel panic or local privilege escalation on affected MIPS systems.
The octeontx2-af driver in the Linux kernel mishandles SR-IOV mailbox requests for nix_set_rx_mode, allowing a low-privileged user controlling a Virtual Function on Marvell OcteonTX2 hardware to silently delete the Physical Function's MCAM promiscuous and allmulti filtering rules through ordinary interface bringup or teardown operations. Affected Linux kernel versions span 5.14 through multiple stable branches, patched in 6.1.178, 6.6.145, 6.12.97, 6.18.40, 7.1.5, and 7.2-rc3. No public exploit identified at time of analysis; EPSS is 0.21% (12th percentile), consistent with negligible observed exploitation activity and the hardware-specific attack surface.
Integer overflow in the Linux kernel SMB client's smb2_ioctl_query_info() function enables a malicious SMB server to bypass bounds checking during PASSTHRU_FSCTL response processing, leading to an out-of-bounds kernel memory read disclosed to userspace. Affected systems are Linux kernels across multiple stable branches where OutputOffset and qi.input_buffer_length are summed without overflow protection, allowing a server-controlled 32-bit wrap to defeat the bounds check and cause copy_to_user() to read beyond the response buffer. No public exploit has been identified at time of analysis, and the EPSS score of 0.22% reflects low current exploitation probability, but the network-reachable attack surface and high confidentiality impact (CVSS 8.1) make patching a near-term priority for any Linux host using SMB client connectivity.
Kernel memory corruption in the Linux ASoC Sound Open Firmware (SOF) IPC4 control subsystem allows a low-privileged local user to trigger incorrect buffer copy lengths in sof_ipc4_bytes_put(), potentially achieving high confidentiality, integrity, and availability impact. The root cause is a logic error - not a race - where the copy size is sourced from the stale in-kernel buffer's size field rather than from the incoming user-supplied sof_abi_hdr.size in ucontrol, enabling data truncation or stale-byte copying into kernel structures. No public exploit code or active exploitation has been identified at time of analysis; patch commits are available across multiple stable kernel series.
Missing payload size validation in the Linux kernel's ASoC SOF IPC4 control subsystem allows a local low-privileged attacker to trigger out-of-bounds memory access when the kernel processes MODULE_NOTIFICATION messages. Affected systems are those running Linux kernel 7.0 and related stable branches where the SOF IPC4 audio driver is active - typically Intel hardware using Sound Open Firmware. No public exploit or CISA KEV listing exists, and EPSS sits at 0.20% (10th percentile), indicating low current exploitation interest, though the CVSS 7.8 score reflects real kernel-level impact potential.
Integer overflow in the Linux kernel's ASoC Sound Open Firmware (SOF) IPC3 control handler allows a local, low-privileged attacker on 32-bit platforms to bypass buffer size validation and trigger out-of-bounds memory access in `snd_sof_update_control`. The flaw exists because `sof_ipc3_control_update()` performs unguarded arithmetic on firmware-supplied `cdata->num_elems`, which wraps on 32-bit integer arithmetic and causes the subsequent header size check to pass with mismatched values. No public exploit code exists and no CISA KEV listing is present; EPSS probability is 0.23% at the 14th percentile, with vendor patches available across multiple stable kernel branches.
Memory corruption and information disclosure in the Linux kernel's ASoC Sound Open Firmware (SOF) IPC3 control subsystem allows local users with low privileges to corrupt kernel memory or leak sensitive data. The flaw affects sof_ipc3_bytes_put() and sof_ipc3_bytes_get() functions, where wrong-size memcpy operations and an off-by-sizeof bounds check create exploitable memory safety violations. No public exploit or CISA KEV listing exists at time of analysis; the EPSS score of 0.21% (12th percentile) reflects a low but non-negligible near-term exploitation probability.
Integer overflow in the Linux kernel's QRTR (Qualcomm IPC Router) subsystem on 32-bit platforms allows an out-of-bounds kernel heap write via a crafted incoming packet. On 32-bit builds where size_t is four bytes, passing size >= 0xfffffffd to ALIGN(size, 4) wraps the result to zero, bypassing the packet validation check in qrtr_endpoint_post() and allowing skb_put_data() to write attacker-controlled data far beyond the allocated socket buffer. This is the 32-bit residual of commit ad9d24c9429e2, which fixed only the 64-bit case; 64-bit kernels are structurally unaffected. No public exploit is identified at time of analysis, and EPSS at 0.22% reflects low exploitation probability.
Out-of-bounds read in the Linux kernel ATM networking subsystem (`net/atm`) allows local low-privileged users to disclose kernel memory or crash the system by supplying an out-of-range `traffic_class` value via the `SO_ATMQOS` socket option. The flaw persists because `check_tp()` fails to reject traffic class values above `ATM_ANYCLASS`, leaving the invalid value in `vcc->qos` where it is later used as an unguarded array index in `pvc_info()` when `/proc/net/atm/pvc` is read. EPSS sits at 0.22% (13th percentile) with no CISA KEV listing and no public exploit identified, making real-world exploitation risk considerably lower than the CVSS 7.1 score implies, particularly given that ATM networking is a legacy subsystem absent from most modern deployments.
Denial-of-service in the Linux kernel's IFE (Inter-Forwarding-Element) traffic-control action allows a crafted, malformed IFE frame to crash the host, because ife_decode() only guaranteed the outer IFE header was pullable before handing the decapsulated packet to eth_type_trans(), which then reads an inner Ethernet header that may be shorter than ETH_HLEN in the linear skb area. Only systems that have the tc act_ife action configured are exposed. There is no public exploit identified at time of analysis, EPSS is low (0.22%, 13th percentile), and it is not in CISA KEV; the fix adds ETH_HLEN to the pull check.
Out-of-bounds array indexing in the Linux kernel's KVM irqfd routing for LoongArch allows a local user with KVM access to index past the routing table's chip array boundary, potentially exposing host kernel memory or enabling a hypervisor boundary breach with full triad impact. Patches are available in stable releases 6.18.40, 7.1.5, and 7.2-rc1 across three upstream commits. No public exploit code exists and EPSS sits at 0.21% (11th percentile), indicating negligible active exploitation probability despite the elevated CVSS 8.8 score.
Missing interrupt request (IRQ) validity checking in the LoongArch KVM subsystem of the Linux kernel allows a local low-privileged user with access to KVM device nodes to pass malformed IRQ values via the kvm_vcpu_ioctl_interrupt() ioctl, potentially causing memory corruption or privilege escalation that crosses the guest-to-host boundary. The CVSS scope change (S:C) signals that successful exploitation could compromise the hypervisor host, making this significant for LoongArch-based virtualization environments. No public exploit code has been identified and EPSS probability sits at 0.21%, suggesting exploitation remains theoretical at this time.
Local privilege/information-disclosure risk in the Linux kernel's s390 KVM subsystem stems from an unlikely race in try_get_locked_pte(), where puds or pmds can be unmapped between the p?dp_get() and p?d_offset() calls, leaving code operating on a stale or freed page-table entry. The flaw affects s390 (IBM Z mainframe) systems running KVM virtualization and has now been patched upstream; no public exploit identified at time of analysis and EPSS exploitation probability is low (0.20%, 10th percentile).
Memory corruption in the Linux kernel's KVM/arm64 GICv3 virtualization (vgic) subsystem allows a local attacker on an ARM64 KVM host to trigger a double list removal, corrupting the ap_list and enabling a use-after-free style condition. The flaw lives in vgic_prune_ap_list(), where an interrupt can be pruned from a vCPU's active/pending list a second time after vgic_flush_pending_lpis() already removed it, because the affinity re-check does not confirm the interrupt is still owned by the vCPU. No public exploit is identified at time of analysis, and EPSS is low (0.22%), consistent with a race-condition kernel bug that is difficult to weaponize.
Local privilege escalation / host memory corruption in the Linux kernel's arm64 KVM vGIC subsystem allows a malicious or compromised guest VM to trigger a use-after-free by racing an LPI (Locality-specific Peripheral Interrupt) disable against an interrupt affinity migration across vCPUs. When vgic_prune_ap_list() drops and reacquires the irq and ap_list locks, a concurrent affinity change can free the interrupt out from under it, leading to a kernel UAF that can crash the host or potentially enable host-kernel code execution. This is not in CISA KEV and no public exploit identified at time of analysis; EPSS is low (0.21%, 11th percentile), consistent with a hard-to-win race rather than a turnkey exploit.
Improper state unwinding in the Linux kernel KVM nested VMX (nVMX) subsystem allows a low-privileged local attacker operating within an L1 guest to potentially escape the virtualization boundary and gain control over the host hypervisor's page table base register (CR3). When EPT is disabled and the deferred vTPR-vs-TPR Threshold consistency check fails, KVM does not restore vmcs01.GUEST_CR3 to its own value, leaving it set to an L1-controlled address - enabling a malicious guest to redirect hypervisor memory mappings to attacker-controlled structures. No public exploit has been identified and no CISA KEV listing exists; EPSS at 0.20% (10th percentile) confirms currently low observed exploitation probability.
Incomplete SEV-SNP state handling in the Linux kernel's KVM subsystem breaks AMD Secure Encrypted Virtualization isolation when intra-host VM migration or mirroring is attempted on SNP guests, potentially exposing encrypted guest memory to confidentiality and integrity breaches. The vulnerability affects multiple stable kernel branches from commit 1dfe571c12cf99244b933208fb77f29471ded677 onward, with fixes backported to 6.12.97, 6.18.40, 7.1.5, and 7.2-rc4. No public exploit code exists at time of analysis, and the EPSS score of 0.21% at the 11th percentile places real-world exploitation probability as very low despite the high official CVSS score of 8.8.
Out-of-bounds kernel memory access in Linux KVM's Intel TDX subsystem allows a local, low-privileged user to exploit a TOCTOU race condition during TD virtual machine initialization, potentially achieving kernel memory disclosure, corruption, or denial of service. The vulnerable path exists in tdx_td_init(), where the cpuid.nent field is read once to size a flexible allocation and then again from the copied structure - allowing userspace to change the count between those two references. No active exploitation has been confirmed and EPSS probability is very low (0.20%, 10th percentile), limiting immediate real-world risk to TDX-enabled production environments.
Denial-of-service in the Linux kernel's KVM x86 subsystem allows a guest VM to crash the host hypervisor by exploiting a state inconsistency in PV EOI (paravirtual end-of-interrupt) handling. When a guest triggers a memory read failure in `pv_eoi_get_user()` while concurrently disabling PV EOI, KVM fires a fatal assertion in `kvm_lapic_sync_from_vapic()` at `lapic.c:3338`, producing a kernel BUG and crashing the host. This takes down all co-resident virtual machines. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but vendor-confirmed patches are available across multiple stable kernel branches.
Use-after-free in the Linux kernel's KVM x86 irqfd subsystem exposes hypervisor hosts to potential privilege escalation and VM escape when VFIO PCI device passthrough is in use. The flaw arises because a failed IRTE bypass update leaves irqfd->producer as a dangling pointer; if the VFIO PCI vector is subsequently disabled-an event independent of KVM routing-the now-freed vfio_pci_irq_ctx struct can be dereferenced through KVM's routing table, corrupting kernel memory. No public exploit has been identified at time of analysis and EPSS is low (0.22%, 13th percentile), but the S:C scope change in the CVSS vector reflects the potential for a low-privilege local attacker to escape VM boundaries into the host kernel.
Improper locking scope in the Linux kernel KVM subsystem exposes a use-after-free race condition through `kvm_io_bus_get_dev()`, where the function drops the SRCU lock before returning a device pointer, leaving a window in which the referenced object may be freed before the caller can safely inspect it. All Linux kernel versions from the introducing commit (approximately 4.8) through the 7.1 and 6.x stable series are affected until patched releases across eight stable branches are applied. No public exploit has been identified at time of analysis, and the EPSS score of 0.22% reflects a low current probability of exploitation despite the High CVSS severity rating.
Denial of service in the Linux kernel's KVM arm64 nested virtualization subsystem allows a guest to crash the host hypervisor by writing to the ZCR_EL2 system register alias during a nested context. Affected systems run arm64 Linux kernel builds where FEAT_NV2 is advertised to an L1 guest hypervisor; the write is architecturally legitimate in this context, but a misplaced WARN triggers a hyp_panic, taking down the KVM hypervisor layer. No public exploit or CISA KEV listing exists, and EPSS probability sits at 0.21% (11th percentile), reflecting low observed exploitation activity.
Improper permission handling in the KVM ARM64 nested-virtualization (NV) subsystem of the Linux kernel (6.16 through fixes in 6.18.40/7.1.5) lets a malicious L1 guest hypervisor write to a read-only backing page and trigger a page reference leak on the host. When mapping the L1 VNCR page into the host stage-1, KVM trusted only the guest stage-1 permissions and ignored that the backing PFN may be read-only (e.g. a read-only memslot), permitting writes to memory that should be immutable and leaking pages on the read-only early-return path. There is no public exploit identified at time of analysis; EPSS is low (0.21%, 11th percentile) and the issue is not in CISA KEV.
Guest-to-host memory corruption in the Linux kernel's arm64 KVM nested-virtualization (NV) path arises from mishandling of the VNCR page translation: when a nested guest reads the VNCR page before writing, the host maps the PFN read-only and fails to re-fetch a writable translation on the subsequent write abort. The fix invalidates the VNCR TLB and re-translates before injecting the abort, restoring correct write-fault handling and satisfying FEAT_ETS2/3 ordering. There is no public exploit identified at time of analysis, EPSS is low (0.21%), and it is not on CISA KEV.
Denial-of-service in the Linux kernel's arm64 KVM nested-virtualization (NV) support allows an L1 guest to trigger a host System Error (SError) by pointing its VNCR mapping at a non-memory PFN. Because kvm_translate_vncr() unconditionally applies cacheable memory attributes without checking whether the backing PFN is real memory, a writeback to a device/non-cacheable endpoint can raise an uncontained SError on the host. The upstream fix makes KVM reject non-memory backing and inject a Synchronous External Abort (SEA) into the guest instead. There is no public exploit identified at time of analysis and EPSS is low (0.21%).
Server-Side Request Forgery in Red Hat Quay's build API allows an authenticated user with repository write access to pivot into internal network segments via the Quay builder service. Exploitation requires FEATURE_BUILD_SUPPORT to be enabled and the attacker to hold at least write-level repository permissions. The CVSS vector (PR:L, C:H) reflects a meaningful but bounded threat: internal network reconnaissance and sensitive data disclosure are achievable, though no public exploit exists and EPSS sits at 0.13% (3rd percentile), indicating no observed widespread exploitation at time of analysis.
Red Hat Quay 3's exported action logs download endpoint fails to enforce authorization, permitting any network-accessible party who holds a valid file ID to retrieve full audit log exports without authenticating. The file IDs, while complex and not publicly guessable, are transmitted in plaintext via email notifications and webhook callbacks - creating a realistic interception pathway for adversaries with network positioning. No active exploitation or public POC has been identified; EPSS at 0.31% (23rd percentile) reflects low automated exploitation probability, though targeted disclosure remains credible wherever log export notifications traverse unencrypted channels.
Red Hat Quay's Stripe billing webhook handler at /webhooks/stripe processes inbound JSON payloads without verifying the Stripe-Signature HMAC header, enabling any network-reachable unauthenticated attacker to forge billing events. Successful exploitation resets the targeted namespace's build quota to its configured maximum and dispatches unsolicited billing notification emails to namespace administrators. No public exploit has been identified and EPSS is 0.14% (4th percentile), but the zero-prerequisite attack path makes exploitation trivially scriptable by any attacker with HTTP access to the endpoint.
Red Hat Quay 3 and Red Hat OpenShift Update Service expose an unauthenticated security scanner notification endpoint when the SECURITY_SCANNER_V4_PSK (pre-shared key) is absent, enabling remote unauthenticated attackers to flood the notification queue and inject path traversal characters into outbound Clair API URL paths. The primary impact is worker resource exhaustion leading to denial of service, with a secondary low-integrity impact from blind path manipulation against the configured Clair vulnerability scanner host. No public exploit identified at time of analysis, and EPSS of 0.26% (17th percentile) indicates low current exploitation probability.
Cross-site scripting in JupyterLab 3.3.0 through 4.5.9 and 4.6.0 through 4.6.1 enables arbitrary code execution in a victim's browser session through a crafted overrides.json settings file. The sideBySideLeftMarginOverride and sideBySideRightMarginOverride notebook extension settings are inserted unsanitized into CSS style content, allowing a payload to execute with full JupyterLab API access - enabling notebook reads/writes and arbitrary kernel command execution under the victim's credentials. No public exploit has been identified at time of analysis and the vulnerability is not in CISA KEV, but the CVSS 4.0 score of 8.6 with high confidentiality and integrity impact reflects meaningful real-world risk, particularly in multi-user JupyterHub deployments.
Arbitrary OS command injection in FreePBX Music on Hold module versions 17.0.1 through 17.0.6 allows an authenticated administrator to execute commands as the asterisk service user by supplying dangerous player arguments through the custom application configuration interface. The validateCustomConfiguration() function in Music.class.php accepted player command-line options for mpg123, mpg321, madplay, ogg123, and cvlc without blocking file-write, FIFO, or network control flags, because the applicationUsesDisallowedPlayerOption() function lacked the blocklist logic needed to reject them. No public exploit code or active exploitation has been identified at time of analysis; the issue is patched in version 17.0.7.
Improper transparency log verification in the Go module checksum database (GOSUMDB) client allows a coordinating malicious GOPROXY and GOSUMDB pair to serve arbitrary, tampered module content to developers without triggering any client-side integrity error. All cmd/go versions before 1.25.13, 1.26.6, and 1.27.0-rc.3, as well as golang.org/x/mod/sumdb before 0.40.0, are affected. No public exploit code has been identified at time of analysis and CISA has not listed this in KEV, but the supply chain attack surface means developers may have silently pulled poisoned dependencies before patching, making retrospective verification via re-fetching module sums mandatory.
Exponential parsing time in js-yaml 5.0.0 through 5.2.1 enables unauthenticated remote denial of service via a crafted YAML payload under 200 bytes. The parser's flow-collection logic re-parses nested flow-sequence keys rather than caching results, producing O(2^n) work per nesting level - approximately 30 levels suffices to stall a Node.js process for over two minutes on a single CPU. A functional proof-of-concept is published in the GHSA advisory; no special YAML features or non-default configuration options are required to trigger the flaw.
Entity expansion limit bypass in fast-xml-parser 5.9.3-5.10.0 enables remote unauthenticated denial of service against any Node.js service parsing untrusted XML. The parser's OrderedObjParser.js passes each encountered DOCTYPE declaration through addInputEntities(), which reinitializes the entity-expansion safety counters (maxTotalExpansions, maxExpandedLength) on every call - a crafted document with multiple DOCTYPE blocks therefore resets these guards to zero repeatedly within a single parse operation, nullifying protections against billion-laughs-style exponential entity expansion. The result is excessive CPU consumption, event-loop blocking, memory exhaustion, and process termination. No active exploitation has been confirmed (not in CISA KEV), but exploitation requires zero authentication or special configuration beyond the default entity-processing behavior.
Out-of-bounds read in PostGIS before 3.7.0beta2 enables low-privileged database users to disclose server process memory or crash the PostgreSQL backend by passing malformed FlatGeobuf geometry data to the extension's property metadata decoder. The decoder validates that a string length prefix is present but omits a bounds check confirming the string body falls within the supplied buffer before materializing it as a SQL-visible value, creating both a memory disclosure and denial-of-service path. A publicly available exploit demonstrates successful memory disclosure against managed PostgreSQL platforms including NeonDB and Supabase; exploitation is not confirmed in CISA KEV but the public proof-of-concept and multi-tenant exposure substantially elevate real-world risk.
Out-of-bounds write in rsync 3.2.3 through 3.4.x corrupts .bss-segment memory via misuse of snprintf() return semantics in parse_size_arg(), enabling remote denial-of-service and potential memory corruption with high availability impact. The CVSS 4.0 score of 8.3 with AV:N/PR:N reflects that an unauthenticated remote attacker can reach the vulnerable code path, though AC:H indicates the truncation condition requires a specifically crafted size argument. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis. The fix is confirmed in v3.5.0, designated a major security release by the maintainers.
Authorization bypass in rsync 3.1.0 through 3.4.x allows authenticated users to circumvent module-level access controls when group-based deny rules are configured with space-containing group names. The auth users directive's comma-only parser silently discards deny rules for any @Group Name entry whose group name contains a space, granting unintended access to restricted rsync modules regardless of the administrator's intended group-based exclusions. The rsync project designated v3.5.0 a major security release to address this flaw; no CISA KEV listing or public exploit code has been identified at time of analysis.
Symlink race condition in rsync before 3.5.0 allows directory traversal beyond the configured module root during sender-side scanning. Attackers with write access to a path component of the scanned tree can exploit a TOCTOU window between lstat() and opendir() system calls to redirect traversal outside the module boundary, causing rsync to enumerate and transfer files from unintended filesystem locations. This affects both daemon-mode and non-daemon sender-side scanning configurations; no public exploit has been identified at time of analysis, and the vulnerability is not listed in CISA KEV.
Symlink race condition in rsync before 3.5.0 enables local privilege escalation by allowing an attacker to redirect ACL and extended attribute application to arbitrary files outside the intended destination tree. A low-privileged local attacker exploits the timing window between rsync's file write and the subsequent acl_set_file() or lsetxattr() call by substituting a crafted symlink at a predictable destination path, causing rsync to stamp permissions onto unintended files. No public exploit code has been identified at time of analysis, and the flaw is not listed in CISA KEV; however, the CVSS 4.0 score of 7.2 reflects genuine high confidentiality and integrity impact when successfully timed.
Arbitrary file deletion in rsync before 3.5.0 allows a malicious sender to expand the scope of --delete operations beyond the intended destination subtree by sending a crafted file list. All rsync versions prior to 3.5.0 are affected through multiple attack variants including implied parent directory reclassification, synthetic root path construction, legacy protocol behavior (protocol version below 30), and non-directory root handling. No public exploit has been identified at time of analysis, though the CVSS 4.0 score of 7.1 with network vector and low complexity reflects meaningful real-world risk for any deployment that syncs from potentially untrusted or compromised senders with --delete enabled.
Path traversal in rsync daemon before 3.5.0 allows remote rsync clients to read and write files outside the configured module root. The root cause is the daemon calling chdir() to the module root at session start without resolving symlinks via realpath(), so if the module root path or any path component is a symlink, subsequent relative-path operations resolve against the symlink target instead of the intended directory. Exploitation requires two server-side conditions - use chroot disabled and a symlink anywhere in the module root path - but no special conditions on the attacker side beyond having rsync client access to the module. No public exploit code or CISA KEV listing is identified at time of analysis.
Arbitrary file read in rsync before 3.5.0 enables attackers with local low-privilege access to read files accessible to the rsync daemon process by exploiting improper symlink resolution in input configuration file handling. The vulnerability affects --files-from, --password-file, and filter merge file paths, allowing placement of a symlink at a predictable argument path or supply of a --files-from path that escapes the daemon module root. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis; the vendor has released a confirmed fix in rsync 3.5.0.
Remote code execution in PostgreSQL logical decoding (versions before 18.5, 17.11, 16.15, 15.19, and 14.24) allows any database user holding REPLICATION privilege - a role explicitly below superuser - to load arbitrary shared libraries via dlopen by specifying a malicious logical decoding plugin name, executing arbitrary code as the OS account running the server. This is a missing authorization flaw (CWE-862): the REPLICATION privilege was not intended to grant the ability to load native code. No public exploit code or CISA KEV listing has been identified at time of analysis, though the high-impact CVSS 7.2 vector and RCE outcome make this a high-priority patching target for any deployment that grants REPLICATION to non-superusers.
Command injection in the PostgreSQL psql client (versions before 18.5, 17.11, 16.15, 15.19, and 14.24) allows an attacker who controls both a malicious server and the supplied data rows to execute arbitrary psql meta-commands on the connecting client host. The flaw is triggered when a COPY FROM STDIN or \copy FROM STDIN operation fails with a premature server-side error - before the server signals readiness to receive data rows - causing psql to misinterpret the inline data stream as client-side command input rather than row data. No public exploit code has been identified at time of analysis, but the CVSS 8.1 score reflects the potential for full confidentiality, integrity, and availability impact when the dual-control preconditions are met.
Code injection in PostgreSQL's pg_dump, pg_dumpall, and pg_restore (plain-format mode) allows a malicious superuser of an origin database server to embed arbitrary OS-level commands into a dump file, which execute on the restoring client's operating system account when psql processes the dump. This is a confirmed bypass of the CVE-2025-8714 patch: the \unrestrict meta-command introduced by that fix is itself exploitable via psql meta-command input expansion, negating the protection that \restrict was intended to provide. No public exploit has been identified at time of analysis, but the high CVSS score (8.8) and full RCE impact make this urgent for any organization that accepts and restores PostgreSQL dumps from external or untrusted sources.
SQL injection in PostgreSQL's EXTRACT() expression deparse enables a database object owner to escalate privileges and execute arbitrary SQL with superuser rights. Affected across the active PostgreSQL release tree - versions before 14.24, 15.19, 16.15, 17.11, and 18.5 - the flaw is triggered when deparse consumers such as pg_dump or psql's \sf command process a hostile object definition crafted by a low-privilege but authenticated database user. No public exploit code or CISA KEV listing exists at time of analysis; however, the superuser privilege-escalation impact and broad reach of affected deparse consumers make this a high-priority upgrade, particularly for multi-tenant or shared PostgreSQL environments.
Stack buffer overflow in PostgreSQL's argument name matching logic allows a database object creator to crash backend processes and achieve low integrity impact by supplying a crafted OUT parameter count. Affected are all active major branches: versions 14.x before 14.24, 15.x before 15.19, 16.x before 16.15, 17.x before 17.11, and 18.x before 18.5. No public exploit or CISA KEV listing has been identified at time of analysis; however, the constrained-write nature of the overflow (limited to 0x0 and 0x1 bytes) caps realistic impact at availability loss rather than arbitrary code execution, making this a high-priority patch rather than an emergency incident response trigger.
Type confusion in PostgreSQL's 'refint' contrib module enables any low-privileged database user with object creation rights to execute arbitrary code as the operating system user hosting the PostgreSQL service. Affected are all active PostgreSQL branches prior to versions 18.5, 17.11, 16.15, 15.19, and 14.24. Notably, the fix was silently committed to the PostgreSQL git repository under the subject 'refint: Remove plan cache.' without a CVE assignment, meaning vulnerable installations may have remained unpatched far longer than typical because administrators had no security signal to act on. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
Heap buffer overflow in PostgreSQL's plperl extension allows a database function owner to execute arbitrary code as the OS-level user running the database server by crafting a function body that returns a tied hash. Affected versions span the four active PostgreSQL major release lines prior to 18.5, 17.11, 16.15, 15.19, and 14.24. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
PostgreSQL's ctid data type selectivity estimator mishandles non-ctid input through a type confusion flaw (CWE-843), enabling any low-privileged database user with object-creation rights to read approximately 4 bytes of arbitrary server memory per query. All supported major versions prior to 18.5, 17.11, 16.15, 15.19, and 14.24 are affected. No public exploit code or CISA KEV listing has been identified at time of analysis, but the vendor explicitly acknowledges that substantial memory value recovery is possible.
Authentication bypass in the kin-openapi Go library (getkin/kin-openapi) before 0.144.0 lets unauthenticated remote attackers reach protected routes when an application uses openapi3filter.ValidationHandler as its enforcement middleware without explicitly setting an AuthenticationFunc. Because Load() silently substitutes a no-op callback for a nil AuthenticationFunc, every OpenAPI security requirement is treated as satisfied and the fail-closed guard is never reached. There is no public exploit identified at time of analysis and it is not in CISA KEV, but the flaw is fail-open by default, disclosed with source-level detail in GHSA-r277-6w6q-xmqw, and carries a vendor CVSS of 9.1.
Memory exhaustion in etcd's TLS acceptor loop allows unauthenticated network attackers to crash etcd clusters - and the Kubernetes control planes they back - without completing a TLS handshake. The vulnerable code path in `client/pkg/transport/listener_tls.go` spawns a goroutine per inbound TCP connection with no timeout, meaning connections that never send a ClientHello block indefinitely inside `tls.Conn.Handshake()` and accumulate in an unbounded `pending` map. Exploitation is trivially automatable: no special protocol knowledge is needed beyond initiating TCP connections. No public exploit code or CISA KEV listing exists at time of analysis, but the Kubernetes control plane dependency elevates real-world blast radius well beyond a standalone etcd outage.
Watch API authorization bypass in etcd allows any authenticated low-privilege user to silently read the entire keyspace beyond their granted key. A user holding a READ grant on a single exact key can invoke the Watch gRPC API with clientv3.WithFromKey() to receive streaming events for every key lexicographically greater than or equal to their permitted key - an unbounded confidentiality breach against etcd's RBAC model. Affected versions span etcd prior to 3.5.33, 3.6.0-3.6.13, and 3.7.0 pre-releases; fixes are released as 3.5.33, 3.6.14, and 3.7.1. No public exploit code or CISA KEV listing exists at time of analysis, but the trivial exploit path (a single standard gRPC flag) makes weaponization straightforward for any attacker with valid credentials.
Privilege escalation in Red Hat Advanced Cluster Management for Kubernetes 2 lets a namespace-scoped tenant abuse the multicloud-operators-subscription controller as a confused deputy: by crafting Subscription Custom Resources, a namespace-admin causes the controller's highly privileged ServiceAccount to deploy attacker-chosen cluster-scoped resources. This breaks tenant isolation and can yield cluster-wide privilege escalation and arbitrary code execution. Rated CVSS 9.9 (scope-changing), with no public exploit identified at time of analysis and no active exploitation reported (not in CISA KEV).
Unauthorized cross-tenant Secret and ConfigMap access in the multicloud-operators-channel component of Red Hat Advanced Cluster Management for Kubernetes 2 allows a compromised managed-cluster agent to read all Secrets and ConfigMaps within any Channel namespace on the hub cluster. The Changed scope (S:C) in the CVSS vector confirms that exploitation pivots from a managed cluster context into the hub, exposing Git and Helm repository credentials belonging to other tenants. No public exploit has been identified at time of analysis, but the network-reachable, low-privilege vector makes this a high-priority finding in any multi-tenant RHACM deployment.
Cross-tenant bearer-token disclosure in Red Hat Advanced Cluster Management for Kubernetes 2 (RHACM) lets an authenticated tenant abuse the GitOpsCluster controller in the multicloud-integrations component to redirect spoke-cluster credentials into a namespace they control. Because the controller acts on the tenant's behalf across trust boundaries (a confused-deputy flaw), a low-privileged user can obtain tokens that grant access to managed spoke clusters and bypass ArgoCD AppProject scoping controls. No public exploit identified at time of analysis, and it is not listed in CISA KEV; the CVSS base score is 9.6 (Critical).
Incorrect JSON Pointer escape-sequence decoding in cJSON versions 1.5.0 through 1.7.19 allows unauthenticated network attackers to redirect RFC 6902 JSON Patch operations to unintended object keys by supplying crafted ~0 or ~1 sequences in patch paths. Any application that exposes cJSONUtils_ApplyPatches() or cJSONUtils_ApplyPatchesCaseSensitive() to external input is vulnerable to silent data corruption, unintended key deletion, and potential authorization bypass when JSON Patch is used to gate access-controlled modifications. No public exploit code or CISA KEV listing has been identified at time of analysis, but the network-accessible, zero-authentication attack surface and high integrity impact (CVSS 4.0: 8.7) make this a meaningful risk for any service built on cJSON's utility layer.
Server-impersonation via broken TLS hostname verification affects Apache HttpComponents Client 5.4 through 5.6.3 when applications use the asynchronous HttpClient, where the HostnameVerificationPolicy#BUILTIN setting is silently ignored. An adversary positioned to intercept and modify network traffic can present a valid certificate issued for an unrelated domain and the async client will accept it, defeating the core TLS server-identity check and exposing transmitted data. There is no public exploit identified at time of analysis and EPSS is very low (0.09%), but the CVSS base score is 9.1 and the classic (synchronous) HttpClient is explicitly unaffected.