Suse
Monthly
The Linux kernel's Panthor DRM driver for ARM Mali CSF-based GPUs (Mali-G310/G510/G610/G710/G720 class hardware) fails to safely validate the build-info metadata block it parses out of the loaded firmware image: panthor_fw_read_build_info() adds the u32 header fields hdr.meta_start and hdr.meta_size without overflow protection, reads the "git_sha: " prefix without first confirming the metadata is long enough, and can underflow the trailing NULL terminator index when meta_size is zero. An attacker who can supply or influence the firmware blob can therefore make malformed metadata pass validation and drive out-of-bounds reads, yielding information disclosure and potential availability impact on the GPU/driver. Exploitation is local and privileged (CVSS PR:H, i.e. authenticated with high privileges) and requires a system with Panthor active and Mali CSF hardware; default vendor-signed firmware is unaffected, and the independent assessment rates the realistic severity far below the vendor's 7.1 as CVSS:3.1/AV:L/AC:H/PR:H/UI:N/S:U/C:L/I:N/A:L. No public exploit code has been identified at time of analysis, and this CVE is not listed in CISA KEV; vendor fixes are shipped in Linux 6.18.51, 7.2.5 and 7.3-rc1.
Out-of-bounds memory access in the Linux kernel's drm/panthor driver for Arm Mali CSF-class GPUs, caused by 32-bit offset arithmetic wrapping before a bounds check in panthor_init_cs_iface() and panthor_init_csg_iface(). A local attacker with low privileges on a system that has CONFIG_DRM_PANTHOR loaded and a Mali CSF GPU present could influence firmware-provided control-interface strides/offsets to escape the mapped region, yielding potential information disclosure and memory corruption (high confidentiality, integrity, and availability impact per the assessed vector). Exploitation requires the ability to supply malicious or compromised firmware content and is rated high complexity in our independent assessment (AV:L/AC:H/PR:L/UI:N); no public exploit code has been identified at time of analysis and there is no CISA KEV confirmation of active exploitation.
A race condition in the Linux kernel's Direct Rendering Manager (DRM) core allows a local low-privileged user to trigger use-after-free-style resource teardown by issuing an ioctl on a partially registered DRM device node. When drm_dev_register() fails after one minor (for example the render minor) has already been registered and opened by userspace, the error path tears down device resources without first setting the unplugged flag, so an in-flight drm_dev_enter() critical section can continue operating on freed state. The vendor rates this CVSS 3.1 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H); our independent assessment keeps the same CIA and local/low-privilege prerequisites but raises attack complexity to High because the attacker must win a narrow window during a probe or hot-plug registration failure that is not normally under their control. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation (CISA KEV); vendor patches are available across the supported stable branches.
Missing validation of the plane degamma LUT size in the Linux kernel's AMD display driver (amdgpu/DC) lets a local, authenticated user who can submit DRM atomic commits supply a malformed AMD_PLANE_DEGAMMA_LUT blob - for example a single-entry LUT - and drive the kernel into a divide-by-zero in __is_lut_linear() or an out-of-bounds read in __drm_lut_to_dc_gamma(). The practical consequence is a kernel crash or denial of service and, via the out-of-bounds read, potential disclosure of kernel memory contents; there is no evidence of memory corruption leading to code execution, and this is a local-only issue. Reachability is narrow: the vulnerable property is exposed only on kernels built with AMD_PRIVATE_COLOR (not enabled in mainstream distribution kernels) and only on systems with an AMD GPU using the amdgpu/DC display path. No public exploit code and no confirmed active exploitation were identified at time of analysis, and vendor patches are available in the stable trees (6.12.110, 6.18.51, 7.2.5) and in mainline 7.3-rc1.
Integer overflow in the Linux kernel's amdgpu VCN decode-message parser lets an authenticated local user with access to the AMD GPU device node bypass a buffer-count bounds check and drive the parser loop far past the end of a message buffer object, producing out-of-bounds kernel reads that crash the system (availability) and can disclose kernel memory (confidentiality). Exploitation is not remote or unauthenticated: the attacker must be a local principal able to submit VCN decode messages and must additionally allocate a roughly 4 GiB GPU-accessible mapping so msg[1] passes the earlier 'header does not fit in BO' check, a substantial resource precondition that our assessment scores as high attack complexity (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:N/A:H). No public exploit code was identified at time of analysis and the issue is not listed as confirmed actively exploited (CISA KEV); this is a genuine but modest-priority local vulnerability.
An out-of-bounds array access in the Linux kernel's AMDGPU driver (drm/amdgpu) lets a local user who can submit GPU work trigger a kernel fault when a ring that was never assigned to a compute partition (AMDGPU_XCP_NO_PARTITION, i.e. ~0) is used on the SDMA isolation-enforcement or VM-flush paths. The access is caught by UBSAN and can crash the kernel, giving a denial-of-service condition with only limited memory-disclosure potential; because the trigger requires local access to an affected AMD GPU running with partition isolation active, exploitation is hardware- and configuration-dependent rather than universally reachable. The vendor has released patches (Linux 6.18.51, 7.2.5 and 7.3-rc1), and no public exploit code was identified at time of analysis; the independent assessment scores this locally as CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:N/A:H, i.e. availability-weighted with low confidentiality impact.
Stale GPU TLB entries in the Linux kernel's AMD KFD (amdkfd) driver let in-flight DMA descriptors from already-unmapped MES-scheduled queues continue reading or writing memory that has been freed or migrated, producing page faults and hung compute queues. The flaw affects AMD GPU/APU systems running KFD/ROCm compute through the MES firmware scheduler path rather than the HWS path (which invalidates the TLB automatically), and was reproduced on gfx1151 (Strix Point) with XNACK mode 1 enabled during SVM page-migration workloads such as KFDSVMRangeTest.MultiThreadMigrationTest. It is a local, timing-sensitive race requiring a GPU-authorized local user, per our assessment triggers only during MES queue eviction (evict_process_queues_cpsch) or debug/CRIU queue suspension (suspend_queues) concurrent with SVM page migration; no public exploit identified at time of analysis, and it is not listed in CISA KEV. Vendor-released patches (Linux 6.18.51, 7.2.5, and 7.3-rc2) add the missing kfd_flush_tlb() calls.
Memory corruption in the Linux kernel's AMD KFD (amdkfd) driver allows a local user with access to the GPU compute interface to corrupt kernel page state when a GPU Shared Virtual Memory (SVM) page migration from device memory to system RAM fails. The error-path cleanup derives the struct page from a DMA/bus address instead of the page's physical address (pfn), so on systems with an enabled IOMMU it releases and unlocks system-RAM pages that the migration never pinned, while the genuinely allocated pages are leaked and their DMA mappings are not torn down correctly. The vendor assigns CVSS 7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H); our independent assessment keeps the same impact but raises attack complexity to AC:H because the faulty cleanup is reachable only after a device-to-system-RAM migration has already failed and requires IOMMU plus an active ROCm/HSA SVM workload. No public exploit identified at time of analysis and it is not confirmed actively exploited (CISA KEV).
Linux kernel AMD KFD (amdkfd) SVM migration code can use an uninitialized return value when migrating a VM range whose CPU side is a hole, causing the driver to tear down all VRAM pages it has just allocated and leaving memory state inconsistent. Affected are Linux kernel builds using the AMD GPU compute path (SVM/HMM migration to VRAM on ROCm/HSA-capable AMD hardware); the flaw affects code reachable from the commit 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 baseline and is fixed in 6.18.51, 7.2.5 and 7.3-rc1. Triggering requires a local user holding a GPU device handle and hitting a racy, non-default memory-layout condition, and no public exploit code was identified at time of analysis; the vendor's CVSS 3.1 score of 7.8 is assessed as overstated relative to this local, condition-gated error-handling defect.
A use-after-put in the Linux kernel's DRM pagemap device-memory migration code (drm_pagemap_migrate_populate_ram_pfn) lets a local, low-privileged user who can drive the GPU/device-private-memory migration path corrupt kernel memory and potentially escalate privileges. The defect has two parts: higher-order (THP) folio allocations lack __GFP_NOWARN and any order-0 fallback, and the free_pages error path computes folio_order(page_folio(page)) after put_page(page) has already dropped the reference, so corrupting state occurs when that put released the last reference. Exploitation requires the DRM pagemap subsystem (new in Linux 6.18) to be built and actively used on supported hardware, plus attacker-induced memory pressure to force the allocation failure, and the severity is moderated by the AC:H assessment in the authoritative analysis; there is no public exploit code and no confirmed active exploitation (no CISA KEV listing) at time of analysis.
A mismatched DMA unmap size in the nouveau DRM driver's device-private memory (dmem) migration path causes the kernel to unmap only PAGE_SIZE instead of the full compound-folio mapping size when device-private transparent huge pages (THP) are migrated. On affected systems running the open-source nouveau driver with dmem THP migration in use, an authenticated local attacker able to drive GPU device-memory migration workloads can repeatedly trigger the nouveau_dmem_migrate_to_ram() success path or the nouveau_dmem_migrate_copy_one() copy-error path, gradually leaking residual IOMMU/IOVA mappings for order>0 folios. No public exploit code exists and the issue is not confirmed as actively exploited (not in CISA KEV); EPSS and KEV signals are absent, and our independent assessment scores this as a low-impact, local-only mapping leak (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:N/A:L) rather than the 8.8 vendor vector, which overstates confidentiality, integrity, and scope impact.
Use-after-free in the Linux kernel's in-tree nouveau DRM driver lets a local user who can access the nouveau device node on a Fermi-generation or newer NVIDIA GPU potentially corrupt memory during channel teardown. The bug is an ordering flaw in nouveau_channel_del(): the channel's fence context is freed by context_del() before the channel-kill event subscription is dropped, so a kill event delivered in that narrow window makes nouveau_channel_killed() call nouveau_fence_context_kill() on an already-freed fence context. No public exploit code has been identified at time of analysis, and although the CNA assigned CVSS 7.8 (AV:L/AC:L/PR:L), our assessment raises attack complexity to High because a kill event must land in a very tight race window - and on current kernels nothing actually kills a channel on this path, making real-world triggerability very low.
Linux kernel builds containing the open-source Nouveau GPU driver (drm/nouveau/uvmm) fail to clear op->reg on two error paths in nouveau_uvmm_bind_job_submit()'s OP_UNMAP_SPARSE arm, so a job that never created a sparse region can drop the region's only reference in nouveau_uvmm_bind_job_cleanup() and free a live object; a second job still owning that region then performs a use-after-free. Exploitation requires local access to the DRM/render device node and the ability to submit VM_BIND jobs (PR:L), plus a trigger of the -ENOENT busy-region check or an -ENOMEM failure from drm_gpuvm_sm_unmap_ops_create(), with the full use-after-free needing a concurrent job holding the same region. No public exploit code or confirmed active exploitation was identified at time of analysis, and systems running the proprietary NVIDIA driver rather than Nouveau are not affected.
A local privilege-escalation use-after-free exists in the Linux kernel perf subsystem: an unprivileged local user can win a tight race between perf_mmap_close() and a concurrent perf_mmap_rb() revival so that a freshly revived ring buffer is freed while another process still has it mapped, yielding page-level memory corruption and a path to root. The bug is reachable under the default kernel.perf_event_paranoid=2 setting (authenticated local account per the CVSS vector PR:L, no user interaction), so hardening the setting or restricting perf_event_open is the practical interim control. Vendor-released patches are available (6.18.52, 7.2.5, 7.3-rc2), the EPSS score is low at 0.19% (9th percentile), and no public exploit code has been identified at time of analysis - but exploitation is local-only and probabilistic, requiring repeated attempts to hit the TOCTOU window.
A use-after-free in the Linux kernel GTP (GPRS Tunnelling Protocol) module allows a local attacker who can create GTP links to trigger a race between link teardown and inbound packet processing, potentially leading to kernel memory corruption with high confidentiality, integrity, and availability impact. Only systems that have the gtp module loaded or reachable are exposed - a mobile-core/telecom feature uncommon in general-purpose Linux deployments - and exploitation requires CAP_NET_ADMIN (obtainable by an unprivileged user within a user namespace) plus a non-deterministic race win, which is why our independent assessment rates the vector AV:L/AC:H/PR:L rather than the published AV:L/AC:L/PR:L. No public exploit code has been identified at time of analysis (EPSS 0.21%, 11th percentile) and the issue is not confirmed actively exploited (CISA KEV).
A use-after-free in the Linux kernel's in-kernel ksmbd SMB3 server allows an authenticated attacker with an established SMB2 session to race an SMB2 TREE_CONNECT request against a concurrent session LOGOFF, so the tree-connection object is freed while smb2_tree_connect() is still initializing it and building the response. Successful triggering yields memory corruption in kernel context that can be leveraged for both confidentiality and integrity impact (KASAN reports slab-use-after-free at fs/smb/server/smb2pdu.c:2872). The CVE carries a 9.8 base score from the kernel CNA, but the assessed vector is AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, reflecting that exploitation requires a valid session and precise timing; EPSS is low (0.19%, 9th percentile), there is no CISA KEV listing, and no public exploit code has been identified at time of analysis.
Out-of-bounds heap reads in the Linux kernel's ext4 inline-directory code (ext4_read_inline_dir()) let a local actor who can present a crafted inline-data ext4 directory - by creating one on a writable ext4 volume with the inline_data feature enabled, or by mounting a malicious ext4 image (e.g. via removable-media automount) - leak kernel heap memory and crash the kernel through an ordinary getdents64()/iterate_dir() call. The kernel emits a KASAN slab-out-of-bounds report in __ext4_check_dir_entry when the size-2 rec_len probe is dereferenced past the end of the kmalloc(inline_size) buffer. There is no public exploit identified at time of analysis, no CISA KEV listing, and EPSS is 0.21% (11th percentile), indicating low predicted exploitation activity; the supplied CVSS of 9.1 (AV:N/PR:N) is inconsistent with the flaw's local-only reachability and should be treated as mis-scored, with the assessed vector being AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H (High).
IPv6 IPsec receive processing in the Linux kernel writes one element past the end of the six-slot xfrm_state pointer array in xfrm6_input_addr(), because the depth guard tests '1 + sp->len == XFRM_MAX_DEPTH' instead of '>=', so a secpath already stacked to XFRM_MAX_DEPTH by xfrm_input() and preserved across xfrm_trans_reinject() bypasses the check and stores into sp->xvec[sp->len++]. The attacker must control an inner packet carrying a Mobile IPv6 destination-options Home Address option or a type-2 routing header, and because the write stays inside the larger sec_path allocation it is invisible to KASAN - it is only flagged by UBSAN_BOUNDS and only fatal when the non-default panic_on_warn sysctl is enabled, otherwise it is a logged warning with no functional effect. This means the input CVSS 3.1 vector of 9.8 (AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:H) is the generic maximal score auto-assigned to Linux kernel CVEs and is not credible for this bug: the authoritative independent assessment rates it CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H (5.9, availability-only, high attack complexity), since exploitation requires IPsec transport mode with six nested SA transforms, a Mobile IPv6 header, and a UBSAN_BOUNDS kernel with panic_on_warn enabled. Exploitation status: no public exploit identified at time of analysis; EPSS is only 0.21% (11th percentile) and the flaw is not listed in CISA KEV, consistent with the layered prerequisites. Authentication requirements: unauthenticated remote attackers (CVSS vector contains PR:N).
Mounting a crafted NTFS filesystem image can corrupt Linux kernel memory through the in-kernel fs/ntfs3 driver, where an integer truncation in restart-table growth (a u32 'used + add' cast to the u16 __le16 count of struct RESTART_TABLE) produces an undersized allocation that is subsequently written past its bounds during $LogFile replay. The issue is local and requires an attacker-supplied image to actually be mounted: on default configurations this needs mount privileges (CAP_SYS_ADMIN/root), while the unprivileged path depends on a USB-automount daemon plus physical insertion of the media, so it is not remotely reachable. Kernels carrying the vulnerable ntfs3 log-replay code before the listed stable fixes are affected; vendor patches are available (Linux 5.15.221, 6.1.188, 6.6.157, 6.12.110, 6.18.52 and 7.2.6, plus 7.3-rc1 in mainline), no public exploit was identified at time of analysis, and EPSS is low at 0.21% (11th percentile).
Mounting a crafted NTFS image on a Linux system with the ntfs3 driver loaded triggers an out-of-bounds read in read_log_rec_buf(), causing a kernel crash and possible disclosure of adjacent slab memory into the log replay buffer. This is a local-only issue that requires the attacker to get the malicious volume mounted, either through physical media with an active automount daemon or a process/user holding mount privileges such as CAP_SYS_ADMIN, and no public exploit was identified at the time of analysis. Vendor patches are available in stable releases 5.15.221, 6.1.188, 6.6.157, 6.12.110, 6.18.52, 7.2.6, and 7.3-rc1, and the independent assessment (AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:H) is lower than the provided 8.4 vector because impact is limited to crash and potential disclosure rather than code execution.
Heap memory disclosure in the Linux kernel's ntfs3 filesystem driver lets an attacker who can get a crafted NTFS image mounted read past the kmalloc-backed extended-attribute buffer and leak kernel heap contents to userspace via getxattr(), with an out-of-bounds read of up to 65535 bytes that can also crash the kernel. The defect is a missing size check in ntfs_read_ea(): a record declaring ef->size = 24 while elength = 0xffff passes validation because only the remaining buffer size is verified, after which ntfs_get_ea() trusts elength and copies the oversize value out of the undersized record. Exploitation is not remotely reachable in default configurations - it requires local access or a system that automounts untrusted removable media (the vendor's CVSS 9.1 AV:N rating overstates exposure), EPSS is 0.21% (11th percentile), and no public exploit code has been identified at time of analysis, though the vendor has released fixes.
An out-of-bounds read in the Linux kernel's ISO9660/zisofs decompression code allows a local attacker to read memory past the end of a page-pointer array (kmalloc-8 slab) by simply read()ing a compressed file from a crafted ISO9660 image. The flaw is reachable only when the image's Rock Ridge 'ZF' record specifies a zisofs block-size shift below PAGE_SHIFT (a value rock.c does not reject) and a sub-page block leaves poffset partway into a page followed by an empty block, so the mount prerequisite and local trigger make this a local availability/limited-disclosure bug rather than a remote one. No public exploit code was identified at time of analysis, and EPSS is low (0.21%, 11th percentile); exploitation is not confirmed in the wild and the vendor's AV:N/PR:N CVSS 9.8 score is not credible for a bug that requires mounting a malicious image on the target - our assessment is AV:L/PR:L with high availability impact and low confidentiality impact.
A memory-corruption flaw in the Linux kernel's vfio-pci driver (vfio/pci/vfio_pci_config.c) allows a local user holding access to a VFIO passthrough device node (typically /dev/vfio/*) to trigger a use-after-free and subsequent double-free of the per-device MSI permission table (vdev->msi_perm). Exploitation requires attacker-induced failure of the allocation path (init_pci_cap_msi_perm()/alloc_perm_bits() returning -ENOMEM during a failed device open, e.g. under memory pressure or fault injection), after which re-opening the same persistent vfio_pci_core_device reuses the freed perm_bits object - dereferencing its readfn/writefn function pointers inside vfio_pci_config_rw_single() - while closing it hits kfree() on an already-freed object in vfio_config_free(). There is no public exploit code identified and no indication of active exploitation at time of analysis; EPSS is low (0.21%, ~11th percentile), and the memory-pressure precondition plus the requirement for VFIO passthrough privileges materially limits real-world reliability, even though the assessed CVSS:3.1:AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H score is high.
A mis-sized TLB invalidation in the Linux kernel's KVM/arm64 stage-1 handling can leave stale translations resident in the TLB when the stage-1 MMU is disabled during a VNCR (nested virtualization / FEAT_NV2) invalidation, so a workload able to drive nested-guest TLB operations on a vulnerable arm64 host may retain access to mappings that should have been flushed. The bug is a correctness defect in TLB-invalidation size computation rather than an exposed remotely reachable primitive: it requires an arm64 host running KVM with nested virtualization enabled on an affected kernel, and our independent assessment rates it AV:L/AC:H/PR:L (local access, high attack complexity), materially lower than the published CVSS 9.3, because no path from a stale-TLB condition to a concrete memory-safety effect has been demonstrated. EPSS is 0.18% (8th percentile) and no public exploit code has been identified at time of analysis; vendor patches are available.
A use-after-free in the Linux kernel's Bluetooth SCO (synchronous connection-oriented) socket handling lets an attacker within Bluetooth radio range race the SCO connection-ready path against a concurrent socket close, dereferencing a freed socket with the potential for kernel memory corruption or a crash. Only systems with Bluetooth enabled and an active SCO listening socket are exposed, and exploitation is unauthenticated but adjacent (AV:A) and highly timing-dependent (AC:H in independent assessment), with the realistic outcome being a kernel denial of service rather than reliable code execution. No public exploit code has been identified at time of analysis and the vulnerability is not in CISA KEV; EPSS is 0.19% (9th percentile), indicating low observed exploitation likelihood, and vendor patches are available in stable releases 5.15.212, 6.1.178, 6.6.145, 6.12.97, 6.18.40 and 7.1.
A time-of-check-to-time-of-use race condition in the Extensions component of Google Chrome on macOS allows an attacker to break out of the renderer sandbox and execute arbitrary code in the browser process context. The barrier to entry is meaningful: the attacker must already have compromised the renderer process through a separate bug and then use social engineering to persuade the victim into a specific UI interaction that widens the race window. Affected builds are Chrome for macOS prior to 153.0.8010.47, and Google rates the issue High severity; no public exploit code or CISA KEV entry was identified at time of analysis.
Use-after-free in the V8 JavaScript engine of Google Chrome desktop builds prior to 153.0.8010.47 allows unauthenticated remote attackers to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page. Because the CVSS vector is PR:N/UI:R, no credentials or special browser configuration are required, but the victim must actively navigate to attacker-controlled content; the memory-corruption primitive is confined to the renderer process, so full host compromise would require a second, independent sandbox-escape vulnerability. No public exploit code has been identified at time of analysis, and the vendor has released a fixed build, making this a high-priority patch item rather than a confirmed active-exploitation emergency.
Sandbox escape in Google Chrome prior to 153.0.8010.47 allows a remote attacker who has already compromised the browser's renderer process to execute arbitrary code outside the sandbox via a race condition (TOCTOU) triggered by a crafted HTML page; the user must visit that page for the flaw to be reachable. Google rates the issue Chromium security severity High and a vendor patch is available from the 153.0.8010.47 stable channel release. There is no public exploit code and no CISA KEV listing at time of analysis, and the high attack complexity combined with a required renderer-compromise precondition keeps realistic risk below the raw 8.3 CVSS score.
Type confusion in Chrome's CacheStorage implementation in builds prior to 153.0.8010.47 lets a remote, unauthenticated attacker execute arbitrary code inside the browser's renderer sandbox when a victim loads a crafted HTML page. The bug is rated High by Chromium and 8.8 by NVD (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), but it is a renderer-level compromise rather than a sandbox escape, so host impact requires chaining a second vulnerability. No CISA KEV listing and no public exploit code were identified at time of analysis, and no EPSS score was supplied in the input data.
Improper input validation in ANGLE, Google Chrome's graphics abstraction layer, allows a remote attacker to potentially execute arbitrary code outside the browser sandbox by convincing a user to open a crafted HTML page in Chrome builds prior to 153.0.8010.47. Exploitation requires no authentication (PR:N) but does require user interaction (UI:R) - the victim must navigate to attacker-controlled or compromised content - and the scope-change metric (S:C) reflects that successful exploitation implies code execution escaping the renderer sandbox onto the host OS. The issue carries a Critical 9.6 CVSS rating and a vendor patch is available in Chrome 153.0.8010.47; there is no public exploit identified at time of analysis, and Chromium rates the underlying security severity as Medium.
Remote code execution inside the renderer sandbox can be triggered in unpatched Google Chrome builds by a use-after-free in the browser's built-in PDF rendering component. Exploitation is unauthenticated (CVSS PR:N) but requires the victim to open a crafted HTML page that embeds malicious PDF content (UI:R), and any resulting code execution is confined to Chrome's renderer sandbox - meaning this bug alone does not compromise the host and would typically need to be chained with a separate sandbox-escape flaw for full system compromise. A vendor patch is available in Chrome 153.0.8010.47; no public exploit code has been identified at time of analysis and there is no CISA KEV listing, though the 8.8 CVSS score and the ubiquity of Chrome make timely patching a priority.
Use-after-free in Chrome's DOM implementation allows a remote attacker to execute arbitrary code inside the renderer sandbox when a victim opens a crafted HTML page in Chrome versions prior to 153.0.8010.47. The flaw carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and is rated High by Chromium security severity; a vendor patch is available and no public exploit code or CISA KEV entry was identified at time of analysis.
Google Chrome versions earlier than 153.0.8010.47 contain an incorrect authorization flaw (CWE-863) in the WebUI subsystem that lets an attacker who already controls a compromised renderer process break out of the browser sandbox and run arbitrary code on the host via a crafted HTML page. Exploitation is a two-stage proposition: the attacker must first obtain renderer code execution, then chain this flaw to escape the sandbox, and the victim must load the malicious page. Google rates the Chromium security severity as High and has shipped a fix in Chrome 153.0.8010.47; no public exploit code or CISA KEV entry was identified in the available intelligence at time of analysis.
Incorrect authorization in Chrome's Core component on Windows (versions prior to 153.0.8010.47) lets a local attacker who can run a program on the machine break out of the browser sandbox and execute arbitrary code at the user's privilege level outside it. The flaw is rated High by the Chromium security team and carries CVSS 7.4 (AV:L/AC:H/PR:N/UI:N, C/I/A all High), reflecting a local-only but complete confidentiality, integrity and availability impact once the sandbox boundary is crossed. No public exploit code or CISA KEV listing was provided in the input, and Google has released a fixed stable-channel build, so this is best treated as a high-value chaining primitive rather than a currently mass-exploited issue.
Improper state validation in the Skia graphics library, as shipped in Google Chrome prior to 153.0.8010.47, lets an attacker who already controls a compromised renderer process read memory outside the browser sandbox by serving a crafted HTML page. Exploitation requires the victim to load the malicious page (UI:R) and depends on chaining with a separate renderer compromise, which is why the vector carries AC:H despite the network attack path. Vendor status is "Patch available"; no public exploit code and no CISA KEV listing were present in the supplied intelligence, so the flaw should be treated as a sandbox-escape primitive rather than an observed, widely exploited issue.
Missing authorization in Chrome's AppManifest handling (CWE-862) lets an attacker who has already compromised the renderer process bypass web origin policy and load a crafted HTML page inside a trusted origin context, yielding high confidentiality and integrity impact. Exploitation is not a default-config remote attack: it requires two stacked preconditions - a pre-compromised renderer (typically via a separate prior bug) plus social engineering to induce victim interaction with the malicious page. Per the CVSS vector (AV:N/AC:L/PR:N/UI:R) the attacker is remote and unauthenticated, but user interaction is mandatory; our independent assessment raises attack complexity to High (AC:H) because the renderer must first be subverted, and Google's own rating is 'Chromium security severity: Medium'. EPSS is low at 0.25% (16th percentile) and no public exploit has been identified at time of analysis; the fix ships in Chrome 153.0.8010.47, so patched and auto-updated browsers are not affected.
Remote code execution inside the renderer sandbox affects Google Chrome desktop builds prior to 153.0.8010.47, caused by a type confusion flaw in the browser's compositing pipeline (CWE-843) that is reachable from a crafted HTML page. An attacker needs only to convince a user to load the page: the CVSS 3.1 vector is 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), so no credentials or privileges are required, but user interaction is mandatory. Google rates the issue Chromium security severity High and has shipped a fixed stable-channel build; no public exploit code or CISA KEV listing appears in the supplied intelligence, and no EPSS score was provided, so the current exploitation picture is best described as patch-now-but-not-known-exploited.
Use-after-free in Google Chrome's DigitalCredentials component lets a remote, unauthenticated attacker execute arbitrary code outside the browser sandbox when a victim is socially engineered into loading a crafted HTML page, affecting all Chrome builds prior to 153.0.8010.47. Exploitation requires no credentials or elevated privileges (CVSS PR:N) but does require the user to navigate to the attacker-controlled page (UI:R), and the resulting scope change (S:C) means impact extends beyond the browser's sandbox boundary to full confidentiality, integrity, and availability loss. Google rates the issue High and has shipped a fix in the stable channel; no public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV, so the current risk is driven by the ease of phishing/malvertising delivery rather than confirmed active exploitation.
Integer overflow in V8, Chrome's JavaScript engine, allows a remote attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page in Chrome builds prior to 153.0.8010.47; the bug carries a high CVSS (9.6 as published, scored 8.8 under our scope-unchanged reassessment) because memory corruption in V8 can be leveraged for code execution, though impact is confined to the renderer process and full host compromise would require chaining a separate sandbox-escape flaw. Chrome ships on a rapid auto-update cadence and a vendor patch is available (153.0.8010.47), which limits mass exposure; EPSS is a modest 0.36% (30th percentile), CISA SSVC records no observed exploitation, and no public exploit code has been identified at time of analysis, so this is a high-severity memory-safety defect to prioritize for unpatched or update-delayed enterprise fleets rather than an active-emergency. No authentication is required (PR:N), but exploitation depends on user interaction: the victim must load attacker-controlled JavaScript with scripting enabled in the default configuration.
Let me synthesize. CVE-2026-91727: Incorrect reference resolution in Extensions in Chrome on Mac prior to 153.0.8010.47. Local attacker who compromised renderer process could execute arbitrary code outside sandbox via a local program. CWE-706 (Use of Incorrectly-Resolved Name or Reference). CVSS 8.1 AV:L/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H. Product: Google Chrome (macOS). Product name 1-3 words: "Google Chrome". Prevalence: ubiquitous. Now fields. Summary: must not copy description; start with impact verb and product. E.g. "Sandbox escape in Google Chrome on macOS (prior to 153.0.8010.47) lets an attacker who has already compromised the renderer process escalate to code execution outside the browser sandbox..." Technical context: CWE-706 incorrect reference resolution in Extensions — extension API resolves a reference (name/path/identifier) incorrectly, allowing a local program to be loaded/executed outside sandbox. macOS-specific. Renderer compromise prerequisite. Risk assessment: CVSS 8.1 with AV:L AC:H PR:N UI:N S:C. EPSS not provided, KEV not provided. Patch available. No POC known. Attack requires renderer compromise (two-stage). S:C indicates sandbox escape crossing security scope. Not KEV → no public exploit identified at time of analysis. Note missing EPSS/KEV data explicitly. Affected products: Google Chrome on macOS versions prior to 153.0.8010.47; EUVD lists "Chrome 153.0.8010.47 <153.0.8010.47" which is malformed/likely means before 153.0.8010.47. Reference: chromereleases blog, chromium issue 516893912. Remediation: upgrade to 153.0.8010.47 or later. Chrome auto-update. macOS-specific. Compensating controls: restrict extension installs via enterprise policy, disable extensions, etc. Trade-offs. Exploit scenario: attacker chains a renderer RCE (e.g. via malicious web content) then exploits the extension reference resolution flaw to break out of sandbox and run native code on macOS host. Exploitation conditions: requires (1) macOS platform, (2) att
Google Chrome builds prior to 153.0.8010.47 carry a use-after-free in the browser's Input component that allows an attacker who already controls a compromised renderer process to escape the Chrome sandbox and run arbitrary code with the browser's privileges. Exploitation is not remote-standalone: it requires a chained renderer compromise plus a victim who opens a crafted HTML page, which is why the flaw is scored High (8.3) rather than Critical despite total technical impact. Google has shipped a fixed stable-channel build; no public exploit code has been identified and the issue is not listed in CISA KEV at time of analysis.
Use-after-free in Google Chrome's Input handling allows a remote attacker to achieve code execution in affected desktop builds prior to 153.0.8010.47. Exploitation is unauthenticated (PR:N) but requires the victim to render attacker-controlled HTML (UI:R), making drive-by or malicious-page delivery the primary vector; default configurations are affected with no non-default prerequisites. The vulnerability is rated CVSS 8.8 (C:H/I:H/A:H) and a vendor patch is available in the Stable channel build 153.0.8010.47; no public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing).
A use-after-free in Google Chrome's Internals component allows a remote attacker to potentially execute arbitrary code outside the browser sandbox when a victim opens a crafted HTML page, affecting all Chrome builds prior to 153.0.8010.47 on desktop. Exploitation requires user interaction (visiting the page) but no authentication or elevated privileges, and Google rates the Chromium security severity as Critical. Vendor-released patch: 153.0.8010.47. There is no public exploit code identified at time of analysis and no confirmed actively exploited (CISA KEV) status, though the SSVC framework assigns total technical impact.
Code injection in XML handling in Google Chrome versions prior to 153.0.8010.47 could let a remote attacker bypass the web origin policy by luring a victim into opening a crafted HTML page (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:N per independent assessment, versus Google's published 8.1 vector). Exploitation requires user interaction - the victim must load the malicious page - and no authentication is needed, while Google's own Chromium severity rating is 'Low', indicating constrained real-world impact; the EPSS score is 0.26% (17th percentile) and no public exploit has been identified at time of analysis. A vendor patch is available in Chrome 153.0.8010.47, and Chrome's automatic background update mechanism rapidly retires vulnerable versions.
Use-after-free in Google Chrome's Core component lets a remote attacker execute arbitrary code outside the browser sandbox by getting a victim to load a crafted HTML page in any build prior to 153.0.8010.47. The flaw is unauthenticated (PR:N) but requires user interaction (UI:R), and because the resulting code execution occurs outside the sandbox, Chrome's normal renderer isolation does not contain the compromise; the assessed severity is 9.6 with scope changed (S:C). No public exploit code has been identified at time of analysis, and a vendor-released patch is available in Chrome 153.0.8010.47.
Use-after-free in Google Chrome's Auth component allows a remote attacker to achieve code execution outside the browser sandbox when a victim simply loads a crafted HTML page in any desktop Chrome build prior to 153.0.8010.47. Exploitation is unauthenticated and requires no special configuration - the only prerequisite is the user interaction of visiting or rendering the attacker-controlled page (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6), and because the flaw is not confined to the renderer, no separate sandbox-escape bug is needed to reach the host. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; Google has released a fixed build (153.0.8010.47), and details remain restricted in the Chromium tracker until most users have updated.
Type confusion in Chrome's ServiceWorker implementation allows a remote attacker to achieve arbitrary code execution inside the renderer sandbox by enticing a victim to load a crafted HTML page in any Chrome build prior to 153.0.8010.47. Exploitation is unauthenticated (PR:N) but requires user interaction (UI:R) - the victim must visit or be redirected to attacker-controlled content - and the resulting code execution is confined to the sandbox (S:U), so full host compromise would require chaining a separate sandbox-escape flaw. There is no public exploit identified at time of analysis, and a vendor-released patch (153.0.8010.47) is available, making this a high-priority but practically bounded patching task rather than an urgent zero-day response.
Google Chrome on macOS versions prior to 153.0.8010.47 contain a race condition (TOCTOU) in the Extensions subsystem that lets an attacker who has already compromised the browser's renderer process break out of the sandbox and execute arbitrary code on the host, triggered when a victim loads a crafted HTML page. Google rated the issue High severity and Chromium's own severity assessment drove the 8.3 CVSS base score with a Scope change (S:C), reflecting that code execution crosses the renderer/sandbox boundary rather than staying contained. No public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV, but a vendor patch is available and should be applied promptly because sandbox escapes are the high-value second stage of any Chrome exploit chain.
An out-of-bounds write in Google Chrome's ServiceWorker implementation allows remote code execution inside the browser's renderer sandbox when a victim loads a crafted HTML page; exploitation requires the user to visit or be redirected to attacker-controlled content and to have a service worker exercised (UI:R, PR:N), so no credentials or pre-existing privileges are needed. Successful exploitation yields high confidentiality, integrity and availability impact within the sandboxed renderer process (CVSS 3.1 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), and host compromise would additionally require a separate sandbox-escape. Only Chrome builds prior to 153.0.8010.47 are affected, a vendor patch is available, and no public exploit code has been identified at time of analysis; because Chrome auto-updates in the background, most installations will remediate themselves quickly, though managed and long-lived sessions should be verified.
Use-after-free in Google Chrome's WebAppInstalls component allows a remote, unauthenticated attacker to execute arbitrary code outside the browser sandbox when a victim loads a crafted HTML page on any build prior to 153.0.8010.47. Exploitation requires user interaction (CVSS 3.1 vector AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, score 9.6), and the scope-changed rating reflects that a successful attack escapes the renderer sandbox and reaches the host rather than staying contained in the browser process. At time of analysis there is no indication of active exploitation and no public exploit code identified; the vendor has shipped a fixed build (153.0.8010.47) and the primary exposure is unpatched consumer and enterprise Chrome installations.
Type confusion in Google Chrome's ServiceWorker implementation before version 153.0.8010.47 allows a remote attacker to achieve arbitrary code execution inside the renderer sandbox by getting a user to open a crafted HTML page. The flaw carries a CVSS base score of 8.8 (AV:N/AC:L/PR:N/UI:R), the classic memory-corruption profile for Chrome renderer bugs, and Google rated it High in its Chromium severity scheme. A vendor patch shipped in the 153.0.8010.47 stable release, and there is no public exploit code identified and no CISA KEV entry at time of analysis, so this is a prioritise-and-patch issue rather than a confirmed active campaign.
An out-of-bounds read in Mozilla Thunderbird's IMAP response parser affects all builds prior to Thunderbird 156 and prior to Thunderbird 140.16 (ESR), allowing a malicious or compromised IMAP server to crash the mail client and potentially expose a limited amount of process memory by sending a crafted untagged '* ID' response. The flaw is reachable before authentication (CVSS vector PR:N/UI:N), so an attacker needs no mailbox credentials and no user click beyond the client connecting to a server they control, have compromised, or can intercept via man-in-the-middle; independent assessment sets confidentiality impact to Low and availability impact to High, which is milder than the 9.1 NVD base score. Exploitation requires the victim's Thunderbird to actually initiate an IMAP session to the attacker-controlled endpoint, and with EPSS at only 0.21% (12th percentile) and no CISA KEV entry or public exploit code identified, the severity signals conflict: a critical-looking base score against low real-world exploitation likelihood, mitigated by the availability of fixed builds in Thunderbird 156 and 140.16.
An out-of-bounds read in Mozilla Thunderbird's IMAP response parsing can disclose process memory or crash the client when the mail client connects to an attacker-controlled or compromised IMAP server, or when an on-path attacker injects crafted IMAP lines into a session. The flaw affects Thunderbird versions before 156 and Thunderbird ESR versions before 140.16, and is fixed in those releases; exploitation requires the victim's client to establish an IMAP session with the malicious endpoint (CVSS UI:R) while requiring no attacker authentication (PR:N). EPSS is 0.18% (8th percentile), and no public exploit code or confirmed active exploitation (CISA KEV) has been identified at time of analysis.
Malformed email headers in Mozilla Thunderbird before 156 and 140.16 ESR can cause header parsing confusion or potential memory safety violations when a victim opens a crafted message, though code execution is only described as a potential outcome by the vendor. No public exploit code or active exploitation has been identified, and the EPSS score is low at 0.18% (percentile 8). The vulnerability requires user interaction (UI:R) because the victim must receive and render the malicious email, and the raw CVSS of 9.8 overstates real-world urgency for a desktop mail client.
Credential leakage in Tornado's CurlAsyncHTTPClient (all releases through 6.5.6) lets sensitive per-request state — client TLS certificates (SSLCERT/SSLKEY) and proxy basic-auth credentials (PROXYUSERPWD) — persist on pooled pycurl handles and be presented to a different, unintended host on a later request. The flaw affects applications that pass per-request credentials to the curl-backed client and reuse the same client instance across hosts; it is not reachable by an anonymous internet attacker against a default server deployment, and the vendor rates attack complexity as high with attack requirements present. No public exploit code has been identified at time of analysis and no active exploitation is reported; the vendor has fixed the issue in Tornado 6.5.7.
Memory amplification denial of service in the Tornado Python web framework before 6.5.8 lets unauthenticated remote attackers exhaust server memory with a single crafted multipart/form-data request containing tens of thousands of parts — roughly 600KB of body is enough to build a 100,000-element transient list. Tornado's parse_multipart_form_data splits the body on the boundary before it enforces the max_parts limit, so the safety check fires only after the expensive allocation has already happened. Publicly available exploit code exists (a gist with poc.py), patch status is 'available from vendor' with the fix shipped in 6.5.8, and no CISA KEV listing or EPSS score accompanied the supplied intelligence.
Heap memory corruption in FreeRDP's server-side static virtual channel handling (all versions before 3.31.0) allows an authenticated RDP client to send channel messages larger than the expected chunk size, triggering an integer underflow that corrupts heap memory and can overwrite live pointers, potentially yielding code execution on the RDP server. Reachability is gated on the server enabling CHANNEL_OPTION_SHOW_PROTOCOL for the channel, and on the attacker already holding a valid session, so this is a post-authentication, configuration-dependent flaw rather than a pre-auth RCE. A vendor fix is available in 3.31.0 via upstream commit 40d9202, and no public exploit code or confirmed active exploitation was identified at time of analysis.
Widget: Win32 mitigation bypass in Mozilla Firefox on Windows allows attacker-controlled web content to defeat a platform security protection (CWE-693); the flaw is fixed in Firefox 156 and Firefox ESR 153.3. Mozilla rates it 9.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), implying unauthenticated remote compromise with no user interaction, but the independent assessment scores it AV:N/AC:H/PR:N/UI:R - a Windows-only precondition, a victim who actually renders the malicious page, and typically a second chained vulnerability are required before the bypass converts into high confidentiality/integrity impact. EPSS is 0.15% (5th percentile), and there is no CISA KEV entry or public exploit code identified at the time of analysis, so real-world exploitation pressure is currently low.
Memory corruption in Mozilla Firefox's Networking component can be triggered when the browser processes crafted or malformed network data, giving an attacker who controls the data path a possible route to code execution inside the content process. All Firefox builds before 156 and Firefox ESR builds before 153.3 are affected; Mozilla shipped fixes in Firefox 156 and Firefox ESR 153.3. Reaching the bug requires the victim to actively browse to an attacker-controlled site or route traffic through a malicious or MITM'd endpoint, and exploitation further depends on winning a heap-layout/memory-corruption primitive, with any resulting execution initially confined to the sandboxed content process; no public exploit code is identified at time of analysis and EPSS is low at 0.15% (5th percentile). Note that the two CVSS vectors in circulation disagree - the NVD-supplied vector (8.8, AV:L/AC:L/PR:L) implies prior local low-privilege access, whereas the independent reassessment (AV:N/AC:H/PR:N/UI:R) describes the more plausible remote-web-content path, and that discrepancy should be resolved with Mozilla before finalising exposure decisions.
A mitigation bypass in the Mozilla Firefox Networking component lets remote attackers defeat a built-in browser security protection, yielding high confidentiality and integrity impact (CVSS 9.1, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N as scored by Mozilla) against unpatched clients. Affected are Firefox versions prior to 156 and Firefox ESR prior to 153.3; our internal assessment keeps the same C:H/I:H/A:N impact but treats the recorded UI:N as optimistic and applies UI:R, since a client-side browser flaw in practice requires the victim to load attacker-influenced web content before the bypass can be exercised. No public exploit code has been identified at time of analysis and the EPSS score is low (0.16%, 5th percentile); vendor-released patches exist in Firefox 156 and Firefox ESR 153.3.
A mitigation bypass in the Firefox Popup Blocker allows attacker-controlled web content to defeat the browser's built-in popup-blocking protection, so unwanted windows can be spawned despite the user's configured blocking preference. All Firefox builds prior to 156 and Firefox ESR builds prior to 153.3 are affected, per the CPE entry cpe:2.3:a:mozilla:firefox:*:*:*:*:*:*:*:* and Mozilla advisories mfsa2026-90, mfsa2026-93, mfsa2026-94 and mfsa2026-96. Exploitation requires a victim to load the crafted content in an unpatched browser, and the practical outcome is a weakened anti-deception control enabling phishing and UI spoofing rather than code execution or direct data compromise; EPSS is a low 0.16% (5th percentile), and no public exploit has been identified at time of analysis. Note that the supplied CVSS 8.8 rating is not supported by the independent re-assessment, which scores the issue as AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N because impact is limited to integrity of the browser's protective behavior.
Memory-safety corruption in Mozilla Firefox's Safe Browsing component can be triggered when a victim loads attacker-controlled web content on any Firefox build before 156 or Firefox ESR before 153.3. The assessed vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, score 8.0) shows the vulnerability is network-reachable with low complexity, but exploitation is gated by mandatory user interaction - the victim must visit or load content that the Safe Browsing component processes. No public exploit code has been identified at time of analysis and EPSS is low (0.14%, 4th percentile), but a browser memory-corruption bug with high C/I/A impact warrants prompt patching; Mozilla fixed it in Firefox 156 and Firefox ESR 153.3.
Sandbox escape in Mozilla Firefox on Windows allows attacker-supplied web content to break out of the content-process sandbox through the browser's 'Widget: Win32' native window-handling code, stemming from incorrect boundary conditions that produce an out-of-bounds memory condition. It affects Firefox versions before 156 and Firefox ESR versions before 153.3 running on Windows, and although the vendor rates it 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H), our independent reassessment applies AC:H because a successful escape also requires chaining this flaw with a separate content-process memory-corruption bug to first achieve code execution inside the renderer - the escape alone grants no execution. Exploitation is unauthenticated at the network vector but requires the victim to load attacker-controlled content (UI:R), no public exploit code has been identified at time of analysis, and the EPSS score is low at 0.14% (4th percentile).
A sandbox escape in Firefox's Profile Backup component lets code that is already running inside the browser's sandboxed content process break out to browser and host privilege, but it is not a standalone remote compromise: the authoritative assessment rates it CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:C/C:H/I:H/A:H, meaning an attacker must first hold an in-sandbox foothold (typically a separate content-process exploit) and typically requires user interaction. Mozilla's vendor advisory scores it 9.8 with a PR:N/UI:N/S:U vector, and the flaw is fixed in Firefox 156. EPSS is low at 0.14% (4th percentile) and no public exploit identified at time of analysis; there is no CISA KEV entry, so this reads as a second-stage chain link rather than a standalone exploit.
Sandbox escape in Mozilla Firefox on Windows stems from an incorrect boundary condition (CWE-119) in the Win32 Widget component, allowing an attacker who already has code execution inside a content/child sandbox to escape and gain high-impact code execution, data access, and availability impact. It affects Firefox before 156 and Firefox ESR before 153.3, with patched builds available as Firefox 156 and Firefox ESR 153.3. No public exploit or active exploitation is identified, and EPSS is low at 0.14% (4th percentile), but the CVSS score is 8.8 and exploitation is chain-dependent, typically requiring a separate content-process memory-safety bug to reach this escape stage.
Sandbox escape in Mozilla Firefox on Windows, in the Widget: Win32 component, lets an attacker who already holds low-privileged code execution inside a Firefox content/child process corrupt memory via an incorrect boundary condition (CWE-119) and break out of the browser sandbox into full user-level code execution. The flaw is Windows-only - the Win32 widget code path does not exist on macOS or Linux - and patched builds (Firefox 156 and Firefox ESR 153.3) are not exploitable; there is no public exploit identified at time of analysis and EPSS is low at 0.14% (4th percentile). Because this is a second-stage sandbox-escape primitive rather than a standalone remote bug, it is not independently exploitable against a default install without a preceding content-process compromise.
Memory corruption in Mozilla Firefox's Process Sandboxing component, caused by incorrect boundary conditions, can be triggered when a victim browses attacker-controlled web content on any Firefox version prior to 156. Although the input feed carries a nominal CVSS of 9.8 and a CWE-119 (buffer bounds) classification, our assessment reduces the practical severity to AV:N/AC:H/PR:N/UI:R because successful exploitation requires the user to render malicious content and then reach and corrupt the targeted sandbox code path, which realistically implies chaining with a content-process compromise. No public exploit code has been identified and the flaw is not in CISA KEV, with an EPSS score of just 0.14% (4th percentile), indicating low near-term exploitation likelihood despite the high theoretical impact. The issue is unauthenticated from a network standpoint (PR:N) but is not zero-interaction.
Improper boundary conditions in the DOM Editor component of Mozilla Firefox can corrupt memory when a user renders crafted web content, allowing an attacker to potentially execute code inside the browser's content process. All Firefox builds before 156 and Firefox ESR builds before 153.3 are affected; the CVSS vector sets PR:N, so unauthenticated remote delivery is possible, but the assessed exploitation path requires the victim to load attacker-controlled page content (UI:R) and reliable exploitation of a memory-corruption bug typically needs heap grooming and a sandbox escape to affect the host. No public exploit code has been identified at time of analysis and EPSS is low at 0.14% (4th percentile), so despite the 9.3 base score the practical real-world priority is moderate, driven mainly by the browser's ubiquity and the fact that the fix is already shipped.
Enterprise policy enforcement bypass in Mozilla Firefox affects all builds prior to 156 and Firefox ESR prior to 153.3, letting remote, unauthenticated attackers circumvent restrictions that administrators have locked down through the browser's Enterprise Policies component. Mozilla's advisory carries a CVSS 9.1 base score, while an independent re-assessment lowers the practical severity by raising attack complexity (AC:H) and scoping real-world impact to managed deployments where a policy is actually relied upon as a security control - a default consumer install with no policies configured has nothing to bypass. No public exploit code has been identified at time of analysis, there is no confirmed active exploitation (CISA KEV), and EPSS is only 0.15% (5th percentile); Mozilla has not disclosed the specific trigger mechanism, so precise preconditions remain unclear.
Content spoofing caused by an invalid-pointer (null-pointer dereference) condition in Mozilla Firefox's Graphics rendering component affects Firefox versions prior to 156, allowing a remote, unauthenticated attacker to falsify or distort what a victim sees when the browser renders attacker-supplied web or graphics content. Mozilla shipped the fix in Firefox 156 (advisories MFSA2026-90 and MFSA2026-94, Bugzilla 2061393); there is no public exploit identified at time of analysis and no CISA KEV listing, and EPSS is low at roughly 0.14% (4th percentile). The raw CVSS 9.1 score overstates practical risk - our independent assessment lowers it to AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:L because exploitation requires the victim to navigate to and render malicious content, and the realistic outcome is spoofing plus a limited crash/denial-of-service condition rather than full integrity or availability loss.
A race condition in Mozilla Firefox's XPConnect component allows an attacker who has already compromised execution inside the content/renderer sandbox to escape that boundary and reach higher-privileged browser code. Only Firefox builds prior to version 156 are affected; the flaw was fixed upstream and published in Mozilla's MFSA 2026-90/MFSA 2026-94 advisories. Exploitation is not a standalone remote code-execution path but a chained, timing-dependent step requiring a separate renderer compromise first, and no public exploit has been identified at time of analysis, with an EPSS score of just 0.14% (4th percentile) indicating low predicted real-world activity.
Sandbox escape in Mozilla Firefox's Widget:Win32 component on Windows allows code that is already running inside the browser's content/renderer sandbox to break out and execute on the host with the user's privileges, escalating a limited renderer compromise into full desktop compromise. It does not stand alone: an attacker must first obtain code execution in the content process via a separate bug, then trigger the boundary-condition memory corruption, and a victim must load attacker-controlled web content (CVSS 9.0, PR:L, UI:R, S:C). Vendor fixes are Firefox 156 and Firefox ESR 153.3; EPSS is only 0.15% (5th percentile) and no public exploit code or confirmed active exploitation has been identified, so the high base score should be weighed against the multi-stage, Windows-only prerequisites.
Sandbox escape in Mozilla Firefox (all versions before 156) and Firefox ESR (before 153.3) allows an attacker who gets malicious web content processed by the browser's WebRTC stack to break out of the sandboxed content process and run code with the privileges of the parent/broker process, yielding high confidentiality, integrity and availability impact. Exploitation is not trivial: the victim must load attacker-controlled content and, because the assessed vector is CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H, the bug realistically functions as a chain component on top of a renderer-level compromise rather than a single-shot webpage exploit. There is no public exploit identified at time of analysis, CISA KEV does not list it, and EPSS is only 0.15% (5th percentile), so the practical near-term risk sits below the 9.6 base score headline; Mozilla shipped fixes in Firefox 156 and Firefox ESR 153.3.
Information disclosure in Mozilla Firefox's Networking: HTTP component affects Firefox builds prior to 156 and Firefox ESR builds prior to 153.3, allowing a remote, unauthenticated attacker who can influence HTTP traffic a victim's browser processes to expose high-confidentiality data (CVSS 3.1 base 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N). Impact is confidentiality-only - no integrity or availability loss is assessed - and the flaw is consistent with CWE-200 (Exposure of Sensitive Information). At time of analysis there is no public exploit identified and no CISA KEV listing; EPSS is 0.15% (5th percentile), indicating low modeled near-term exploitation likelihood, though the unauthenticated, low-complexity profile keeps it relevant for unpatched consumer and enterprise Firefox fleets.
Mozilla Firefox builds before 156 (and Firefox ESR builds before 153.3) can be induced to bypass an existing browser security mitigation through attacker-influenced web content that exercises the DOM: Networking component, yielding high confidentiality and integrity impact without granting outright code execution. The vendor rates this 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), but our independent assessment adjusts the vector to UI:R, since the victim must actually load the malicious page for the bypass to trigger - a normal precondition for a client-side browser flaw. There is no public exploit identified at time of analysis and EPSS is low (0.16%, 6th percentile), so near-term real-world risk is limited despite the critical score.
A mitigation bypass in Firefox's Remote Settings Client - the signed channel the browser uses to receive configuration, blocklist and policy updates - was fixed in Firefox 156 and Firefox ESR 153.3. The vendor's CVSS 3.1 vector (9.1, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N) rates it as an unauthenticated, network-reachable high-integrity/high-confidentiality issue, but that flat 9.1 should be read with caution: our independent assessment re-scores it at CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N, because a bypass of the Remote Settings mitigation realistically depends on the attacker being able to tamper with settings content or its delivery channel (a man-in-the-middle position or a spoofed/compromised settings source) rather than a zero-context hit against an idle browser. No public exploit code or confirmed active exploitation was identified at time of analysis, and EPSS is low at 0.16% (6th percentile), which is consistent with a terse, undisclosed-disparate advisory rather than a mass-exploited bug. All users on Firefox before 156 or Firefox ESR before 153.3 are affected.
Incorrect boundary conditions in the Firefox DOM Animation component (CWE-119) allow remote attackers to corrupt memory in the browser process of any default Firefox build prior to version 156, with Mozilla scoring the flaw CVSS 9.8 (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H) - the profile of a potential remote code execution issue. Exploitation requires the victim to load attacker-controlled web content (or attacker-supplied markup such as malvertising) that exercises the affected animation code path, so practical delivery is gated by victim interaction even though the vendor vector lists UI:N; our independent assessment therefore scores it UI:R while keeping confidentiality, integrity, and availability impact High. There is no KEV listing and no public exploit code identified at time of analysis, and EPSS is only 0.15% (5th percentile), indicating low observed exploitation likelihood measured against the high theoretical severity. No authentication or special target configuration is needed - any unpatched Firefox install is exposed.
Memory corruption in Mozilla Firefox's HTTP networking component (CWE-119) allows an attacker who controls the content of an HTTP response - for example via a malicious or compromised web server, or by man-in-the-middle position - to corrupt Firefox's memory and potentially achieve code execution in the browser process on a victim running Firefox before 156. The issue is a client-side networking-stack flaw rather than a remotely reachable server service: exploitation requires the user to initiate and complete the malicious HTTP exchange, which is why the independent assessment scores it CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H while the vendor/NVD vector lists UI:N at 9.8. No public exploit code or active exploitation has been identified at time of analysis (EPSS 0.15%, 5th percentile), and the flaw is closed by the regular Firefox 156 update, which sharply limits the exposure window.
Mozilla Firefox versions prior to 156 (and Firefox ESR prior to 153.3) contain a buffer-boundary flaw in the Graphics component that can be leveraged to escape the browser's content-process sandbox and reach the host, explaining the vendor's critical 9.6 score (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H) - the scope change reflects a crossing from the constrained renderer process into the host, with full confidentiality, integrity and availability impact. Exploitation is not standalone: it requires a victim to load attacker-controlled web content (UI:R is mandatory) and, in practice, must be chained after an attacker has already achieved code execution inside the Firefox content process, which is why the independent assessment raises attack complexity to AC:H while leaving the 9.6-level impact intact. There is no KEV listing and no public exploit identified at time of analysis, and EPSS is low at 0.15% (5th percentile), but the vendor-released fixes - Firefox 156 and Firefox ESR 153.3 - should be applied promptly given the sandbox-escape nature of the flaw.
Improper origin validation in Mozilla Firefox's Graphics component before version 156 can allow attacker-influenced web content, once rendered by a victim, to break site-isolation boundaries and potentially disclose or corrupt data across origins. Affected users are those running Firefox versions prior to 156; exploitation requires the victim to browse to malicious or compromised web content, so it is not a no-interaction mass network exploit despite the vendor's critical 9.1 score, and the independent assessment rates it lower with high attack complexity and required user interaction. No public exploit code or active exploitation has been identified, and EPSS is 0.15% (5th percentile), indicating low predicted exploitation activity at time of analysis.
Sandbox escape in Mozilla Firefox's Graphics component, rooted in an invalid-pointer memory-safety flaw (CWE-119), allows attacker-controlled content loaded by a victim to cross the browser's process-sandbox boundary and reach the privileges of the parent/broker process. Default configurations of Firefox before 156 and Firefox ESR before 140.16 / 153.3 are affected; the vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6) indicates no authentication or privileges are required, but the victim must load attacker-controlled content (UI:R). No public exploit code has been identified at time of analysis and EPSS is low (0.16%, 5th percentile); the real-world bar is further raised because a sandbox escape of this class generally has to be chained with a separate content-process memory-corruption primitive to be exploited end-to-end.
A mitigation bypass in Mozilla Firefox's Remote Settings Client component allows a remote, unauthenticated attacker to defeat a browser security control when a victim interacts with attacker-influenced content, potentially leading to high confidentiality and integrity impact. All Firefox builds prior to 156 and ESR branches prior to 115.41, 140.16, and 153.3 are affected; the issue was fixed in those releases per Mozilla advisories mfsa2026-90 through mfsa2026-96. Exploitation requires user interaction (UI:R) and the vulnerability is characterized as a mitigation bypass that generally must be chained with another primitive to produce direct impact; no public exploit code or confirmed active exploitation has been identified at time of analysis, and the EPSS score is low at 0.16% (6th percentile), so this should be treated as a moderate-priority patch item rather than an emergency.
Trust-boundary spoofing in the proxy-addr Node.js module (versions 1.1.0 through 2.0.7), the library that backs Express req.ip and req.ips, lets unauthenticated clients forge their apparent source address. When an operator declares a trusted-proxy subnet in IPv4-mapped IPv6 notation with an IPv4-sized prefix (e.g. ::ffff:10.0.0.0/8 rather than the correct /104), proxy-addr silently accepts it but trusts every IPv4 address on the internet, so the direct socket peer becomes trusted at hop 0 and any client can set an arbitrary X-Forwarded-For header. This is a fail-open regression introduced in 1.1.0, fixed in 2.0.8; no public exploit identified at time of analysis, and it is not in CISA KEV.
Stack-based buffer overflow in SIPp through 3.7.7 allows a malicious SIP server to crash the client process by sending a crafted 401 or 407 authentication challenge containing an oversized algorithm parameter. The flaw originates in createAuthHeader() at src/auth.cpp:183-192, where the original code uses strncpy bounded by end-start (an attacker-controlled length derived from the algorithm field) rather than the fixed size of the stack-allocated algo buffer. No public exploit has been identified at time of analysis, but upstream fix code is publicly available via GitHub PR #880.
A lockless read race in the Linux kernel's ftrace ring-buffer subsystem allows a local attacker to corrupt kernel memory by concurrently triggering a subbuf resize while a reader accesses stale size metadata. Affected versions span from the commit introducing dynamic subbuf resizing (~Linux 6.8) through current stable branches. The CVSS vector rates confidentiality, integrity, and availability all high, reflecting that a successful race can yield kernel memory corruption; no public exploit or CISA KEV listing exists, and EPSS sits at a low 0.16%.
IRQ resource leak and potential use-after-free in the Linux kernel's NXP PIT (Periodic Interrupt Timer) clocksource driver allows a kernel crash if an interrupt fires after error-path cleanup. The driver's pit_clockevent_init() error path skips free_irq() when cpuhp_setup_state() fails after request_irq() has already succeeded, then proceeds to kfree(pit), leaving the registered IRQ handler's dev_id pointing to freed slab memory. If the IRQ subsequently fires, the handler dereferences the freed pointer, constituting a use-after-free. No public exploit exists and EPSS is 0.15% (5th percentile), consistent with a race-condition bug on niche embedded hardware.
Overlayfs in the Linux kernel exposes an unprivileged local DoS - and a theoretical privilege-escalation path - through a double `end_creating()` call in `ovl_create_real()` when a casefold consistency mismatch is detected during directory creation. The double call unlocks the parent directory's `i_rwsem` twice and calls `dput()` twice on the same dentry: the spurious unlock wedges every subsequent creation under that parent indefinitely, and the spurious `dput()` creates a reference-count imbalance that could underpin a use-after-free chain. The flaw is reachable without root in a user namespace on most modern Linux distributions. No public exploit has been identified at time of analysis and EPSS is 0.18%.
AppArmor's begin_current_label_crit_section() in the Linux kernel contains a use-after-free of struct cred that can be triggered on systems with active AppArmor profiles when those profiles are updated or disabled mid-syscall. The flaw arises from synchronous credential replacement inside LSM hooks: the override_creds() guard in aa_replace_current_label() fails to detect when overridden and objective credentials are the same object, causing two reference drops that free the struct cred while task_struct still holds a pointer to it. No public exploit or CISA KEV listing exists; EPSS is 0.16% at the 5th percentile, consistent with low immediate exploitation probability despite a theoretically high UAF impact.
Out-of-bounds write in the Linux kernel AppArmor LSM label parser allows any local user on an AppArmor-loaded system to corrupt kernel heap or stack memory by writing a crafted multi-component label string to /proc/self/attr/apparmor/current or to the world-writable (mode 0666) securityfs .access file, the latter path applying no privilege check whatsoever. The bug is a deterministic off-by-one: aa_vec_unique() writes a NULL terminator at vec[n] when no duplicates are found, but vec_setup() and DEFINE_VEC() allocate only n slots, so the write lands one entry past the end of either the local stack array or the kzalloc'd buffer. No public exploit has been identified at time of analysis; vendor-released patches are available in stable branches 6.12.109, 6.18.50, 7.2.4, and 7.3-rc1.
Memory corruption in the Linux kernel's swap/hibernation subsystem can produce silent data corruption and crashes in unrelated userspace processes during hibernation image preparation. swap_free_hibernation_slot() unconditionally calls __swap_cluster_free_entries() without checking whether a folio already occupies the slot in the swap cache - a state reachable when cluster readahead speculatively faults in pages over the hibernation window. The freed slot is returned to the allocator while its folio retains the stale swap offset in folio->swap; when page reclaim subsequently flushes that folio using the stale offset, it silently overwrites a swap table entry now belonging to a different process, corrupting arbitrary in-flight userspace data. No public exploit has been identified at time of analysis.
The Linux kernel's Panthor DRM driver for ARM Mali CSF-based GPUs (Mali-G310/G510/G610/G710/G720 class hardware) fails to safely validate the build-info metadata block it parses out of the loaded firmware image: panthor_fw_read_build_info() adds the u32 header fields hdr.meta_start and hdr.meta_size without overflow protection, reads the "git_sha: " prefix without first confirming the metadata is long enough, and can underflow the trailing NULL terminator index when meta_size is zero. An attacker who can supply or influence the firmware blob can therefore make malformed metadata pass validation and drive out-of-bounds reads, yielding information disclosure and potential availability impact on the GPU/driver. Exploitation is local and privileged (CVSS PR:H, i.e. authenticated with high privileges) and requires a system with Panthor active and Mali CSF hardware; default vendor-signed firmware is unaffected, and the independent assessment rates the realistic severity far below the vendor's 7.1 as CVSS:3.1/AV:L/AC:H/PR:H/UI:N/S:U/C:L/I:N/A:L. No public exploit code has been identified at time of analysis, and this CVE is not listed in CISA KEV; vendor fixes are shipped in Linux 6.18.51, 7.2.5 and 7.3-rc1.
Out-of-bounds memory access in the Linux kernel's drm/panthor driver for Arm Mali CSF-class GPUs, caused by 32-bit offset arithmetic wrapping before a bounds check in panthor_init_cs_iface() and panthor_init_csg_iface(). A local attacker with low privileges on a system that has CONFIG_DRM_PANTHOR loaded and a Mali CSF GPU present could influence firmware-provided control-interface strides/offsets to escape the mapped region, yielding potential information disclosure and memory corruption (high confidentiality, integrity, and availability impact per the assessed vector). Exploitation requires the ability to supply malicious or compromised firmware content and is rated high complexity in our independent assessment (AV:L/AC:H/PR:L/UI:N); no public exploit code has been identified at time of analysis and there is no CISA KEV confirmation of active exploitation.
A race condition in the Linux kernel's Direct Rendering Manager (DRM) core allows a local low-privileged user to trigger use-after-free-style resource teardown by issuing an ioctl on a partially registered DRM device node. When drm_dev_register() fails after one minor (for example the render minor) has already been registered and opened by userspace, the error path tears down device resources without first setting the unplugged flag, so an in-flight drm_dev_enter() critical section can continue operating on freed state. The vendor rates this CVSS 3.1 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H); our independent assessment keeps the same CIA and local/low-privilege prerequisites but raises attack complexity to High because the attacker must win a narrow window during a probe or hot-plug registration failure that is not normally under their control. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation (CISA KEV); vendor patches are available across the supported stable branches.
Missing validation of the plane degamma LUT size in the Linux kernel's AMD display driver (amdgpu/DC) lets a local, authenticated user who can submit DRM atomic commits supply a malformed AMD_PLANE_DEGAMMA_LUT blob - for example a single-entry LUT - and drive the kernel into a divide-by-zero in __is_lut_linear() or an out-of-bounds read in __drm_lut_to_dc_gamma(). The practical consequence is a kernel crash or denial of service and, via the out-of-bounds read, potential disclosure of kernel memory contents; there is no evidence of memory corruption leading to code execution, and this is a local-only issue. Reachability is narrow: the vulnerable property is exposed only on kernels built with AMD_PRIVATE_COLOR (not enabled in mainstream distribution kernels) and only on systems with an AMD GPU using the amdgpu/DC display path. No public exploit code and no confirmed active exploitation were identified at time of analysis, and vendor patches are available in the stable trees (6.12.110, 6.18.51, 7.2.5) and in mainline 7.3-rc1.
Integer overflow in the Linux kernel's amdgpu VCN decode-message parser lets an authenticated local user with access to the AMD GPU device node bypass a buffer-count bounds check and drive the parser loop far past the end of a message buffer object, producing out-of-bounds kernel reads that crash the system (availability) and can disclose kernel memory (confidentiality). Exploitation is not remote or unauthenticated: the attacker must be a local principal able to submit VCN decode messages and must additionally allocate a roughly 4 GiB GPU-accessible mapping so msg[1] passes the earlier 'header does not fit in BO' check, a substantial resource precondition that our assessment scores as high attack complexity (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:N/A:H). No public exploit code was identified at time of analysis and the issue is not listed as confirmed actively exploited (CISA KEV); this is a genuine but modest-priority local vulnerability.
An out-of-bounds array access in the Linux kernel's AMDGPU driver (drm/amdgpu) lets a local user who can submit GPU work trigger a kernel fault when a ring that was never assigned to a compute partition (AMDGPU_XCP_NO_PARTITION, i.e. ~0) is used on the SDMA isolation-enforcement or VM-flush paths. The access is caught by UBSAN and can crash the kernel, giving a denial-of-service condition with only limited memory-disclosure potential; because the trigger requires local access to an affected AMD GPU running with partition isolation active, exploitation is hardware- and configuration-dependent rather than universally reachable. The vendor has released patches (Linux 6.18.51, 7.2.5 and 7.3-rc1), and no public exploit code was identified at time of analysis; the independent assessment scores this locally as CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:N/A:H, i.e. availability-weighted with low confidentiality impact.
Stale GPU TLB entries in the Linux kernel's AMD KFD (amdkfd) driver let in-flight DMA descriptors from already-unmapped MES-scheduled queues continue reading or writing memory that has been freed or migrated, producing page faults and hung compute queues. The flaw affects AMD GPU/APU systems running KFD/ROCm compute through the MES firmware scheduler path rather than the HWS path (which invalidates the TLB automatically), and was reproduced on gfx1151 (Strix Point) with XNACK mode 1 enabled during SVM page-migration workloads such as KFDSVMRangeTest.MultiThreadMigrationTest. It is a local, timing-sensitive race requiring a GPU-authorized local user, per our assessment triggers only during MES queue eviction (evict_process_queues_cpsch) or debug/CRIU queue suspension (suspend_queues) concurrent with SVM page migration; no public exploit identified at time of analysis, and it is not listed in CISA KEV. Vendor-released patches (Linux 6.18.51, 7.2.5, and 7.3-rc2) add the missing kfd_flush_tlb() calls.
Memory corruption in the Linux kernel's AMD KFD (amdkfd) driver allows a local user with access to the GPU compute interface to corrupt kernel page state when a GPU Shared Virtual Memory (SVM) page migration from device memory to system RAM fails. The error-path cleanup derives the struct page from a DMA/bus address instead of the page's physical address (pfn), so on systems with an enabled IOMMU it releases and unlocks system-RAM pages that the migration never pinned, while the genuinely allocated pages are leaked and their DMA mappings are not torn down correctly. The vendor assigns CVSS 7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H); our independent assessment keeps the same impact but raises attack complexity to AC:H because the faulty cleanup is reachable only after a device-to-system-RAM migration has already failed and requires IOMMU plus an active ROCm/HSA SVM workload. No public exploit identified at time of analysis and it is not confirmed actively exploited (CISA KEV).
Linux kernel AMD KFD (amdkfd) SVM migration code can use an uninitialized return value when migrating a VM range whose CPU side is a hole, causing the driver to tear down all VRAM pages it has just allocated and leaving memory state inconsistent. Affected are Linux kernel builds using the AMD GPU compute path (SVM/HMM migration to VRAM on ROCm/HSA-capable AMD hardware); the flaw affects code reachable from the commit 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 baseline and is fixed in 6.18.51, 7.2.5 and 7.3-rc1. Triggering requires a local user holding a GPU device handle and hitting a racy, non-default memory-layout condition, and no public exploit code was identified at time of analysis; the vendor's CVSS 3.1 score of 7.8 is assessed as overstated relative to this local, condition-gated error-handling defect.
A use-after-put in the Linux kernel's DRM pagemap device-memory migration code (drm_pagemap_migrate_populate_ram_pfn) lets a local, low-privileged user who can drive the GPU/device-private-memory migration path corrupt kernel memory and potentially escalate privileges. The defect has two parts: higher-order (THP) folio allocations lack __GFP_NOWARN and any order-0 fallback, and the free_pages error path computes folio_order(page_folio(page)) after put_page(page) has already dropped the reference, so corrupting state occurs when that put released the last reference. Exploitation requires the DRM pagemap subsystem (new in Linux 6.18) to be built and actively used on supported hardware, plus attacker-induced memory pressure to force the allocation failure, and the severity is moderated by the AC:H assessment in the authoritative analysis; there is no public exploit code and no confirmed active exploitation (no CISA KEV listing) at time of analysis.
A mismatched DMA unmap size in the nouveau DRM driver's device-private memory (dmem) migration path causes the kernel to unmap only PAGE_SIZE instead of the full compound-folio mapping size when device-private transparent huge pages (THP) are migrated. On affected systems running the open-source nouveau driver with dmem THP migration in use, an authenticated local attacker able to drive GPU device-memory migration workloads can repeatedly trigger the nouveau_dmem_migrate_to_ram() success path or the nouveau_dmem_migrate_copy_one() copy-error path, gradually leaking residual IOMMU/IOVA mappings for order>0 folios. No public exploit code exists and the issue is not confirmed as actively exploited (not in CISA KEV); EPSS and KEV signals are absent, and our independent assessment scores this as a low-impact, local-only mapping leak (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:N/A:L) rather than the 8.8 vendor vector, which overstates confidentiality, integrity, and scope impact.
Use-after-free in the Linux kernel's in-tree nouveau DRM driver lets a local user who can access the nouveau device node on a Fermi-generation or newer NVIDIA GPU potentially corrupt memory during channel teardown. The bug is an ordering flaw in nouveau_channel_del(): the channel's fence context is freed by context_del() before the channel-kill event subscription is dropped, so a kill event delivered in that narrow window makes nouveau_channel_killed() call nouveau_fence_context_kill() on an already-freed fence context. No public exploit code has been identified at time of analysis, and although the CNA assigned CVSS 7.8 (AV:L/AC:L/PR:L), our assessment raises attack complexity to High because a kill event must land in a very tight race window - and on current kernels nothing actually kills a channel on this path, making real-world triggerability very low.
Linux kernel builds containing the open-source Nouveau GPU driver (drm/nouveau/uvmm) fail to clear op->reg on two error paths in nouveau_uvmm_bind_job_submit()'s OP_UNMAP_SPARSE arm, so a job that never created a sparse region can drop the region's only reference in nouveau_uvmm_bind_job_cleanup() and free a live object; a second job still owning that region then performs a use-after-free. Exploitation requires local access to the DRM/render device node and the ability to submit VM_BIND jobs (PR:L), plus a trigger of the -ENOENT busy-region check or an -ENOMEM failure from drm_gpuvm_sm_unmap_ops_create(), with the full use-after-free needing a concurrent job holding the same region. No public exploit code or confirmed active exploitation was identified at time of analysis, and systems running the proprietary NVIDIA driver rather than Nouveau are not affected.
A local privilege-escalation use-after-free exists in the Linux kernel perf subsystem: an unprivileged local user can win a tight race between perf_mmap_close() and a concurrent perf_mmap_rb() revival so that a freshly revived ring buffer is freed while another process still has it mapped, yielding page-level memory corruption and a path to root. The bug is reachable under the default kernel.perf_event_paranoid=2 setting (authenticated local account per the CVSS vector PR:L, no user interaction), so hardening the setting or restricting perf_event_open is the practical interim control. Vendor-released patches are available (6.18.52, 7.2.5, 7.3-rc2), the EPSS score is low at 0.19% (9th percentile), and no public exploit code has been identified at time of analysis - but exploitation is local-only and probabilistic, requiring repeated attempts to hit the TOCTOU window.
A use-after-free in the Linux kernel GTP (GPRS Tunnelling Protocol) module allows a local attacker who can create GTP links to trigger a race between link teardown and inbound packet processing, potentially leading to kernel memory corruption with high confidentiality, integrity, and availability impact. Only systems that have the gtp module loaded or reachable are exposed - a mobile-core/telecom feature uncommon in general-purpose Linux deployments - and exploitation requires CAP_NET_ADMIN (obtainable by an unprivileged user within a user namespace) plus a non-deterministic race win, which is why our independent assessment rates the vector AV:L/AC:H/PR:L rather than the published AV:L/AC:L/PR:L. No public exploit code has been identified at time of analysis (EPSS 0.21%, 11th percentile) and the issue is not confirmed actively exploited (CISA KEV).
A use-after-free in the Linux kernel's in-kernel ksmbd SMB3 server allows an authenticated attacker with an established SMB2 session to race an SMB2 TREE_CONNECT request against a concurrent session LOGOFF, so the tree-connection object is freed while smb2_tree_connect() is still initializing it and building the response. Successful triggering yields memory corruption in kernel context that can be leveraged for both confidentiality and integrity impact (KASAN reports slab-use-after-free at fs/smb/server/smb2pdu.c:2872). The CVE carries a 9.8 base score from the kernel CNA, but the assessed vector is AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, reflecting that exploitation requires a valid session and precise timing; EPSS is low (0.19%, 9th percentile), there is no CISA KEV listing, and no public exploit code has been identified at time of analysis.
Out-of-bounds heap reads in the Linux kernel's ext4 inline-directory code (ext4_read_inline_dir()) let a local actor who can present a crafted inline-data ext4 directory - by creating one on a writable ext4 volume with the inline_data feature enabled, or by mounting a malicious ext4 image (e.g. via removable-media automount) - leak kernel heap memory and crash the kernel through an ordinary getdents64()/iterate_dir() call. The kernel emits a KASAN slab-out-of-bounds report in __ext4_check_dir_entry when the size-2 rec_len probe is dereferenced past the end of the kmalloc(inline_size) buffer. There is no public exploit identified at time of analysis, no CISA KEV listing, and EPSS is 0.21% (11th percentile), indicating low predicted exploitation activity; the supplied CVSS of 9.1 (AV:N/PR:N) is inconsistent with the flaw's local-only reachability and should be treated as mis-scored, with the assessed vector being AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H (High).
IPv6 IPsec receive processing in the Linux kernel writes one element past the end of the six-slot xfrm_state pointer array in xfrm6_input_addr(), because the depth guard tests '1 + sp->len == XFRM_MAX_DEPTH' instead of '>=', so a secpath already stacked to XFRM_MAX_DEPTH by xfrm_input() and preserved across xfrm_trans_reinject() bypasses the check and stores into sp->xvec[sp->len++]. The attacker must control an inner packet carrying a Mobile IPv6 destination-options Home Address option or a type-2 routing header, and because the write stays inside the larger sec_path allocation it is invisible to KASAN - it is only flagged by UBSAN_BOUNDS and only fatal when the non-default panic_on_warn sysctl is enabled, otherwise it is a logged warning with no functional effect. This means the input CVSS 3.1 vector of 9.8 (AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:H) is the generic maximal score auto-assigned to Linux kernel CVEs and is not credible for this bug: the authoritative independent assessment rates it CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H (5.9, availability-only, high attack complexity), since exploitation requires IPsec transport mode with six nested SA transforms, a Mobile IPv6 header, and a UBSAN_BOUNDS kernel with panic_on_warn enabled. Exploitation status: no public exploit identified at time of analysis; EPSS is only 0.21% (11th percentile) and the flaw is not listed in CISA KEV, consistent with the layered prerequisites. Authentication requirements: unauthenticated remote attackers (CVSS vector contains PR:N).
Mounting a crafted NTFS filesystem image can corrupt Linux kernel memory through the in-kernel fs/ntfs3 driver, where an integer truncation in restart-table growth (a u32 'used + add' cast to the u16 __le16 count of struct RESTART_TABLE) produces an undersized allocation that is subsequently written past its bounds during $LogFile replay. The issue is local and requires an attacker-supplied image to actually be mounted: on default configurations this needs mount privileges (CAP_SYS_ADMIN/root), while the unprivileged path depends on a USB-automount daemon plus physical insertion of the media, so it is not remotely reachable. Kernels carrying the vulnerable ntfs3 log-replay code before the listed stable fixes are affected; vendor patches are available (Linux 5.15.221, 6.1.188, 6.6.157, 6.12.110, 6.18.52 and 7.2.6, plus 7.3-rc1 in mainline), no public exploit was identified at time of analysis, and EPSS is low at 0.21% (11th percentile).
Mounting a crafted NTFS image on a Linux system with the ntfs3 driver loaded triggers an out-of-bounds read in read_log_rec_buf(), causing a kernel crash and possible disclosure of adjacent slab memory into the log replay buffer. This is a local-only issue that requires the attacker to get the malicious volume mounted, either through physical media with an active automount daemon or a process/user holding mount privileges such as CAP_SYS_ADMIN, and no public exploit was identified at the time of analysis. Vendor patches are available in stable releases 5.15.221, 6.1.188, 6.6.157, 6.12.110, 6.18.52, 7.2.6, and 7.3-rc1, and the independent assessment (AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:H) is lower than the provided 8.4 vector because impact is limited to crash and potential disclosure rather than code execution.
Heap memory disclosure in the Linux kernel's ntfs3 filesystem driver lets an attacker who can get a crafted NTFS image mounted read past the kmalloc-backed extended-attribute buffer and leak kernel heap contents to userspace via getxattr(), with an out-of-bounds read of up to 65535 bytes that can also crash the kernel. The defect is a missing size check in ntfs_read_ea(): a record declaring ef->size = 24 while elength = 0xffff passes validation because only the remaining buffer size is verified, after which ntfs_get_ea() trusts elength and copies the oversize value out of the undersized record. Exploitation is not remotely reachable in default configurations - it requires local access or a system that automounts untrusted removable media (the vendor's CVSS 9.1 AV:N rating overstates exposure), EPSS is 0.21% (11th percentile), and no public exploit code has been identified at time of analysis, though the vendor has released fixes.
An out-of-bounds read in the Linux kernel's ISO9660/zisofs decompression code allows a local attacker to read memory past the end of a page-pointer array (kmalloc-8 slab) by simply read()ing a compressed file from a crafted ISO9660 image. The flaw is reachable only when the image's Rock Ridge 'ZF' record specifies a zisofs block-size shift below PAGE_SHIFT (a value rock.c does not reject) and a sub-page block leaves poffset partway into a page followed by an empty block, so the mount prerequisite and local trigger make this a local availability/limited-disclosure bug rather than a remote one. No public exploit code was identified at time of analysis, and EPSS is low (0.21%, 11th percentile); exploitation is not confirmed in the wild and the vendor's AV:N/PR:N CVSS 9.8 score is not credible for a bug that requires mounting a malicious image on the target - our assessment is AV:L/PR:L with high availability impact and low confidentiality impact.
A memory-corruption flaw in the Linux kernel's vfio-pci driver (vfio/pci/vfio_pci_config.c) allows a local user holding access to a VFIO passthrough device node (typically /dev/vfio/*) to trigger a use-after-free and subsequent double-free of the per-device MSI permission table (vdev->msi_perm). Exploitation requires attacker-induced failure of the allocation path (init_pci_cap_msi_perm()/alloc_perm_bits() returning -ENOMEM during a failed device open, e.g. under memory pressure or fault injection), after which re-opening the same persistent vfio_pci_core_device reuses the freed perm_bits object - dereferencing its readfn/writefn function pointers inside vfio_pci_config_rw_single() - while closing it hits kfree() on an already-freed object in vfio_config_free(). There is no public exploit code identified and no indication of active exploitation at time of analysis; EPSS is low (0.21%, ~11th percentile), and the memory-pressure precondition plus the requirement for VFIO passthrough privileges materially limits real-world reliability, even though the assessed CVSS:3.1:AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H score is high.
A mis-sized TLB invalidation in the Linux kernel's KVM/arm64 stage-1 handling can leave stale translations resident in the TLB when the stage-1 MMU is disabled during a VNCR (nested virtualization / FEAT_NV2) invalidation, so a workload able to drive nested-guest TLB operations on a vulnerable arm64 host may retain access to mappings that should have been flushed. The bug is a correctness defect in TLB-invalidation size computation rather than an exposed remotely reachable primitive: it requires an arm64 host running KVM with nested virtualization enabled on an affected kernel, and our independent assessment rates it AV:L/AC:H/PR:L (local access, high attack complexity), materially lower than the published CVSS 9.3, because no path from a stale-TLB condition to a concrete memory-safety effect has been demonstrated. EPSS is 0.18% (8th percentile) and no public exploit code has been identified at time of analysis; vendor patches are available.
A use-after-free in the Linux kernel's Bluetooth SCO (synchronous connection-oriented) socket handling lets an attacker within Bluetooth radio range race the SCO connection-ready path against a concurrent socket close, dereferencing a freed socket with the potential for kernel memory corruption or a crash. Only systems with Bluetooth enabled and an active SCO listening socket are exposed, and exploitation is unauthenticated but adjacent (AV:A) and highly timing-dependent (AC:H in independent assessment), with the realistic outcome being a kernel denial of service rather than reliable code execution. No public exploit code has been identified at time of analysis and the vulnerability is not in CISA KEV; EPSS is 0.19% (9th percentile), indicating low observed exploitation likelihood, and vendor patches are available in stable releases 5.15.212, 6.1.178, 6.6.145, 6.12.97, 6.18.40 and 7.1.
A time-of-check-to-time-of-use race condition in the Extensions component of Google Chrome on macOS allows an attacker to break out of the renderer sandbox and execute arbitrary code in the browser process context. The barrier to entry is meaningful: the attacker must already have compromised the renderer process through a separate bug and then use social engineering to persuade the victim into a specific UI interaction that widens the race window. Affected builds are Chrome for macOS prior to 153.0.8010.47, and Google rates the issue High severity; no public exploit code or CISA KEV entry was identified at time of analysis.
Use-after-free in the V8 JavaScript engine of Google Chrome desktop builds prior to 153.0.8010.47 allows unauthenticated remote attackers to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page. Because the CVSS vector is PR:N/UI:R, no credentials or special browser configuration are required, but the victim must actively navigate to attacker-controlled content; the memory-corruption primitive is confined to the renderer process, so full host compromise would require a second, independent sandbox-escape vulnerability. No public exploit code has been identified at time of analysis, and the vendor has released a fixed build, making this a high-priority patch item rather than a confirmed active-exploitation emergency.
Sandbox escape in Google Chrome prior to 153.0.8010.47 allows a remote attacker who has already compromised the browser's renderer process to execute arbitrary code outside the sandbox via a race condition (TOCTOU) triggered by a crafted HTML page; the user must visit that page for the flaw to be reachable. Google rates the issue Chromium security severity High and a vendor patch is available from the 153.0.8010.47 stable channel release. There is no public exploit code and no CISA KEV listing at time of analysis, and the high attack complexity combined with a required renderer-compromise precondition keeps realistic risk below the raw 8.3 CVSS score.
Type confusion in Chrome's CacheStorage implementation in builds prior to 153.0.8010.47 lets a remote, unauthenticated attacker execute arbitrary code inside the browser's renderer sandbox when a victim loads a crafted HTML page. The bug is rated High by Chromium and 8.8 by NVD (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), but it is a renderer-level compromise rather than a sandbox escape, so host impact requires chaining a second vulnerability. No CISA KEV listing and no public exploit code were identified at time of analysis, and no EPSS score was supplied in the input data.
Improper input validation in ANGLE, Google Chrome's graphics abstraction layer, allows a remote attacker to potentially execute arbitrary code outside the browser sandbox by convincing a user to open a crafted HTML page in Chrome builds prior to 153.0.8010.47. Exploitation requires no authentication (PR:N) but does require user interaction (UI:R) - the victim must navigate to attacker-controlled or compromised content - and the scope-change metric (S:C) reflects that successful exploitation implies code execution escaping the renderer sandbox onto the host OS. The issue carries a Critical 9.6 CVSS rating and a vendor patch is available in Chrome 153.0.8010.47; there is no public exploit identified at time of analysis, and Chromium rates the underlying security severity as Medium.
Remote code execution inside the renderer sandbox can be triggered in unpatched Google Chrome builds by a use-after-free in the browser's built-in PDF rendering component. Exploitation is unauthenticated (CVSS PR:N) but requires the victim to open a crafted HTML page that embeds malicious PDF content (UI:R), and any resulting code execution is confined to Chrome's renderer sandbox - meaning this bug alone does not compromise the host and would typically need to be chained with a separate sandbox-escape flaw for full system compromise. A vendor patch is available in Chrome 153.0.8010.47; no public exploit code has been identified at time of analysis and there is no CISA KEV listing, though the 8.8 CVSS score and the ubiquity of Chrome make timely patching a priority.
Use-after-free in Chrome's DOM implementation allows a remote attacker to execute arbitrary code inside the renderer sandbox when a victim opens a crafted HTML page in Chrome versions prior to 153.0.8010.47. The flaw carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and is rated High by Chromium security severity; a vendor patch is available and no public exploit code or CISA KEV entry was identified at time of analysis.
Google Chrome versions earlier than 153.0.8010.47 contain an incorrect authorization flaw (CWE-863) in the WebUI subsystem that lets an attacker who already controls a compromised renderer process break out of the browser sandbox and run arbitrary code on the host via a crafted HTML page. Exploitation is a two-stage proposition: the attacker must first obtain renderer code execution, then chain this flaw to escape the sandbox, and the victim must load the malicious page. Google rates the Chromium security severity as High and has shipped a fix in Chrome 153.0.8010.47; no public exploit code or CISA KEV entry was identified in the available intelligence at time of analysis.
Incorrect authorization in Chrome's Core component on Windows (versions prior to 153.0.8010.47) lets a local attacker who can run a program on the machine break out of the browser sandbox and execute arbitrary code at the user's privilege level outside it. The flaw is rated High by the Chromium security team and carries CVSS 7.4 (AV:L/AC:H/PR:N/UI:N, C/I/A all High), reflecting a local-only but complete confidentiality, integrity and availability impact once the sandbox boundary is crossed. No public exploit code or CISA KEV listing was provided in the input, and Google has released a fixed stable-channel build, so this is best treated as a high-value chaining primitive rather than a currently mass-exploited issue.
Improper state validation in the Skia graphics library, as shipped in Google Chrome prior to 153.0.8010.47, lets an attacker who already controls a compromised renderer process read memory outside the browser sandbox by serving a crafted HTML page. Exploitation requires the victim to load the malicious page (UI:R) and depends on chaining with a separate renderer compromise, which is why the vector carries AC:H despite the network attack path. Vendor status is "Patch available"; no public exploit code and no CISA KEV listing were present in the supplied intelligence, so the flaw should be treated as a sandbox-escape primitive rather than an observed, widely exploited issue.
Missing authorization in Chrome's AppManifest handling (CWE-862) lets an attacker who has already compromised the renderer process bypass web origin policy and load a crafted HTML page inside a trusted origin context, yielding high confidentiality and integrity impact. Exploitation is not a default-config remote attack: it requires two stacked preconditions - a pre-compromised renderer (typically via a separate prior bug) plus social engineering to induce victim interaction with the malicious page. Per the CVSS vector (AV:N/AC:L/PR:N/UI:R) the attacker is remote and unauthenticated, but user interaction is mandatory; our independent assessment raises attack complexity to High (AC:H) because the renderer must first be subverted, and Google's own rating is 'Chromium security severity: Medium'. EPSS is low at 0.25% (16th percentile) and no public exploit has been identified at time of analysis; the fix ships in Chrome 153.0.8010.47, so patched and auto-updated browsers are not affected.
Remote code execution inside the renderer sandbox affects Google Chrome desktop builds prior to 153.0.8010.47, caused by a type confusion flaw in the browser's compositing pipeline (CWE-843) that is reachable from a crafted HTML page. An attacker needs only to convince a user to load the page: the CVSS 3.1 vector is 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), so no credentials or privileges are required, but user interaction is mandatory. Google rates the issue Chromium security severity High and has shipped a fixed stable-channel build; no public exploit code or CISA KEV listing appears in the supplied intelligence, and no EPSS score was provided, so the current exploitation picture is best described as patch-now-but-not-known-exploited.
Use-after-free in Google Chrome's DigitalCredentials component lets a remote, unauthenticated attacker execute arbitrary code outside the browser sandbox when a victim is socially engineered into loading a crafted HTML page, affecting all Chrome builds prior to 153.0.8010.47. Exploitation requires no credentials or elevated privileges (CVSS PR:N) but does require the user to navigate to the attacker-controlled page (UI:R), and the resulting scope change (S:C) means impact extends beyond the browser's sandbox boundary to full confidentiality, integrity, and availability loss. Google rates the issue High and has shipped a fix in the stable channel; no public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV, so the current risk is driven by the ease of phishing/malvertising delivery rather than confirmed active exploitation.
Integer overflow in V8, Chrome's JavaScript engine, allows a remote attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page in Chrome builds prior to 153.0.8010.47; the bug carries a high CVSS (9.6 as published, scored 8.8 under our scope-unchanged reassessment) because memory corruption in V8 can be leveraged for code execution, though impact is confined to the renderer process and full host compromise would require chaining a separate sandbox-escape flaw. Chrome ships on a rapid auto-update cadence and a vendor patch is available (153.0.8010.47), which limits mass exposure; EPSS is a modest 0.36% (30th percentile), CISA SSVC records no observed exploitation, and no public exploit code has been identified at time of analysis, so this is a high-severity memory-safety defect to prioritize for unpatched or update-delayed enterprise fleets rather than an active-emergency. No authentication is required (PR:N), but exploitation depends on user interaction: the victim must load attacker-controlled JavaScript with scripting enabled in the default configuration.
Let me synthesize. CVE-2026-91727: Incorrect reference resolution in Extensions in Chrome on Mac prior to 153.0.8010.47. Local attacker who compromised renderer process could execute arbitrary code outside sandbox via a local program. CWE-706 (Use of Incorrectly-Resolved Name or Reference). CVSS 8.1 AV:L/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H. Product: Google Chrome (macOS). Product name 1-3 words: "Google Chrome". Prevalence: ubiquitous. Now fields. Summary: must not copy description; start with impact verb and product. E.g. "Sandbox escape in Google Chrome on macOS (prior to 153.0.8010.47) lets an attacker who has already compromised the renderer process escalate to code execution outside the browser sandbox..." Technical context: CWE-706 incorrect reference resolution in Extensions — extension API resolves a reference (name/path/identifier) incorrectly, allowing a local program to be loaded/executed outside sandbox. macOS-specific. Renderer compromise prerequisite. Risk assessment: CVSS 8.1 with AV:L AC:H PR:N UI:N S:C. EPSS not provided, KEV not provided. Patch available. No POC known. Attack requires renderer compromise (two-stage). S:C indicates sandbox escape crossing security scope. Not KEV → no public exploit identified at time of analysis. Note missing EPSS/KEV data explicitly. Affected products: Google Chrome on macOS versions prior to 153.0.8010.47; EUVD lists "Chrome 153.0.8010.47 <153.0.8010.47" which is malformed/likely means before 153.0.8010.47. Reference: chromereleases blog, chromium issue 516893912. Remediation: upgrade to 153.0.8010.47 or later. Chrome auto-update. macOS-specific. Compensating controls: restrict extension installs via enterprise policy, disable extensions, etc. Trade-offs. Exploit scenario: attacker chains a renderer RCE (e.g. via malicious web content) then exploits the extension reference resolution flaw to break out of sandbox and run native code on macOS host. Exploitation conditions: requires (1) macOS platform, (2) att
Google Chrome builds prior to 153.0.8010.47 carry a use-after-free in the browser's Input component that allows an attacker who already controls a compromised renderer process to escape the Chrome sandbox and run arbitrary code with the browser's privileges. Exploitation is not remote-standalone: it requires a chained renderer compromise plus a victim who opens a crafted HTML page, which is why the flaw is scored High (8.3) rather than Critical despite total technical impact. Google has shipped a fixed stable-channel build; no public exploit code has been identified and the issue is not listed in CISA KEV at time of analysis.
Use-after-free in Google Chrome's Input handling allows a remote attacker to achieve code execution in affected desktop builds prior to 153.0.8010.47. Exploitation is unauthenticated (PR:N) but requires the victim to render attacker-controlled HTML (UI:R), making drive-by or malicious-page delivery the primary vector; default configurations are affected with no non-default prerequisites. The vulnerability is rated CVSS 8.8 (C:H/I:H/A:H) and a vendor patch is available in the Stable channel build 153.0.8010.47; no public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing).
A use-after-free in Google Chrome's Internals component allows a remote attacker to potentially execute arbitrary code outside the browser sandbox when a victim opens a crafted HTML page, affecting all Chrome builds prior to 153.0.8010.47 on desktop. Exploitation requires user interaction (visiting the page) but no authentication or elevated privileges, and Google rates the Chromium security severity as Critical. Vendor-released patch: 153.0.8010.47. There is no public exploit code identified at time of analysis and no confirmed actively exploited (CISA KEV) status, though the SSVC framework assigns total technical impact.
Code injection in XML handling in Google Chrome versions prior to 153.0.8010.47 could let a remote attacker bypass the web origin policy by luring a victim into opening a crafted HTML page (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:N per independent assessment, versus Google's published 8.1 vector). Exploitation requires user interaction - the victim must load the malicious page - and no authentication is needed, while Google's own Chromium severity rating is 'Low', indicating constrained real-world impact; the EPSS score is 0.26% (17th percentile) and no public exploit has been identified at time of analysis. A vendor patch is available in Chrome 153.0.8010.47, and Chrome's automatic background update mechanism rapidly retires vulnerable versions.
Use-after-free in Google Chrome's Core component lets a remote attacker execute arbitrary code outside the browser sandbox by getting a victim to load a crafted HTML page in any build prior to 153.0.8010.47. The flaw is unauthenticated (PR:N) but requires user interaction (UI:R), and because the resulting code execution occurs outside the sandbox, Chrome's normal renderer isolation does not contain the compromise; the assessed severity is 9.6 with scope changed (S:C). No public exploit code has been identified at time of analysis, and a vendor-released patch is available in Chrome 153.0.8010.47.
Use-after-free in Google Chrome's Auth component allows a remote attacker to achieve code execution outside the browser sandbox when a victim simply loads a crafted HTML page in any desktop Chrome build prior to 153.0.8010.47. Exploitation is unauthenticated and requires no special configuration - the only prerequisite is the user interaction of visiting or rendering the attacker-controlled page (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6), and because the flaw is not confined to the renderer, no separate sandbox-escape bug is needed to reach the host. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; Google has released a fixed build (153.0.8010.47), and details remain restricted in the Chromium tracker until most users have updated.
Type confusion in Chrome's ServiceWorker implementation allows a remote attacker to achieve arbitrary code execution inside the renderer sandbox by enticing a victim to load a crafted HTML page in any Chrome build prior to 153.0.8010.47. Exploitation is unauthenticated (PR:N) but requires user interaction (UI:R) - the victim must visit or be redirected to attacker-controlled content - and the resulting code execution is confined to the sandbox (S:U), so full host compromise would require chaining a separate sandbox-escape flaw. There is no public exploit identified at time of analysis, and a vendor-released patch (153.0.8010.47) is available, making this a high-priority but practically bounded patching task rather than an urgent zero-day response.
Google Chrome on macOS versions prior to 153.0.8010.47 contain a race condition (TOCTOU) in the Extensions subsystem that lets an attacker who has already compromised the browser's renderer process break out of the sandbox and execute arbitrary code on the host, triggered when a victim loads a crafted HTML page. Google rated the issue High severity and Chromium's own severity assessment drove the 8.3 CVSS base score with a Scope change (S:C), reflecting that code execution crosses the renderer/sandbox boundary rather than staying contained. No public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV, but a vendor patch is available and should be applied promptly because sandbox escapes are the high-value second stage of any Chrome exploit chain.
An out-of-bounds write in Google Chrome's ServiceWorker implementation allows remote code execution inside the browser's renderer sandbox when a victim loads a crafted HTML page; exploitation requires the user to visit or be redirected to attacker-controlled content and to have a service worker exercised (UI:R, PR:N), so no credentials or pre-existing privileges are needed. Successful exploitation yields high confidentiality, integrity and availability impact within the sandboxed renderer process (CVSS 3.1 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), and host compromise would additionally require a separate sandbox-escape. Only Chrome builds prior to 153.0.8010.47 are affected, a vendor patch is available, and no public exploit code has been identified at time of analysis; because Chrome auto-updates in the background, most installations will remediate themselves quickly, though managed and long-lived sessions should be verified.
Use-after-free in Google Chrome's WebAppInstalls component allows a remote, unauthenticated attacker to execute arbitrary code outside the browser sandbox when a victim loads a crafted HTML page on any build prior to 153.0.8010.47. Exploitation requires user interaction (CVSS 3.1 vector AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, score 9.6), and the scope-changed rating reflects that a successful attack escapes the renderer sandbox and reaches the host rather than staying contained in the browser process. At time of analysis there is no indication of active exploitation and no public exploit code identified; the vendor has shipped a fixed build (153.0.8010.47) and the primary exposure is unpatched consumer and enterprise Chrome installations.
Type confusion in Google Chrome's ServiceWorker implementation before version 153.0.8010.47 allows a remote attacker to achieve arbitrary code execution inside the renderer sandbox by getting a user to open a crafted HTML page. The flaw carries a CVSS base score of 8.8 (AV:N/AC:L/PR:N/UI:R), the classic memory-corruption profile for Chrome renderer bugs, and Google rated it High in its Chromium severity scheme. A vendor patch shipped in the 153.0.8010.47 stable release, and there is no public exploit code identified and no CISA KEV entry at time of analysis, so this is a prioritise-and-patch issue rather than a confirmed active campaign.
An out-of-bounds read in Mozilla Thunderbird's IMAP response parser affects all builds prior to Thunderbird 156 and prior to Thunderbird 140.16 (ESR), allowing a malicious or compromised IMAP server to crash the mail client and potentially expose a limited amount of process memory by sending a crafted untagged '* ID' response. The flaw is reachable before authentication (CVSS vector PR:N/UI:N), so an attacker needs no mailbox credentials and no user click beyond the client connecting to a server they control, have compromised, or can intercept via man-in-the-middle; independent assessment sets confidentiality impact to Low and availability impact to High, which is milder than the 9.1 NVD base score. Exploitation requires the victim's Thunderbird to actually initiate an IMAP session to the attacker-controlled endpoint, and with EPSS at only 0.21% (12th percentile) and no CISA KEV entry or public exploit code identified, the severity signals conflict: a critical-looking base score against low real-world exploitation likelihood, mitigated by the availability of fixed builds in Thunderbird 156 and 140.16.
An out-of-bounds read in Mozilla Thunderbird's IMAP response parsing can disclose process memory or crash the client when the mail client connects to an attacker-controlled or compromised IMAP server, or when an on-path attacker injects crafted IMAP lines into a session. The flaw affects Thunderbird versions before 156 and Thunderbird ESR versions before 140.16, and is fixed in those releases; exploitation requires the victim's client to establish an IMAP session with the malicious endpoint (CVSS UI:R) while requiring no attacker authentication (PR:N). EPSS is 0.18% (8th percentile), and no public exploit code or confirmed active exploitation (CISA KEV) has been identified at time of analysis.
Malformed email headers in Mozilla Thunderbird before 156 and 140.16 ESR can cause header parsing confusion or potential memory safety violations when a victim opens a crafted message, though code execution is only described as a potential outcome by the vendor. No public exploit code or active exploitation has been identified, and the EPSS score is low at 0.18% (percentile 8). The vulnerability requires user interaction (UI:R) because the victim must receive and render the malicious email, and the raw CVSS of 9.8 overstates real-world urgency for a desktop mail client.
Credential leakage in Tornado's CurlAsyncHTTPClient (all releases through 6.5.6) lets sensitive per-request state — client TLS certificates (SSLCERT/SSLKEY) and proxy basic-auth credentials (PROXYUSERPWD) — persist on pooled pycurl handles and be presented to a different, unintended host on a later request. The flaw affects applications that pass per-request credentials to the curl-backed client and reuse the same client instance across hosts; it is not reachable by an anonymous internet attacker against a default server deployment, and the vendor rates attack complexity as high with attack requirements present. No public exploit code has been identified at time of analysis and no active exploitation is reported; the vendor has fixed the issue in Tornado 6.5.7.
Memory amplification denial of service in the Tornado Python web framework before 6.5.8 lets unauthenticated remote attackers exhaust server memory with a single crafted multipart/form-data request containing tens of thousands of parts — roughly 600KB of body is enough to build a 100,000-element transient list. Tornado's parse_multipart_form_data splits the body on the boundary before it enforces the max_parts limit, so the safety check fires only after the expensive allocation has already happened. Publicly available exploit code exists (a gist with poc.py), patch status is 'available from vendor' with the fix shipped in 6.5.8, and no CISA KEV listing or EPSS score accompanied the supplied intelligence.
Heap memory corruption in FreeRDP's server-side static virtual channel handling (all versions before 3.31.0) allows an authenticated RDP client to send channel messages larger than the expected chunk size, triggering an integer underflow that corrupts heap memory and can overwrite live pointers, potentially yielding code execution on the RDP server. Reachability is gated on the server enabling CHANNEL_OPTION_SHOW_PROTOCOL for the channel, and on the attacker already holding a valid session, so this is a post-authentication, configuration-dependent flaw rather than a pre-auth RCE. A vendor fix is available in 3.31.0 via upstream commit 40d9202, and no public exploit code or confirmed active exploitation was identified at time of analysis.
Widget: Win32 mitigation bypass in Mozilla Firefox on Windows allows attacker-controlled web content to defeat a platform security protection (CWE-693); the flaw is fixed in Firefox 156 and Firefox ESR 153.3. Mozilla rates it 9.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), implying unauthenticated remote compromise with no user interaction, but the independent assessment scores it AV:N/AC:H/PR:N/UI:R - a Windows-only precondition, a victim who actually renders the malicious page, and typically a second chained vulnerability are required before the bypass converts into high confidentiality/integrity impact. EPSS is 0.15% (5th percentile), and there is no CISA KEV entry or public exploit code identified at the time of analysis, so real-world exploitation pressure is currently low.
Memory corruption in Mozilla Firefox's Networking component can be triggered when the browser processes crafted or malformed network data, giving an attacker who controls the data path a possible route to code execution inside the content process. All Firefox builds before 156 and Firefox ESR builds before 153.3 are affected; Mozilla shipped fixes in Firefox 156 and Firefox ESR 153.3. Reaching the bug requires the victim to actively browse to an attacker-controlled site or route traffic through a malicious or MITM'd endpoint, and exploitation further depends on winning a heap-layout/memory-corruption primitive, with any resulting execution initially confined to the sandboxed content process; no public exploit code is identified at time of analysis and EPSS is low at 0.15% (5th percentile). Note that the two CVSS vectors in circulation disagree - the NVD-supplied vector (8.8, AV:L/AC:L/PR:L) implies prior local low-privilege access, whereas the independent reassessment (AV:N/AC:H/PR:N/UI:R) describes the more plausible remote-web-content path, and that discrepancy should be resolved with Mozilla before finalising exposure decisions.
A mitigation bypass in the Mozilla Firefox Networking component lets remote attackers defeat a built-in browser security protection, yielding high confidentiality and integrity impact (CVSS 9.1, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N as scored by Mozilla) against unpatched clients. Affected are Firefox versions prior to 156 and Firefox ESR prior to 153.3; our internal assessment keeps the same C:H/I:H/A:N impact but treats the recorded UI:N as optimistic and applies UI:R, since a client-side browser flaw in practice requires the victim to load attacker-influenced web content before the bypass can be exercised. No public exploit code has been identified at time of analysis and the EPSS score is low (0.16%, 5th percentile); vendor-released patches exist in Firefox 156 and Firefox ESR 153.3.
A mitigation bypass in the Firefox Popup Blocker allows attacker-controlled web content to defeat the browser's built-in popup-blocking protection, so unwanted windows can be spawned despite the user's configured blocking preference. All Firefox builds prior to 156 and Firefox ESR builds prior to 153.3 are affected, per the CPE entry cpe:2.3:a:mozilla:firefox:*:*:*:*:*:*:*:* and Mozilla advisories mfsa2026-90, mfsa2026-93, mfsa2026-94 and mfsa2026-96. Exploitation requires a victim to load the crafted content in an unpatched browser, and the practical outcome is a weakened anti-deception control enabling phishing and UI spoofing rather than code execution or direct data compromise; EPSS is a low 0.16% (5th percentile), and no public exploit has been identified at time of analysis. Note that the supplied CVSS 8.8 rating is not supported by the independent re-assessment, which scores the issue as AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N because impact is limited to integrity of the browser's protective behavior.
Memory-safety corruption in Mozilla Firefox's Safe Browsing component can be triggered when a victim loads attacker-controlled web content on any Firefox build before 156 or Firefox ESR before 153.3. The assessed vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, score 8.0) shows the vulnerability is network-reachable with low complexity, but exploitation is gated by mandatory user interaction - the victim must visit or load content that the Safe Browsing component processes. No public exploit code has been identified at time of analysis and EPSS is low (0.14%, 4th percentile), but a browser memory-corruption bug with high C/I/A impact warrants prompt patching; Mozilla fixed it in Firefox 156 and Firefox ESR 153.3.
Sandbox escape in Mozilla Firefox on Windows allows attacker-supplied web content to break out of the content-process sandbox through the browser's 'Widget: Win32' native window-handling code, stemming from incorrect boundary conditions that produce an out-of-bounds memory condition. It affects Firefox versions before 156 and Firefox ESR versions before 153.3 running on Windows, and although the vendor rates it 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H), our independent reassessment applies AC:H because a successful escape also requires chaining this flaw with a separate content-process memory-corruption bug to first achieve code execution inside the renderer - the escape alone grants no execution. Exploitation is unauthenticated at the network vector but requires the victim to load attacker-controlled content (UI:R), no public exploit code has been identified at time of analysis, and the EPSS score is low at 0.14% (4th percentile).
A sandbox escape in Firefox's Profile Backup component lets code that is already running inside the browser's sandboxed content process break out to browser and host privilege, but it is not a standalone remote compromise: the authoritative assessment rates it CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:C/C:H/I:H/A:H, meaning an attacker must first hold an in-sandbox foothold (typically a separate content-process exploit) and typically requires user interaction. Mozilla's vendor advisory scores it 9.8 with a PR:N/UI:N/S:U vector, and the flaw is fixed in Firefox 156. EPSS is low at 0.14% (4th percentile) and no public exploit identified at time of analysis; there is no CISA KEV entry, so this reads as a second-stage chain link rather than a standalone exploit.
Sandbox escape in Mozilla Firefox on Windows stems from an incorrect boundary condition (CWE-119) in the Win32 Widget component, allowing an attacker who already has code execution inside a content/child sandbox to escape and gain high-impact code execution, data access, and availability impact. It affects Firefox before 156 and Firefox ESR before 153.3, with patched builds available as Firefox 156 and Firefox ESR 153.3. No public exploit or active exploitation is identified, and EPSS is low at 0.14% (4th percentile), but the CVSS score is 8.8 and exploitation is chain-dependent, typically requiring a separate content-process memory-safety bug to reach this escape stage.
Sandbox escape in Mozilla Firefox on Windows, in the Widget: Win32 component, lets an attacker who already holds low-privileged code execution inside a Firefox content/child process corrupt memory via an incorrect boundary condition (CWE-119) and break out of the browser sandbox into full user-level code execution. The flaw is Windows-only - the Win32 widget code path does not exist on macOS or Linux - and patched builds (Firefox 156 and Firefox ESR 153.3) are not exploitable; there is no public exploit identified at time of analysis and EPSS is low at 0.14% (4th percentile). Because this is a second-stage sandbox-escape primitive rather than a standalone remote bug, it is not independently exploitable against a default install without a preceding content-process compromise.
Memory corruption in Mozilla Firefox's Process Sandboxing component, caused by incorrect boundary conditions, can be triggered when a victim browses attacker-controlled web content on any Firefox version prior to 156. Although the input feed carries a nominal CVSS of 9.8 and a CWE-119 (buffer bounds) classification, our assessment reduces the practical severity to AV:N/AC:H/PR:N/UI:R because successful exploitation requires the user to render malicious content and then reach and corrupt the targeted sandbox code path, which realistically implies chaining with a content-process compromise. No public exploit code has been identified and the flaw is not in CISA KEV, with an EPSS score of just 0.14% (4th percentile), indicating low near-term exploitation likelihood despite the high theoretical impact. The issue is unauthenticated from a network standpoint (PR:N) but is not zero-interaction.
Improper boundary conditions in the DOM Editor component of Mozilla Firefox can corrupt memory when a user renders crafted web content, allowing an attacker to potentially execute code inside the browser's content process. All Firefox builds before 156 and Firefox ESR builds before 153.3 are affected; the CVSS vector sets PR:N, so unauthenticated remote delivery is possible, but the assessed exploitation path requires the victim to load attacker-controlled page content (UI:R) and reliable exploitation of a memory-corruption bug typically needs heap grooming and a sandbox escape to affect the host. No public exploit code has been identified at time of analysis and EPSS is low at 0.14% (4th percentile), so despite the 9.3 base score the practical real-world priority is moderate, driven mainly by the browser's ubiquity and the fact that the fix is already shipped.
Enterprise policy enforcement bypass in Mozilla Firefox affects all builds prior to 156 and Firefox ESR prior to 153.3, letting remote, unauthenticated attackers circumvent restrictions that administrators have locked down through the browser's Enterprise Policies component. Mozilla's advisory carries a CVSS 9.1 base score, while an independent re-assessment lowers the practical severity by raising attack complexity (AC:H) and scoping real-world impact to managed deployments where a policy is actually relied upon as a security control - a default consumer install with no policies configured has nothing to bypass. No public exploit code has been identified at time of analysis, there is no confirmed active exploitation (CISA KEV), and EPSS is only 0.15% (5th percentile); Mozilla has not disclosed the specific trigger mechanism, so precise preconditions remain unclear.
Content spoofing caused by an invalid-pointer (null-pointer dereference) condition in Mozilla Firefox's Graphics rendering component affects Firefox versions prior to 156, allowing a remote, unauthenticated attacker to falsify or distort what a victim sees when the browser renders attacker-supplied web or graphics content. Mozilla shipped the fix in Firefox 156 (advisories MFSA2026-90 and MFSA2026-94, Bugzilla 2061393); there is no public exploit identified at time of analysis and no CISA KEV listing, and EPSS is low at roughly 0.14% (4th percentile). The raw CVSS 9.1 score overstates practical risk - our independent assessment lowers it to AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:L because exploitation requires the victim to navigate to and render malicious content, and the realistic outcome is spoofing plus a limited crash/denial-of-service condition rather than full integrity or availability loss.
A race condition in Mozilla Firefox's XPConnect component allows an attacker who has already compromised execution inside the content/renderer sandbox to escape that boundary and reach higher-privileged browser code. Only Firefox builds prior to version 156 are affected; the flaw was fixed upstream and published in Mozilla's MFSA 2026-90/MFSA 2026-94 advisories. Exploitation is not a standalone remote code-execution path but a chained, timing-dependent step requiring a separate renderer compromise first, and no public exploit has been identified at time of analysis, with an EPSS score of just 0.14% (4th percentile) indicating low predicted real-world activity.
Sandbox escape in Mozilla Firefox's Widget:Win32 component on Windows allows code that is already running inside the browser's content/renderer sandbox to break out and execute on the host with the user's privileges, escalating a limited renderer compromise into full desktop compromise. It does not stand alone: an attacker must first obtain code execution in the content process via a separate bug, then trigger the boundary-condition memory corruption, and a victim must load attacker-controlled web content (CVSS 9.0, PR:L, UI:R, S:C). Vendor fixes are Firefox 156 and Firefox ESR 153.3; EPSS is only 0.15% (5th percentile) and no public exploit code or confirmed active exploitation has been identified, so the high base score should be weighed against the multi-stage, Windows-only prerequisites.
Sandbox escape in Mozilla Firefox (all versions before 156) and Firefox ESR (before 153.3) allows an attacker who gets malicious web content processed by the browser's WebRTC stack to break out of the sandboxed content process and run code with the privileges of the parent/broker process, yielding high confidentiality, integrity and availability impact. Exploitation is not trivial: the victim must load attacker-controlled content and, because the assessed vector is CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H, the bug realistically functions as a chain component on top of a renderer-level compromise rather than a single-shot webpage exploit. There is no public exploit identified at time of analysis, CISA KEV does not list it, and EPSS is only 0.15% (5th percentile), so the practical near-term risk sits below the 9.6 base score headline; Mozilla shipped fixes in Firefox 156 and Firefox ESR 153.3.
Information disclosure in Mozilla Firefox's Networking: HTTP component affects Firefox builds prior to 156 and Firefox ESR builds prior to 153.3, allowing a remote, unauthenticated attacker who can influence HTTP traffic a victim's browser processes to expose high-confidentiality data (CVSS 3.1 base 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N). Impact is confidentiality-only - no integrity or availability loss is assessed - and the flaw is consistent with CWE-200 (Exposure of Sensitive Information). At time of analysis there is no public exploit identified and no CISA KEV listing; EPSS is 0.15% (5th percentile), indicating low modeled near-term exploitation likelihood, though the unauthenticated, low-complexity profile keeps it relevant for unpatched consumer and enterprise Firefox fleets.
Mozilla Firefox builds before 156 (and Firefox ESR builds before 153.3) can be induced to bypass an existing browser security mitigation through attacker-influenced web content that exercises the DOM: Networking component, yielding high confidentiality and integrity impact without granting outright code execution. The vendor rates this 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), but our independent assessment adjusts the vector to UI:R, since the victim must actually load the malicious page for the bypass to trigger - a normal precondition for a client-side browser flaw. There is no public exploit identified at time of analysis and EPSS is low (0.16%, 6th percentile), so near-term real-world risk is limited despite the critical score.
A mitigation bypass in Firefox's Remote Settings Client - the signed channel the browser uses to receive configuration, blocklist and policy updates - was fixed in Firefox 156 and Firefox ESR 153.3. The vendor's CVSS 3.1 vector (9.1, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N) rates it as an unauthenticated, network-reachable high-integrity/high-confidentiality issue, but that flat 9.1 should be read with caution: our independent assessment re-scores it at CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N, because a bypass of the Remote Settings mitigation realistically depends on the attacker being able to tamper with settings content or its delivery channel (a man-in-the-middle position or a spoofed/compromised settings source) rather than a zero-context hit against an idle browser. No public exploit code or confirmed active exploitation was identified at time of analysis, and EPSS is low at 0.16% (6th percentile), which is consistent with a terse, undisclosed-disparate advisory rather than a mass-exploited bug. All users on Firefox before 156 or Firefox ESR before 153.3 are affected.
Incorrect boundary conditions in the Firefox DOM Animation component (CWE-119) allow remote attackers to corrupt memory in the browser process of any default Firefox build prior to version 156, with Mozilla scoring the flaw CVSS 9.8 (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H) - the profile of a potential remote code execution issue. Exploitation requires the victim to load attacker-controlled web content (or attacker-supplied markup such as malvertising) that exercises the affected animation code path, so practical delivery is gated by victim interaction even though the vendor vector lists UI:N; our independent assessment therefore scores it UI:R while keeping confidentiality, integrity, and availability impact High. There is no KEV listing and no public exploit code identified at time of analysis, and EPSS is only 0.15% (5th percentile), indicating low observed exploitation likelihood measured against the high theoretical severity. No authentication or special target configuration is needed - any unpatched Firefox install is exposed.
Memory corruption in Mozilla Firefox's HTTP networking component (CWE-119) allows an attacker who controls the content of an HTTP response - for example via a malicious or compromised web server, or by man-in-the-middle position - to corrupt Firefox's memory and potentially achieve code execution in the browser process on a victim running Firefox before 156. The issue is a client-side networking-stack flaw rather than a remotely reachable server service: exploitation requires the user to initiate and complete the malicious HTTP exchange, which is why the independent assessment scores it CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H while the vendor/NVD vector lists UI:N at 9.8. No public exploit code or active exploitation has been identified at time of analysis (EPSS 0.15%, 5th percentile), and the flaw is closed by the regular Firefox 156 update, which sharply limits the exposure window.
Mozilla Firefox versions prior to 156 (and Firefox ESR prior to 153.3) contain a buffer-boundary flaw in the Graphics component that can be leveraged to escape the browser's content-process sandbox and reach the host, explaining the vendor's critical 9.6 score (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H) - the scope change reflects a crossing from the constrained renderer process into the host, with full confidentiality, integrity and availability impact. Exploitation is not standalone: it requires a victim to load attacker-controlled web content (UI:R is mandatory) and, in practice, must be chained after an attacker has already achieved code execution inside the Firefox content process, which is why the independent assessment raises attack complexity to AC:H while leaving the 9.6-level impact intact. There is no KEV listing and no public exploit identified at time of analysis, and EPSS is low at 0.15% (5th percentile), but the vendor-released fixes - Firefox 156 and Firefox ESR 153.3 - should be applied promptly given the sandbox-escape nature of the flaw.
Improper origin validation in Mozilla Firefox's Graphics component before version 156 can allow attacker-influenced web content, once rendered by a victim, to break site-isolation boundaries and potentially disclose or corrupt data across origins. Affected users are those running Firefox versions prior to 156; exploitation requires the victim to browse to malicious or compromised web content, so it is not a no-interaction mass network exploit despite the vendor's critical 9.1 score, and the independent assessment rates it lower with high attack complexity and required user interaction. No public exploit code or active exploitation has been identified, and EPSS is 0.15% (5th percentile), indicating low predicted exploitation activity at time of analysis.
Sandbox escape in Mozilla Firefox's Graphics component, rooted in an invalid-pointer memory-safety flaw (CWE-119), allows attacker-controlled content loaded by a victim to cross the browser's process-sandbox boundary and reach the privileges of the parent/broker process. Default configurations of Firefox before 156 and Firefox ESR before 140.16 / 153.3 are affected; the vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6) indicates no authentication or privileges are required, but the victim must load attacker-controlled content (UI:R). No public exploit code has been identified at time of analysis and EPSS is low (0.16%, 5th percentile); the real-world bar is further raised because a sandbox escape of this class generally has to be chained with a separate content-process memory-corruption primitive to be exploited end-to-end.
A mitigation bypass in Mozilla Firefox's Remote Settings Client component allows a remote, unauthenticated attacker to defeat a browser security control when a victim interacts with attacker-influenced content, potentially leading to high confidentiality and integrity impact. All Firefox builds prior to 156 and ESR branches prior to 115.41, 140.16, and 153.3 are affected; the issue was fixed in those releases per Mozilla advisories mfsa2026-90 through mfsa2026-96. Exploitation requires user interaction (UI:R) and the vulnerability is characterized as a mitigation bypass that generally must be chained with another primitive to produce direct impact; no public exploit code or confirmed active exploitation has been identified at time of analysis, and the EPSS score is low at 0.16% (6th percentile), so this should be treated as a moderate-priority patch item rather than an emergency.
Trust-boundary spoofing in the proxy-addr Node.js module (versions 1.1.0 through 2.0.7), the library that backs Express req.ip and req.ips, lets unauthenticated clients forge their apparent source address. When an operator declares a trusted-proxy subnet in IPv4-mapped IPv6 notation with an IPv4-sized prefix (e.g. ::ffff:10.0.0.0/8 rather than the correct /104), proxy-addr silently accepts it but trusts every IPv4 address on the internet, so the direct socket peer becomes trusted at hop 0 and any client can set an arbitrary X-Forwarded-For header. This is a fail-open regression introduced in 1.1.0, fixed in 2.0.8; no public exploit identified at time of analysis, and it is not in CISA KEV.
Stack-based buffer overflow in SIPp through 3.7.7 allows a malicious SIP server to crash the client process by sending a crafted 401 or 407 authentication challenge containing an oversized algorithm parameter. The flaw originates in createAuthHeader() at src/auth.cpp:183-192, where the original code uses strncpy bounded by end-start (an attacker-controlled length derived from the algorithm field) rather than the fixed size of the stack-allocated algo buffer. No public exploit has been identified at time of analysis, but upstream fix code is publicly available via GitHub PR #880.
A lockless read race in the Linux kernel's ftrace ring-buffer subsystem allows a local attacker to corrupt kernel memory by concurrently triggering a subbuf resize while a reader accesses stale size metadata. Affected versions span from the commit introducing dynamic subbuf resizing (~Linux 6.8) through current stable branches. The CVSS vector rates confidentiality, integrity, and availability all high, reflecting that a successful race can yield kernel memory corruption; no public exploit or CISA KEV listing exists, and EPSS sits at a low 0.16%.
IRQ resource leak and potential use-after-free in the Linux kernel's NXP PIT (Periodic Interrupt Timer) clocksource driver allows a kernel crash if an interrupt fires after error-path cleanup. The driver's pit_clockevent_init() error path skips free_irq() when cpuhp_setup_state() fails after request_irq() has already succeeded, then proceeds to kfree(pit), leaving the registered IRQ handler's dev_id pointing to freed slab memory. If the IRQ subsequently fires, the handler dereferences the freed pointer, constituting a use-after-free. No public exploit exists and EPSS is 0.15% (5th percentile), consistent with a race-condition bug on niche embedded hardware.
Overlayfs in the Linux kernel exposes an unprivileged local DoS - and a theoretical privilege-escalation path - through a double `end_creating()` call in `ovl_create_real()` when a casefold consistency mismatch is detected during directory creation. The double call unlocks the parent directory's `i_rwsem` twice and calls `dput()` twice on the same dentry: the spurious unlock wedges every subsequent creation under that parent indefinitely, and the spurious `dput()` creates a reference-count imbalance that could underpin a use-after-free chain. The flaw is reachable without root in a user namespace on most modern Linux distributions. No public exploit has been identified at time of analysis and EPSS is 0.18%.
AppArmor's begin_current_label_crit_section() in the Linux kernel contains a use-after-free of struct cred that can be triggered on systems with active AppArmor profiles when those profiles are updated or disabled mid-syscall. The flaw arises from synchronous credential replacement inside LSM hooks: the override_creds() guard in aa_replace_current_label() fails to detect when overridden and objective credentials are the same object, causing two reference drops that free the struct cred while task_struct still holds a pointer to it. No public exploit or CISA KEV listing exists; EPSS is 0.16% at the 5th percentile, consistent with low immediate exploitation probability despite a theoretically high UAF impact.
Out-of-bounds write in the Linux kernel AppArmor LSM label parser allows any local user on an AppArmor-loaded system to corrupt kernel heap or stack memory by writing a crafted multi-component label string to /proc/self/attr/apparmor/current or to the world-writable (mode 0666) securityfs .access file, the latter path applying no privilege check whatsoever. The bug is a deterministic off-by-one: aa_vec_unique() writes a NULL terminator at vec[n] when no duplicates are found, but vec_setup() and DEFINE_VEC() allocate only n slots, so the write lands one entry past the end of either the local stack array or the kzalloc'd buffer. No public exploit has been identified at time of analysis; vendor-released patches are available in stable branches 6.12.109, 6.18.50, 7.2.4, and 7.3-rc1.
Memory corruption in the Linux kernel's swap/hibernation subsystem can produce silent data corruption and crashes in unrelated userspace processes during hibernation image preparation. swap_free_hibernation_slot() unconditionally calls __swap_cluster_free_entries() without checking whether a folio already occupies the slot in the swap cache - a state reachable when cluster readahead speculatively faults in pages over the hibernation window. The freed slot is returned to the allocator while its folio retains the stale swap offset in folio->swap; when page reclaim subsequently flushes that folio using the stale offset, it silently overwrites a swap table entry now belonging to a different process, corrupting arbitrary in-flight userspace data. No public exploit has been identified at time of analysis.