Memory Corruption

Heap out-of-bounds write in OpenImageIO's Cineon image reader (cineon.imageio) allows memory corruption when the library decodes a crafted .cin file that declares an unsupported per-channel bit depth, such as 26. Affected deployments are those running OpenImageIO versions prior to 3.0.21.0, 3.1.16.0, or 3.2.0.3-beta1, and exploitation requires that a victim or an automated pipeline actually open and parse the attacker-supplied Cineon file (CVSS vector PR:N with UI:R). The flaw is rated High (CVSS 3.1 base 8.3, AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:H) and no public exploit code has been identified at time of analysis; vendor-released fixes are available in 3.0.21.0, 3.1.16.0, and 3.2.0.3-beta1.

Heap out-of-bounds write in OpenImageIO's Maya IFF decoder (src/iff.imageio/iffinput.cpp) lets a crafted .iff file corrupt heap memory in any application built against affected releases prior to 3.0.21.0, 3.1.16.0, or 3.2.0.3-beta1. The trigger is a zbuffer-only tiled IFF whose Z-depth data is exposed through a 16-bit public ImageSpec while the decoder keeps a 32-bit internal pixel size, combined with a failure path that leaves m_buf partially populated so a later read_native_tile() copies half-initialized data into an undersized caller buffer sized by m_header.pixel_bytes() instead of ImageSpec::tile_bytes(true). The CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, 7.8) confirms no privileges are required but the attack is local and depends on a victim or pipeline opening the malicious image; no public exploit code or active exploitation has been identified at time of analysis, and risk is highest in automated render/asset pipelines that batch-process untrusted IFF files without human review.

Malformed compressed data delivered over an IBM MQ channel that has compression enabled can trigger an out-of-bounds heap write, allowing a remote attacker to crash the queue manager and, potentially, execute arbitrary code in the MQ process. The issue affects IBM MQ 9.1.0.0-9.1.0.37 LTS, 9.2.0.0-9.2.0.43 LTS, 9.3.0.0-9.3.0.41 LTS / up to 9.3.5.1 CD, 9.4.0.0-9.4.0.25 LTS / up to 9.4.5.1 CD, and 10.0.0.0, with the CVSS base of 9.8 reflecting a network-reachable, unauthenticated worst case, though our assessed vector raises attack complexity to High (AC:H) because the channel must be explicitly configured with compression and reachable by the attacker. Denial of service is the readily achievable outcome, while reliable code execution requires defeating the process's memory protections; no public exploit code has been identified at time of analysis, SSVC rates exploitation as none, and EPSS is low at 0.37% (31st percentile).

Privileged users inside a QEMU guest running on the Q35 machine type with the KVM accelerator can abuse the VAPIC setup hypercall (hw/i386/vapic.c) to break SMM isolation, because the code fails to verify that a writable RAM alias stays inside the option ROM window. By repositioning that alias over chipset-locked SMRAM, an attacker with root-equivalent guest access defeats D_LCK protection and injects code into System Management Mode memory, which QEMU scores as a scope-changing, total-impact compromise (CVSS 8.2). Exploitation is local to the guest with high privileges required (AV:L, PR:H, S:C), publicly available exploit code exists according to the CISA SSVC assessment, but there is no confirmed active exploitation and EPSS is low at 0.20% (10th percentile).

Pre-authentication denial of service in the Moxa TN-4500B series Ethernet switches: improper validation of the username field length during Web login processing lets a remote, unauthenticated attacker send an overly long username that overflows a buffer and crashes the authentication process. No credentials (PR:N) and no user interaction (UI:N) are required, so any TN-4500B switch whose HTTP/HTTPS management login is reachable from the attacker's network is at risk, and the vendor-supplied CVSS 4.0 vector scores it 8.8 with availability impact rated High. The exploit's practical constraint is exposure rather than complexity - switches with web management confined to an isolated OT/management VLAN are not reachable and therefore not exploitable. Realized impact is limited to a crash-driven loss of availability; no data disclosure or confirmed code execution has been demonstrated, and no public exploit code was identified at time of analysis.

Memory corruption in snappy-java through 1.1.10.8 lets an attacker terminate the JVM hosting the library: the Snappy.compress(ByteBuffer, ByteBuffer) overload writes past the end of the destination buffer when incompressible input exceeds its remaining capacity, corrupting off-heap memory. Exposure is limited to Java applications that call that specific ByteBuffer overload with attacker-influenceable, low-compressibility data and a destination buffer that was not sized using Snappy.maxCompressedLength(); code using the byte[]-based compress API or compressing only trusted data is not exposed. The flaw is reachable by unauthenticated remote attackers (CVSS 4.0 vector reports PR:N, and the independent assessment agrees with AV:N/PR:N/UI:N), but the impact is availability-only - no confidentiality or integrity loss and no code execution - and no public exploit code or confirmed active exploitation was identified at time of analysis.

An out-of-bounds heap write in Imager::File::PNG 1.003 - and in the identical reader bundled with Imager releases before 1.035 - allows a crafted 8-bit, non-palette PNG carrying a tRNS transparency chunk to overflow the row buffer during decoding, corrupting the heap and crashing the process. The bug is reachable unauthenticated by any application that hands attacker-supplied image data to Imager->read() or the PNG reader, but the demonstrated and assessed impact is denial of service through a process crash, not confirmed remote code execution. Exploitation requires that the host application actually decode untrusted PNGs; the issue is not listed in CISA KEV, no public exploit code has been identified at time of analysis, and EPSS is low (0.18%, roughly the 7th percentile), though a vendor-released patch exists in Imager::File::PNG 1.004.

Unauthenticated remote attackers can crash or corrupt the Hamlib rigctld daemon on TCP port 4532 by sending a crafted send_raw command with a short payload terminated by CR, exploiting a one-byte out-of-bounds NUL write on the stack and an oversized memory copy that returns up to 198 bytes of uninitialized stack data. Affecting Hamlib versions before 4.7.2 under the default no-password configuration, the issue is fixed in 4.7.2. No public exploit code has been identified at time of analysis, and realistic exposure is limited to deployments that deliberately expose rigctld beyond localhost.

Use-after-free code execution in PDFium, Chrome's bundled PDF rendering engine, allows a remote attacker who lures a victim into opening a crafted HTML page to run arbitrary code inside Chrome's renderer sandbox on any build prior to 153.0.8010.52. The bug is network-reachable and low-complexity with no authentication required, but it does require user interaction (the victim must navigate to the attacker-supplied page), and because the CVSS scope is unchanged (S:U) the compromise is contained within the renderer - full system takeover would require chaining a separate sandbox-escape flaw. Google has released a fixed build and there is no public exploit identified at time of analysis, though the CVSS 8.8 score and memory-corruption tag make timely patching advisable.

Type confusion in the V8 JavaScript engine of Google Chrome prior to 153.0.8010.52 allows remote, unauthenticated attackers to execute arbitrary code inside the renderer sandbox when a victim is socially engineered into loading a crafted HTML page (CVSS 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H). Exploitation is not automatic: it requires user interaction, and because the resulting code execution is confined to the renderer sandbox, turning it into host-level compromise would require chaining a separate sandbox-escape vulnerability. There is no public exploit code identified at time of analysis and the flaw is not listed in CISA KEV, but a vendor patch (Chrome 153.0.8010.52) is available and this is a patch-now item for a ubiquitous product.

Use-after-free in the Dawn (WebGPU) component of Google Chrome on Android before 153.0.8010.52 allows a remote, unauthenticated attacker to potentially execute arbitrary code outside the browser sandbox when a victim renders a crafted HTML page. Exploitation requires the user to load attacker-controlled content (CVSS 9.6, AV:N/AC:L/PR:N/UI:R), and Google rates the bug Chromium security severity Critical; the only affected configuration is Chrome on Android below the fixed 153.0.8010.52 build, and devices already updated are not exposed. There is no CISA KEV listing and no public exploit identified at time of analysis, so the practical risk is driven by the size of the unpatched Android install base rather than by observed attacks.

Use-after-free in Google Chrome's Extensions component allows a remote attacker to execute arbitrary code outside the browser sandbox on any desktop build prior to 153.0.8010.52, provided the victim loads a crafted, attacker-controlled extension. The flaw carries a 9.6 CVSS score (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H), meaning no prior authentication to the target is needed, but the attacker must still persuade the user to install or load a malicious extension, which is the real-world limiting factor; the sandbox-scope change (S:C) reflects code execution escaping Chrome's renderer/extensions sandbox. A vendor patch shipping in 153.0.8010.52 is available, and no public exploit code or confirmed active exploitation has been identified at time of analysis. Because Chrome auto-updates aggressively, the exposed population shrinks quickly once the fixed build propagates.

Heap-based buffer overflow in the TLS transport layer of the MongoDB C Driver on Windows TLS-backend builds allows the endpoint a client connects to - or an attacker able to impersonate, redirect, or man-in-the-middle that connection - to write attacker-supplied data outside the bounds of a heap allocation while the driver processes incoming encrypted traffic, causing memory corruption, disclosure of adjacent heap memory, or termination of the client process. The flaw is reachable before any application-level authentication completes, so no credentials or user interaction are needed (CVSS PR:N/UI:N), and the vendor rates it 9.2 under CVSS 4.0; however, our assessed CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) reflects the real gating factors - this is a client-side defect that only fires when the driver connects to an attacker-controlled endpoint or when the attacker can intercept or redirect the connection (AC:H, AT:P), and only in builds compiled against the Windows platform TLS backend. All C Driver releases in the affected ranges (1.24.0 through the 2.4.0 series per ENISA EUVD) are in scope, tracked as CDRIVER-6417; no public exploit code was identified at time of analysis.

Memory corruption in BlueKitchen BTstack through 1.8.2 allows a bonded Bluetooth peer to overflow the fixed AVDTP stream-endpoint table during A2DP SEP discovery, corrupting adjacent static objects and crashing the stack or severing event delivery on the host device. The flaw is reachable only by an authenticated, already-paired peer that is within Bluetooth radio range and is participating in A2DP stream-endpoint discovery (assessed CVSS:3.1/AV:A/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:H) - unpaired or purely network-remote attackers cannot trigger it, and no user interaction is required. Confidentiality is not affected; the practical impact is low integrity and high availability loss, making this a moderate-priority memory-safety availability bug. No public exploit code and no confirmed actively exploited status were identified at time of analysis, and a vendor patch is available.

Local privilege escalation in Qualcomm Snapdragon platforms can occur when a low-privileged local process supplies an insufficiently sized user buffer to an escape handling driver flow, producing an out-of-bounds write (CWE-787). The issue is rated 7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), so an attacker who already has a foothold on the device as a low-privileged user could corrupt memory and potentially achieve code execution or elevation; authentication requirements are local low privileges per the vector, and no user interaction is required. No public exploit identified at time of analysis, and the assessed risk is a genuine local privilege-escalation issue that is not a drop-everything emergency; Qualcomm's September 2026 security bulletin is the primary advisory, though exact affected chipsets and patched versions are not enumerated in the provided data.

Local privilege escalation on Qualcomm Snapdragon devices is possible via an out-of-bounds write (CWE-787) in data-copy operations that fail to validate large offset and length values. An attacker with low privileges already executing code on the device-such as an unprivileged application-can trigger memory corruption to achieve high confidentiality, integrity, and availability impact. No public exploit code or confirmed active exploitation has been identified at time of analysis; the vendor has published a security bulletin (September 2026) but exact patched versions are not enumerated in the available CPE data.

Memory corruption in the Qualcomm Snapdragon decode-statistics processing path allows a locally present, low-privilege attacker - typically a malicious or compromised app that already runs on the device - to trigger an out-of-bounds write by supplying an offset that is not validated against the target structure's size, potentially achieving code execution with high confidentiality and integrity impact (CVSS 7.8, AV:L/PR:L/UI:N). Exploitation is bounded: it requires an existing local foothold, targets only the Snapdragon SKUs and firmware/driver builds that embed the vulnerable routine, and reliable escalation depends on memory-layout grooming. No public exploit identified at time of analysis, and Qualcomm has published a fix through its September 2026 security bulletin, so this is a legitimate but bounded patching priority rather than an urgent remote or pre-auth risk.

Out-of-bounds memory writes in LightGBM through 4.7.0 can be triggered when a text-format model file containing invalid child/split node references is loaded and SHAP feature-contribution prediction (pred_contrib) is subsequently run, letting the attacker control where data is written inside the leaf_depth_ buffer. The flaw is classified CWE-787 (out-of-bounds write) with a high impact on confidentiality, integrity and availability (CVSS 4.0 base 8.5; independently assessed as CVSS 3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), and exploitation is not remote: per the CVSS vector the attack is local (AV:L) and requires user interaction, meaning the victim must open a malicious model and execute the SHAP prediction path. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and environments that only load trusted, self-generated models or that never compute feature contributions are not exposed.

Out-of-bounds write flaws in HPLIP (HP Linux Imaging and Printing Software) can corrupt memory when a user processes attacker-influenced input such as a crafted print job, a malicious device or network response, or a handled file, with the affected product confirmed by HP and documented in advisory HPSBPI04151. No authentication is required to reach the vulnerable components, but exploitation depends on mandatory user interaction and on hosts that actually have HPLIP installed and in active printing or scanning use. Worst-case impact spans remote code execution, privilege escalation, denial of service, information disclosure, and unauthorized file modification; no public exploit code or confirmed active exploitation was identified at time of analysis.

Denial of service in ISC BIND 9 allows remote, unauthenticated attackers to terminate the named resolver process when it processes a specifically malformed answer that interacts with the DNS64 synthesis feature. Only resolvers explicitly configured with the dns64 option are affected - a non-default, opt-in capability - but for those systems any client of the resolver loses name resolution when named exits. The bug is a use-after-free (CWE-416) reachable from the network with low complexity (CVSS 3.1 base 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), affecting BIND 9.11.0 through 9.18.50, 9.20.0 through 9.20.27, 9.21.0 through 9.21.25, and the corresponding -S1 subscription builds. No public exploit code has been identified at time of analysis and there is no indication of confirmed active exploitation; vendor patches are available as BIND 9.20.29 and 9.21.26.

An out-of-bounds write in Arista VeloCloud Edge and VeloCloud Gateway affects the VCMP tunnel protocol when it processes tunneled IP fragments, causing the affected process to crash and restart and briefly disrupting traffic on the affected SD-WAN node. Exploitation requires the attacker to already be an authenticated overlay neighbor with an established VCMP peer relationship to the target (assessed CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:N/A:H) - internet hosts that are unauthenticated and cannot form an overlay peer relationship cannot reach the vulnerable logic. No public exploit code has been identified at time of analysis; the impact is bounded to a temporary availability loss, with no code execution or data compromise demonstrated.

Memory corruption via use-after-free in Microsoft Edge (Chromium-based) lets a remote attacker run arbitrary code at elevated privilege in the browser and ultimately on the host, provided the victim opens attacker-controlled content. Microsoft scores it 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), so no credentials are needed but a single user visit is — a classic one-click browser exploitation pattern rather than a zero-click worm. The intelligence feed contains no EPSS score, no CISA KEV listing, and no public exploit reference, so at time of analysis this is a high-severity but not yet observed-exploited issue.

Use-after-free in the Workers component of Google Chrome allows an unauthenticated remote attacker to execute arbitrary code outside the browser sandbox when a victim renders a crafted HTML page in any build prior to 153.0.8010.47, including default desktop installations on Windows, macOS and Linux. The only prerequisite is user interaction - opening or being lured to the malicious page (UI:R) - with no special configuration or prior access needed, and because the flaw yields a scope change the compromise extends to the host rather than remaining confined to the renderer. Google rates the issue Critical and has shipped a fixed build; exploitation is not currently observed, CISA's SSVC assessment classifies the flaw as not automatable, and no public exploit identified at time of analysis, though the combination of network reachability, low attack complexity and total technical impact makes it a genuine high-priority vulnerability for prompt patching.

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.

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.

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.

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.

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.

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.

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 write in the NXP NFC hardware abstraction layer (phNxpNciHal_ext_process_nfc_init_rsp in phNxpNciHal_ext.cc) lets a local attacker corrupt memory beyond the intended buffer while the HAL processes an NFC initialization response. Affected are Android devices that ship the NXP NFC HAL, which the Android CPE lists without a version bound; the flaw requires no user interaction and, per Google's bulletin wording, no additional execution privileges, so a typical app-level foothold is enough to attempt escalation. There is no CISA KEV listing and no public exploit code reported in the supplied intelligence, so exploitation is assessed as feasible but not yet observed.

An out-of-bounds write in Av1DecodeFrameTag (vp9hwd_headers.cc) in the Android media decoding stack allows crafted AV1/VP9 media content to corrupt memory and potentially achieve remote code execution in the codec process, which runs with elevated system privileges relative to a normal app. Google's Pixel security bulletin dated 2026-09-01 lists the fix, and no user interaction is required, though the provided CVSS vector (PR:L) implies the attacker must already be able to route content into the decoder path. No EPSS score, CISA KEV entry, or public exploit code was supplied with this record, so active exploitation is unconfirmed.

Use-after-free (CWE-416) in the Android kernel allows a remote attacker to escalate privileges to kernel level on affected Pixel and Android devices, with no authentication, no user interaction, and no additional execution privileges required per the CVSS vector. Google rates this 9.8 (AV:N/AC:L/PR:N/UI:N) in its September 2026 Pixel security bulletin, while independent assessment lowers the practical rating to 8.1 (AC:H) because successful exploitation must first reach the vulnerable kernel code path and then defeat Android kernel memory-corruption mitigations such as KASLR, allocator hardening, and CFI. EPSS is only 0.16% (5th percentile) and there is no CISA KEV entry and no public exploit identified at time of analysis, so exploitation is currently considered possible but not observed.

An out-of-bounds write in ReadTileInfo of vp9hwd_headers.cc lets a crafted VP9 bitstream corrupt memory inside Android's VP9 hardware-decoder header parser, which Google rates as remote escalation of privilege with no additional execution privileges and no user interaction required. Affected builds are those tracked under the Google Android CPE and addressed by the Android/Pixel security bulletin dated 2026-09-01. There is no CISA KEV listing and no public exploit code identified at time of analysis, so this is currently a patch-window issue rather than a confirmed in-the-wild campaign.

Let me synthesize. CVE-2026-56920: Android HEVC decoder, firmware header parsing (fw_hevc_dec_header.c), s_decode_vui_param out-of-bounds write, CWE-787, CVSS 8.8 AV:N/AC:L/PR:L/UI:N. Note: "remote code execution with no additional execution privileges needed" — but CVSS says PR:L. Hmm, this is typical Android bulletin wording: "This could lead to remote code execution with no additional execution privileges needed. User interaction is not needed for exploitation." That's media framework / remote. But CVSS says PR:L which contradicts "no additional execution privileges needed". Actually Android media codecs often run in a sandboxed process (mediaserver), so PR:L reflects the sandbox context. There's a conflict worth noting. Product name: Android (Google Android). Or "Android HEVC Decoder"? 1-3 words. "Google Android" or "Android". Let's use "Android Media Framework"? Hmm — the file is fw_hevc_dec_header.c, HEVC decoder header parsing. Probably part of Android's media codec/firmware. I'll say "Android HEVC Decoder" — 3 words. Actually the CPE says google:android. Product name: "Android HEVC Decoder". Hmm, maybe safer: "Google Android". The field says the specific product or service name affected. CPE is google:android, and it's the HEVC decoder in Android firmware for Pixel devices (bulletin is Pixel). I'll go with "Android HEVC Decoder". Summary: Out-of-bounds write in HEVC VUI parameter decoding. Affected: Android devices with affected firmware (Pixel bulletin 2026-09-01). Remote code execution with no user interaction. No KEV, no POC identified. EPSS: not provided. KEV: not stated → assume not in KEV. POC: not provided → "no public exploit identified at time of analysis". Technical context: HEVC/H.265 VUI (Video Usability Information) parameters in SPS/VPS NAL units; s_decode_vui_param in fw_hevc_dec_header.c; firmware-based HEVC decoder in Android; logic error → insufficient bounds validation → OOB write → memory corruption in media codec process. CWE-787.

Local privilege escalation in the Android kernel affecting Google/Pixel devices lets an unprivileged app already running on the device trigger a use-after-free and gain elevated privileges. The flaw stems from improper locking in a kernel code path (CWE-416), and no user interaction is required; however, an attacker must first have local code execution on the device and must win a locking race to corrupt kernel memory, which adds real-world reliability constraints. No public exploit code has been identified at time of analysis, the issue is not listed in CISA KEV, and EPSS is low at 0.11% (2nd percentile), so this is a genuine but not urgent local privilege-escalation issue confined to devices running kernel builds older than the 2026-09-01 patch level.

An out-of-bounds write in the Android kernel, caused by a logic error in multiple code locations, allows code execution in the kernel context with high impact to confidentiality, integrity and availability. The flaw is remotely reachable per the CVSS vector (AV:N/AC:L/PR:L/UI:N) and requires no user interaction, though the vector indicates a low-privileged rather than fully unauthenticated attacker. Google published a fix in the Pixel security bulletin dated 2026-09-01; no public exploit code, EPSS score, or CISA KEV listing was provided in the available intelligence, so active exploitation is not confirmed.

An out-of-bounds write in Android's VP9 hardware decoder (Vp9DecodeFrameTag in vp9hwd_headers.cc) lets a crafted VP9 video stream corrupt memory in the codec context, giving an attacker code execution at the decoder's privilege level. Affected devices are those running Android builds that include the vulnerable VP9 hardware decoding path prior to the September 2026 Pixel security bulletin fix. No public exploit code or CISA KEV entry was identified at time of analysis, so exploitation appears to require a motivated actor with a delivery path for malicious media.

An out-of-bounds write in Google's Android Cellular Modem component allows code execution in the baseband when a crafted message is delivered to the modem, with no user interaction required. Google Pixel devices running Android builds prior to the September 2026 patch level are affected, per the Pixel security bulletin. Rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N, high confidentiality, integrity and availability impact); no public exploit code or CISA KEV entry was identified at time of analysis, so the immediate risk is to targeted radio-layer attacks rather than mass exploitation.

Opening a crafted PDF file in pdfforge PDF Architect can drive an out-of-bounds heap write inside the application's PDF parsing logic, allowing a remote attacker to run arbitrary code in the context of the current process. Exploitation is client-side: the victim must open a malicious document or visit a page that delivers one, so an attacker must first convince the user to interact with the file. The flaw carries a CVSS 3.0 base score of 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, CWE-787) and was reported through Trend Micro's Zero Day Initiative as ZDI-CAN-28673 / ZDI-26-612; no KEV listing or public exploit indicator was present in the supplied intelligence, so no public exploit is identified at time of analysis.

Remote attackers can achieve arbitrary code execution by luring a user into opening a maliciously crafted PDF document in pdfforge PDF Architect, where the PDF parser writes past the end of an allocated buffer (CWE-787). Exploitation requires user interaction - the victim must open the malicious PDF or visit a page that triggers PDF rendering - but needs no prior privileges, and any resulting code runs with the privileges of the PDF Architect process. The flaw was reported through Trend Micro's Zero Day Initiative (ZDI-CAN-29219 / ZDI-26-614); no public exploit code or CISA KEV listing was present in the supplied intelligence, and no vendor fix version is confirmed in the available data.

OriginLab Origin Viewer fails to properly validate user-supplied data while parsing OGWU files, resulting in an out-of-bounds write past the end of an allocated buffer. An attacker who convinces a victim to open a crafted OGWU file (or visit a page that loads one) can corrupt memory and execute arbitrary code in the context of the current process, with CVSS 3.0 base score 7.8 (AV:L/AC:L/PR:N/UI:R). No public exploit code or CISA KEV listing was provided in the intelligence feed, so active exploitation is not confirmed, though the local attack vector and required user interaction mean the primary risk is targeted file-delivery attacks such as email attachments or malicious downloads.

An out-of-bounds heap write in libwebsockets' HTTP/2 HPACK header decoder lets unauthenticated remote attackers corrupt memory on any instance compiled with HTTP/2 support (LWS_WITH_HTTP2) and exposing an HTTP/2 listener. The flaw is a missing bound check in lws_frag_append(), which appends header/path fragments without verifying the write stays within the configured max_http_header_data limit, so a crafted HPACK-encoded request header can overrun the destination buffer and potentially yield code execution in the server process context. No public exploit code or confirmed active exploitation has been identified at time of analysis; the vendor has published an upstream fix commit (824151862f37bc72f46d9a3e01d5b9408d313a0b), and while the raw severity is rated 9.8 (CVSS 3.0), the independent assessment scores it CVSS 3.1 AV:N/AC:H, reflecting that the bounded write must still be shaped by heap layout and platform to become reliable arbitrary code execution rather than a crash. Affected: libwebsockets builds with HTTP/2 enabled; HTTP/1.1-only or non-HTTP/2 builds are not reachable through this path.

A heap buffer overflow in the IBM MQ client (CWE-787) can be triggered when the client processes crafted messages delivered by a malicious or compromised queue manager, or by an attacker positioned to man-in-the-middle the client-to-manager channel. Successful exploitation can crash the client for a denial-of-service condition or, more seriously, allow arbitrary code execution in the context of the client process. IBM has released a vendor fix via support bulletin 7284943; there is no public exploit code or CISA KEV entry identified at time of analysis, and the elevated complexity (the attacker must control the server side of the connection) keeps real-world risk below its 8.1 CVSS base score for most deployments.

An out-of-bounds write in IBM Verify Identity Access (and its predecessor branding, IBM Security Verify Access, plus both container editions) lets an attacker reach the vulnerability over the network without credentials or user interaction, with the vendor CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, base 9.8) indicating full loss of confidentiality, integrity, and availability if the memory-corruption primitive is successfully converted into code execution or a crash. Affected builds are Verify Identity Access 11.0.0 through 11.0.3 Interim Fix 001, Security Verify Access 10.0.0 through 10.0.9.2 Interim Fix 001, and the matching Verify Identity Access Container and Security Verify Access Container releases; patched or newer installs are not affected. No public exploit code has been identified and there is no confirmed active exploitation (CISA KEV does not list this CVE), and EPSS is low at 0.14 percent (4th percentile), so the practical near-term risk is driven by the product's position on the security perimeter rather than by observed attack activity.

Memory corruption in Mozilla Firefox's GTK widget backend (Widget: Gtk) lets attackers who persuade a victim to render attacker-controlled web content trigger a use-after-free, with the assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H vector rating confidentiality, integrity and availability impacts as high. Affected builds are Firefox before 156 and Firefox ESR before 153.3 running on Linux/GTK desktops; exploitation requires user interaction (loading the malicious page) but no authentication, privileges or non-default configuration. Threat signals are currently low: EPSS is 0.14% (4th percentile), the issue is not listed in CISA KEV, and no public exploit identified at time of analysis.

Use-after-free in Mozilla Firefox's Internationalization (i18n) component allows remote attackers to corrupt memory and potentially execute code in the browser's content process when a victim renders attacker-controlled web content in versions before 156 or Firefox ESR before 153.3. Exploitation is unauthenticated (PR:N) but requires the victim to visit or render the malicious page (UI:R), and default cross-platform installations are exposed because the i18n code is always present. No public exploit code has been identified at time of analysis and EPSS is low at 0.14% (4th percentile), but the 8.8 CVSS reflects high confidentiality, integrity and availability impact confined to the content process; full system compromise would require an additional sandbox-escape chain.

Use-after-free in Mozilla Firefox's Graphics component can be triggered when a victim browses attacker-controlled web content, allowing memory corruption that may lead to code execution or sensitive data disclosure in releases before Firefox 156 and Firefox ESR 153.3. Exploitation requires user interaction (UI:R) but no authentication or privileges (PR:N), and the default rendering configuration is exposed, so essentially all unpatched desktop users are potential targets; exploitation status is no public exploit identified at time of analysis, and EPSS is low at 0.14% (4th percentile) despite the high CVSS of 8.8. Mozilla addresses the issue in Firefox 156 and Firefox ESR 153.3 per advisories MFSA2026-90 and MFSA2026-93.

A use-after-free in Mozilla Firefox's Graphics: Text rendering component allows remote attackers to cause memory corruption, potentially leading to code execution or information disclosure, when a user navigates to a malicious webpage. Affected are Firefox versions before 156 and Firefox ESR before 153.3; the flaw is unauthenticated (PR:N) but requires user interaction (UI:R) and is rated high severity (CVSS 8.8). No public exploit code or active exploitation has been identified at time of analysis, and EPSS is 0.14% (4th percentile), indicating low likelihood of exploitation.

Use-after-free in Mozilla Firefox's Windows-only 'Widget: Win32' component allows unauthenticated remote attackers to corrupt memory and potentially achieve code execution or information disclosure by convincing a victim on Firefox before 156 or Firefox ESR before 153.3 to render attacker-controlled web content. Exploitation requires user interaction (UI:R - the victim must load or interact with the crafted page) and is limited to the Windows platform, since the flawed Win32 widget code is Windows-specific. There is no confirmed active exploitation (not listed in CISA KEV) and no public exploit code identified at time of analysis; EPSS is 0.14% (4th percentile), indicating low near-term exploitation likelihood, though the CVSS base of 8.8 reflects high confidentiality, integrity and availability impact if a working exploit is developed.

Use-after-free in Mozilla Firefox's Graphics component allows remote attackers to corrupt memory and potentially achieve code execution in the browser content process, requiring only that a victim view attacker-controlled web content. Unauthenticated remote attack (CVSS:3.1/AV:N/AC:L/PR:N/UI:R) with high confidentiality, integrity and availability impact, carrying a vendor CVSS of 8.8; affected builds are Firefox prior to 156 and Firefox ESR prior to 153.3, which are fixed in those releases. No public exploit code has been identified and EPSS is low at 0.15% (5th percentile), so exploitation is not confirmed as active; risk is concentrated in the mandatory user interaction (page visit) and sandbox constraints on post-corruption impact.

Use-after-free in Mozilla Firefox's JavaScript WebAssembly engine can be triggered by loading attacker-controlled web content in versions before 156, potentially leading to memory corruption and code execution with high confidentiality, integrity, and availability impact. Exploitation requires user interaction (the victim must open a malicious page) but no authentication, and no public exploit or active exploitation is confirmed; the EPSS score is only 0.15% and CISA KEV does not list it, but the 8.8 CVSS and full-impact potential make patching to Firefox 156 a priority.

Use-after-free in Mozilla Firefox's SVG component allows remote attackers to corrupt memory and potentially achieve code execution or sensitive data disclosure when a victim renders attacker-controlled SVG content in an unpatched browser. Only Firefox builds prior to 156 and Firefox ESR prior to 115.41, 140.16, and 153.3 are affected; Mozilla has shipped fixed releases in all of those channels. The attack is unauthenticated per the CVSS vector (PR:N) but requires user interaction (UI:R) - the victim must load a page or view content that renders the malicious SVG - and although EPSS is low (0.16%, 5th percentile) and no public exploit code or confirmed active exploitation was identified at time of analysis, drive-by delivery via malvertising or compromised sites can satisfy that interaction requirement at scale, making this a genuine high-priority browser issue rather than an emergency.

Use-after-free in Firefox's DOM: Core & HTML component lets a remote, unauthenticated attacker corrupt memory when a victim loads attacker-controlled web content, producing high confidentiality, integrity, and availability impact (CVSS 8.8, AV:N/AC:L/PR:N/UI:R). All Firefox builds prior to 156, plus ESR branches prior to 115.41, 140.16, and 153.3, are affected according to the Mozilla security advisories. No public exploit code or confirmed active exploitation was identified at time of analysis (EPSS 0.16%, 5th percentile), and vendor patches are available.

Use-after-free in Mozilla Firefox's DOM Streams component lets unauthenticated remote attackers corrupt browser memory and potentially achieve arbitrary code execution when a victim simply loads attacker-controlled web content in an unpatched build. Any default Firefox installation older than 156, ESR 115.41, ESR 140.16, or ESR 153.3 is affected, and successful weaponization requires the crafted page to drive the DOM Streams code path and win a heap-grooming race after user interaction (navigation) - there is no public exploit code identified at time of analysis and no confirmed active exploitation (EPSS 0.16%, 5th percentile). Confidence in real-world exploitation is therefore low, but the high integrity/confidentiality/availability impact (CVSS 8.8) and the breadth of the Firefox install base make prompt patching worthwhile.

Use-after-free in the Networking component of Mozilla Firefox allows remote, unauthenticated attackers to potentially corrupt memory and achieve code execution or sensitive-data disclosure when a victim renders attacker-controlled web content, affecting Firefox builds prior to 156 and Firefox ESR prior to 140.16 or 153.3. Per the CVSS vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), no credentials are needed but the victim must interact by loading a malicious or compromised page, and the browser must be unpatched. No public exploit code has been identified at time of analysis and the EPSS score is low at 0.16% (5th percentile), so while the 8.8 base score reflects high potential impact, this is a genuine high-severity issue rather than a near-term emergency; practical exploitation would additionally require defeating the content-process sandbox and modern memory mitigations.

Use-after-free in Firefox's DOM: Navigation component allows memory corruption that a remote attacker can trigger by convincing a victim to load attacker-controlled web content in an unpatched build, potentially leading to code execution in the browser's content process. All Firefox builds below 156 are affected, along with the ESR branches below 115.41, 140.16 and 153.3, and the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, score 8.8) reflects unauthenticated remote attack with high confidentiality, integrity and availability impact, gated only by the required user interaction of visiting the crafted page. There is no public exploit identified at time of analysis and EPSS is low (0.16%, 5th percentile), so this should be handled as a standard high-priority browser patch item rather than an emergency, though full compromise would additionally require escaping the content-process sandbox.

A use-after-free in the Firefox SVG rendering component (CWE-416) allows a remote, unauthenticated attacker to corrupt memory and potentially achieve code execution by getting a victim to load a crafted SVG, whether on a web page or embedded in content the browser renders. Every Firefox release prior to 156 and all ESR branches below 115.41, 140.16, and 153.3 are affected; exploitation requires the user to open attacker-controlled content (UI:R), so no authentication or special privileges are needed and default configurations remain vulnerable because SVG rendering is enabled out of the box. Vendor/NVD scoring is 8.8 High (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), EPSS is a low 0.16% (5th percentile), and there is no public exploit identified at time of analysis - the primary constraints on real-world abuse are the required user interaction and the need to bypass the Firefox sandbox and other memory-safety mitigations for a full compromise.

Use-after-free in Mozilla Firefox's XML component can lead to memory corruption and potentially code execution when a user loads crafted content in an unpatched build. The flaw affects Firefox before 156 and Firefox ESR branches before 115.41, 140.16, and 153.3; per the CVSS vector it is remotely reachable without authentication (PR:N) but requires user interaction (UI:R), and the assessed severity is high (CVSS 8.8). No public exploit code was identified at time of analysis, and EPSS is 0.16% (5th percentile), so while the technical impact is serious, real-world urgency is moderate-to-high rather than emergency-tier.

A use-after-free in Firefox's DOM HTML Parser can corrupt memory when the victim loads attacker-controlled HTML, giving an unauthenticated remote attacker a path to code execution or information disclosure inside the browser process. Affected builds are Firefox before 156 and the ESR lines before 115.41, 140.16, and 153.3; exploitation requires only that a user open a malicious page or one serving malicious markup (UI:R, PR:N), not credentials or non-default settings. No public exploit code or in-the-wild activity has been identified, and EPSS is low at 0.16% (5th percentile), so this is a serious client-side bug that is not currently a top-of-queue emergency.

Use-after-free in Mozilla Firefox's JavaScript JIT compiler can lead to memory corruption and potentially remote code execution when an unauthenticated remote attacker convinces a victim to load attacker-controlled JavaScript in a vulnerable Firefox build. Affected versions are Mozilla Firefox releases prior to the fixed Firefox ESR 140.16, with exploitation requiring user interaction (UI:R) and JavaScript enabled, which is the default; the content-process sandbox and site isolation limit standalone impact. EPSS is 0.15% (5th percentile) and no public exploit code was identified at time of analysis, indicating a high-severity but not top-of-queue emergency.

Use-after-free in Mozilla Firefox's Disability Access (accessibility) APIs lets unauthenticated remote attackers corrupt browser memory and potentially achieve arbitrary code execution when a victim loads attacker-controlled web content, with the only significant precondition being that the user must visit or render the crafted page (UI:R). Affected builds are all Firefox versions before 156, Firefox ESR before 140.16, and Firefox ESR 153.3, across platforms covered by the wildcard CPE cpe:2.3:a:mozilla:mozilla:firefox:*:*:*:*:*:*:*:*. No public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV); EPSS is low at 0.16% (5th percentile), but the 8.8 CVSS profile (AV:N/AC:L/PR:N/UI:R, C:H/I:H/A:H) matches a heap-corruption bug that can escalate to code execution in the affected process, so patching should not be deferred.

A logic flaw in Apple macOS Sequoia, Tahoe, and Golden Gate allows an application running on the target Mac to force unexpected system termination, producing a denial-of-service condition that can crash the host and force a reboot. The flaw is fixed in macOS Sequoia 15.8, macOS Tahoe 26.7, and macOS Golden Gate 27 per Apple's advisories, and no public exploit code has been identified at time of analysis. EPSS is very low (0.17%, 6th percentile) and the issue is not listed in CISA KEV, so near-term mass exploitation is unlikely.

Kernel-level use-after-free in Apple's built-in NFS client allows memory corruption when a device connects to an attacker-operated NFS server, affecting iOS/iPadOS, macOS, tvOS, visionOS and watchOS. Exploitation requires the victim to mount or connect to a malicious NFS share (UI:R) but no credentials or privileges on the target device, making this a remote, unauthenticated-against-the-client attack that terminates in kernel memory corruption with high confidentiality, integrity and availability impact. No public exploit code and no CISA KEV listing were identified at time of analysis; EPSS is low at 0.18% (8th percentile), and CISA SSVC rates exploitation as none and automatable as no, though technical impact is total. Apple has released fixes in iOS 26.7/27, iPadOS 26.7/27, macOS Sequoia 15.8, macOS Tahoe 26.7, macOS Golden Gate 27, tvOS 27, visionOS 27 and watchOS 27.

Out-of-bounds write in Apple's file-parsing code affects iOS/iPadOS 27 and earlier, macOS Sequoia 15.8, macOS Tahoe 26.7, macOS Golden Gate 27, tvOS 27, visionOS 27, and watchOS 27, allowing a maliciously crafted file to corrupt memory when processed. Apple addressed the flaw with improved bounds checking across all listed platforms, and CVSS 3.1 scores it 7.8 (AV:L/AC:L/PR:L/UI:N) with high confidentiality, integrity, and availability impact, even though the advisory text itself describes only unexpected app termination. No publicly available exploit code and no CISA KEV listing were identified at time of analysis, and EPSS is 0.18% (7th percentile), indicating low near-term exploitation likelihood.

An out-of-bounds write (CWE-787) in the Apple frameworks that parse 3D model files lets a maliciously crafted model corrupt memory when it is opened on an affected device, potentially giving the attacker code execution in the context of the processing application. The flaw affects iOS/iPadOS before 26.7 and 27, macOS Sequoia before 15.8, macOS Tahoe before 26.7, macOS Golden Gate 27, tvOS before 27, visionOS before 27 and watchOS before 27, and Apple has shipped fixes for all of them. Exploitation likelihood is low: EPSS is 0.17% (7th percentile), CISA SSVC records exploitation as 'none' and the vulnerability is not in KEV — no public exploit code has been identified, and the local attack vector with required user interaction makes mass exploitation unlikely.

Kernel-level out-of-bounds write (CWE-787) in the macOS SMB client stack allows a malicious SMB server to corrupt kernel memory when a target Mac connects to it, potentially yielding kernel code execution or a system crash. All macOS branches are affected: Sequoia before 15.8, Tahoe before 26.7, and macOS Golden Gate versions before 27. Apple has released patches for all three branches; there is no public exploit code identified, no CISA KEV listing, and EPSS is low (0.17%, 6th percentile), so exploitation is currently assessed as targeted/manual rather than widespread.

Kernel memory corruption in the macOS Apple Filing Protocol client (afpfs) can be triggered when a user connects to a malicious AFP server, for example by following an afp:// link or using 'Connect to Server'; the underlying out-of-bounds write is fixed in macOS Sequoia 15.7.8, macOS Sonoma 14.8.8 and macOS Tahoe 26.6. Exploitation is conditional rather than broadly wormable: the attacker is unauthenticated (PR:N) but must still induce the victim to initiate the AFP connection (UI:R), and any host running the patched builds is not affected. No public exploit code or confirmed active exploitation has been identified at time of analysis, and EPSS is low at 0.20% (10th percentile), so this is a genuine but socially mediated client-side kernel flaw rather than a mass-exploitation candidate.

An out-of-bounds write (CWE-787) in Apple's operating system family - iOS/iPadOS, macOS (Sequoia, Tahoe, and Golden Gate), tvOS, visionOS, and watchOS - lets a remote attacker corrupt memory in an affected process, with the confirmed outcome being an application crash and the potential outcome being arbitrary code execution. Exploitation requires no authentication and no user interaction per the CVSS vector (AV:N/PR:N/UI:N), but the independent assessment rates attack complexity as High and the confirmed technical impact as limited to denial of service, because the specific component or content-processing surface that must be reached has not been documented and reliable code execution is unproven. Apple has released fixed builds for every affected platform, and no public exploit code or active exploitation has been identified at time of analysis; EPSS is a modest 0.99% (61st percentile), which is consistent with a patched, non-weaponized memory-safety defect rather than a top-tier emergency.

An out-of-bounds write in Apple macOS lets a malicious or compromised app running as a normal, unprivileged user corrupt memory and escalate to root privileges on the affected system. The flaw is fixed in macOS Golden Gate 27, macOS Tahoe 26.7, and macOS Sequoia 15.8; all earlier releases of those branches remain exposed (CWE-787, CVSS 7.8, AV:L/PR:L/UI:N). No public exploit code has been identified at time of analysis, and CISA's SSVC assessment rates exploitation as 'none' and non-automatable, so practical risk is currently confined to local post-compromise privilege escalation rather than mass remote attacks.

Kernel out-of-bounds write in Apple macOS exFAT volume handling lets a local attacker who can get a maliciously crafted exFAT-formatted volume mounted - such as removable USB media or a disk image - trigger unexpected system termination (kernel panic) or disclose kernel memory. Only macOS builds below macOS Golden Gate 27 are affected; Apple fixed the flaw with improved bounds checking in macOS Golden Gate 27. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV; EPSS is 0.14% (3rd percentile), and the attack is locally gated, requiring physical, removable-media, or delivery-based access rather than network reach.

A use-after-free in Apple macOS kernel memory management allows a locally installed and executed app to escalate to kernel privileges and run arbitrary code with full system control. Affected releases are macOS before Sequoia 15.8, before Tahoe 26.7, and before Golden Gate 27; Apple shipped fixes in all three branches. The flaw is a local privilege escalation (CVSS 7.8, AV:L/PR:L) rather than a remote code execution bug, and there is no public exploit code or CISA KEV listing identified at time of analysis, so real-world exploitation currently depends on an attacker first getting a malicious app onto the target Mac.

Memory corruption in Apple's image-handling code across iOS 27, iPadOS 27, macOS Golden Gate 27 and visionOS 27 allows an attacker to achieve arbitrary code execution when a user processes a maliciously crafted image. Apple removed the vulnerable code entirely in the 27-generation releases, which are the only versions containing the fix; all earlier supported builds remain affected. The flaw is rated 7.3 (CVSS:3.1/AV:L/AC:L/PR:L/UI:R/S:U/C:H/I:H/A:H), meaning exploitation needs local positioning plus some user interaction, and there is no public exploit code or CISA KEV entry identified at time of analysis.

Kernel memory corruption in Apple macOS before Sequoia 15.8, Golden Gate 27, and Tahoe 26.7 can be triggered by a remote attacker, leading to unexpected system termination or kernel memory corruption. Exploitation requires network reachability to an unidentified service with no authentication or user interaction, though the assessed attack complexity is high (AC:H) and the exact trigger surface is unconfirmed. Apple has released patched versions, and no public exploit code has been identified; EPSS is low at 0.29%.

Memory corruption in Apple macOS WebDAV client handling allows code execution when a user connects to an attacker-controlled WebDAV server, affecting macOS versions prior to Sequoia 15.8, Tahoe 26.7, and Golden Gate 27. The flaw is an out-of-bounds write (CWE-787) reachable over the network but gated by user interaction, rated 8.8 by Apple/NVD with an unauthenticated network attack vector. Apple has released fixes in three OS updates, and exploitation is not confirmed — no public exploit code and no CISA KEV listing — while EPSS sits at 0.18% (8th percentile), indicating low predicted mass-exploitation activity; this reads as a credible but targeted risk rather than a wormable event.

An out-of-bounds write in Apple's 3D model handling code causes memory corruption on unpatched iPhones, iPads, Macs, Apple TVs, Apple Vision Pro and Apple Watches when a maliciously crafted 3D model file is processed by the device. The flaw carries a CVSS 3.1 base score of 8.4 (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) and was addressed by Apple with improved bounds checking in iOS/iPadOS 26.7 and 27, macOS Sequoia 15.8, macOS Tahoe 26.7 and macOS Golden Gate 27, plus tvOS 27, visionOS 27 and watchOS 27; no public exploit code has been identified at time of analysis, and EPSS places the likelihood of exploitation in the near term at only 0.17% (7th percentile). Exploitation is not remote-service based: the attacker must first deliver the crafted model to the victim's device and have it parsed, so it is best treated as a genuine but not urgent patching priority rather than an imminent threat.

An out-of-bounds write in Apple's asset-catalog handling lets a maliciously crafted asset catalog trigger memory corruption that terminates the affected process on unpatched Apple operating systems - iOS and iPadOS before 27, macOS before 15.8, 26.7, and 27, and tvOS, visionOS, and watchOS before 27. Exploitation is local rather than network-based (CVSS:3.1/AV:L/AC:L/PR:N/UI:R) and requires the victim to load or open the crafted asset via a downloaded app, bundle, or file, so the realistic outcome is client-side denial of service rather than remote code execution, despite the vendor's 7.8 base score; no public exploit code was identified at time of analysis and EPSS is only 0.20% (10th percentile), indicating low observed exploitation likelihood. Apple has released fixed versions across all affected platforms.

A use-after-free flaw in Apple's kernel affects iOS and iPadOS before 26.7, macOS Sequoia before 15.8, and macOS Golden Gate before 27, allowing a locally running app to corrupt kernel memory or cause unexpected system termination. The issue is a local, low-privilege memory-safety defect (CWE-416) rated CVSS 7.8, and Apple has shipped fixes in iOS 26.7, iPadOS 26.7, macOS Golden Gate 27 and macOS Sequoia 15.8. There is no indication of active exploitation (no CISA KEV listing) and no public exploit code identified, with EPSS at 0.19% (9th percentile) suggesting low near-term exploitation likelihood at scale.

An out-of-bounds write in Apple's media-handling code can corrupt memory and terminate the affected app when a user opens or previews a maliciously crafted video file on an unpatched Apple OS. The flaw affects iOS/iPadOS before 26.7 and before 27, macOS before Sequoia 15.8, before Tahoe 26.7, and before Golden Gate 27, plus tvOS before 27 and visionOS before 27, and Apple resolved it with improved bounds checking in those releases. Exploitation requires local delivery of the crafted file plus user interaction (CVSS AV:L/UI:R/PR:N), no public exploit code has been identified at time of analysis, and EPSS is low at 0.18% (7th percentile), so the practical risk is bounded by the demonstrated outcome of app termination rather than confirmed remote or zero-click compromise.

Heap out-of-bounds write in the theopolis uefi-firmware-parser Python package (versions prior to 1.14) lets a crafted Tiano/EFI-compressed firmware image corrupt heap memory when the file is parsed. The bundled native Tiano decompressor's ReadCLen() in Decompress.c reads a 9-bit length (up to 511, plus a run-length path allowing up to 531 writes) into the 510-element Sd->mCLen array without an Index < NC bound, producing a deterministic crash and potential code execution in the parsing process. No public exploit identified at time of analysis; the flaw is reached through the normal CompressedSection.process() parsing path, so any tool or service that ingests untrusted firmware with this library is at risk.

Stack out-of-bounds write in the theopolis uefi-firmware-parser Python library (versions prior to 1.14) lets a maliciously crafted Tiano/EFI-compressed firmware blob corrupt the parser's stack when it is decompressed. The bundled native Tiano decompressor's MakeTable() fails to validate Huffman bit-length values, so bit lengths above 16 overflow the stack-allocated Count[17] array and adjacent decode tables, deterministically crashing the parsing process and potentially allowing code execution in that process depending on build hardening. No public exploit identified at time of analysis; the issue was fixed in 1.14 by porting the upstream EDK2 hardening.

An out-of-bounds write in GIMP's Lighting Effects filter allows memory corruption when a victim opens a specially crafted lighting preset file, resulting in a crash or potentially arbitrary code execution in the context of the GIMP process. The CVSS vector (AV:L/UI:R) confirms the attack is file-driven and requires a user to open the malicious preset, so no remote unauthenticated path exists; exploitation depends on social engineering. Red Hat is the reporting party and its CPE data lists RHEL 6 through 9, but no public exploit code, EPSS score, or CISA KEV entry was supplied, so status is no public exploit identified at time of analysis.