Heap Overflow

Heap corruption in Brocade Fabric OS before 10.0.1 allows an authenticated administrator to crash a SAN switch's management service or potentially achieve arbitrary code execution by sending a crafted trunk configuration request through the REST API that is padded with an excessive number of list delimiters. The affected code path copies delimiter-separated list strings into a dynamically allocated heap array without validating the maximum number of elements, so a request that overruns the allocation corrupts heap metadata. Exploitation requires high-level (administrator) credentials and adjacent-network reachability to the management interface - a combination that realistically narrows the threat population to malicious insiders or attackers already holding or abusing admin credentials - and no public exploit code has been identified at time of analysis. This is a genuine but conditional priority rather than a drop-everything emergency.

Cyrus SASL clients that use the DIGEST-MD5 authentication mechanism can be crashed by a malicious or on-path server that supplies a crafted challenge field (such as realm or nonce), because the add_to_challenge() function computes a buffer size before DIGEST-MD5 quoting and fails to account for escaping that lengthens the value, resulting in a heap-based out-of-bounds write. This is a client-side denial-of-service flaw affecting Red Hat Enterprise Linux 6 through 10, Red Hat Hardened Images, and Red Hat OpenShift Container Platform 4; the assessed CVSS vector is AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:H, meaning unauthenticated remote attackers must control or intercept the server endpoint and the victim must initiate authentication. No public exploit code or confirmed active exploitation is identified at time of analysis.

Unauthenticated remote code execution in the NX-API feature of Cisco NX-OS Software lets a remote attacker who can reach the NX-API listener run arbitrary code with root privileges, or crash processes hard enough to force a device reload (DoS), by sending a single crafted HTTP request. Exposure is conditional: NX-API is an optional, non-default feature, so only NX-OS devices and UCS-managed systems where it has been explicitly enabled are vulnerable to an attacker with routing access to the management/HTTP endpoint; the CVSS vector (AV:N/AC:L/PR:N/UI:N) confirms no credentials or user interaction are required once that exposure exists. No public exploit code was identified at time of analysis and the CVE is not listed in CISA KEV, but the 9.8 severity, root-level impact, and full CIA loss make this a high-priority item for any environment exposing the NX-API management plane.

Heap-based buffer overflow in HDF5 (The HDF Group) before 2.2.0 lets an attacker who supplies a crafted HDF5 file corrupt heap memory in any application linked against the library, causing a crash and potentially achieving arbitrary code execution. The flaw lives in H5VM_array_fill() (src/H5VM.c) and is triggered when a dataset's unallocated/unwritten chunks are read: H5D__fill_init() derives the fill-value buffer from datatype and dataspace metadata stored in the file, and when that metadata is inconsistent with the buffer's allocated size the write overruns the buffer with attacker-controlled fill-value bytes. Exploitation is not network-reachable - it requires a victim to open or automatically process the malicious file (AV:L, UI:P per CVSS 4.0; UI:R in the 3.1 assessment), so risk is highest in data-ingest, HPC and ML pipelines that parse untrusted HDF5 inputs without an interactive user; no public exploit code has been identified at time of analysis and there is no KEV listing, though the CVSS 4.0 base score of 8.5 reflects high confidentiality, integrity and availability impact.

Sandbox escape in Google Chrome before 155.0.8059.39 via a heap-based buffer overflow (CWE-122) in ANGLE, Chrome's graphics translation layer: a remote attacker who has already compromised a sandboxed renderer process can use a crafted HTML page to execute arbitrary code outside the sandbox. It is a second-stage primitive rather than an initial-access bug - the assessed vector CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H (8.3) reflects high attack complexity, a required pre-existing renderer exploit chain, and active user interaction (UI:R), with the scope change S:C capturing the crossing of the sandbox boundary, even though Chromium rates the underlying bug Low severity. No public exploit code was identified at time of analysis and CISA's SSVC data records no observed exploitation, so the headline 8.3 should be weighed against the significant preconditions.

Heap-based buffer overflow in Google Chrome's font-handling code (CWE-122) lets an attacker who has already compromised the renderer process execute arbitrary code outside the sandbox when a victim renders a crafted HTML page containing malicious font data. All Chrome builds prior to 155.0.8059.39 on default configurations are affected; exploitation is unauthenticated (PR:N) but requires user interaction (UI:R) and a pre-existing renderer compromise, so it functions as a sandbox-escape chain component rather than a standalone drive-by, and is rated high complexity (AC:H) despite a CVSS base of 8.3 (S:C). No public exploit code has been identified at time of analysis and CISA's SSVC assessment records no exploitation, but the vendor has shipped a fix in 155.0.8059.39.

Heap-based out-of-bounds write in Android's Bluetooth stack, specifically the cfg2prop routine in btif_storage.cc, can be triggered when the Bluetooth subsystem converts attacker-influenced bonded/stored device configuration data into Bluetooth properties, potentially leading to remote code execution. Affected builds are Android 16, Android 16-qpr2, and Android 17; the assessed vector requires low privileges (PR:L, consistent with a pairing/component-level context) and no user interaction, and real-world reachability is expected to be radio-adjacent (a nearby, paired, or spoofed Bluetooth device) rather than arbitrary internet access, even though the vendor-assigned vector carries AV:N. No public exploit code has been identified and SSVC records exploitation as none at time of analysis, but the flaw is memory-corruption class with total technical impact, so it warrants priority patching on devices where Bluetooth is enabled and pairing is common.

Heap-based buffer overflow in Google Chrome's WebRTC component allows a remote attacker to execute arbitrary code inside the renderer sandbox by convincing a victim to open a crafted HTML page; all Chrome builds prior to 154.0.8037.97 on desktop and mobile platforms are affected. Successful exploitation requires user interaction (the victim must navigate to or open the attacker-controlled page), but no authentication or prior privileges are needed, and WebRTC is enabled by default. Impact is high for confidentiality, integrity, and availability within the renderer process, though the attack scope is unchanged - breaking out to the host operating system would require chaining a separate sandbox-escape flaw. Exploitation signals are currently weak: EPSS is only 0.25% (15th percentile), CISA SSVC rates exploitation as 'none', and no public exploit code has been identified at time of analysis; a vendor patch is available.

Heap-based buffer overflow in the C++ THeaderTransport of Apache Thrift before 0.25.0 lets a remote, unauthenticated attacker corrupt heap memory when an application enables the non-default ZLIB transform for outgoing frames and poorly compressible, peer-influenced data expands during compression. The copy into the write buffer happens without a bounds check, so oversized input overflows the heap allocation and, for large frames, also reads past the end of the transform buffer; impact scales with frame size and reliable code execution versus a crash depends on heap layout. No public exploit code has been identified at time of analysis, and because exploitation requires the ZLIB write transform precondition (without it the vulnerable copy path is never reached), this is a credible high-priority issue rather than an automatic emergency.

Heap-based buffer overflow in Fortra Core Privileged Access Manager (BoKS) allows remote attackers to corrupt heap memory when the product builds a human-readable failure reason for a revoked key, because the heap buffer allocated for that message is too small for the final sprintf() output. Per the vendor CVSS vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:N) the flaw is network-reachable and does not require authentication, but it does require user interaction and the revoked-key error path must actually be entered with a failure string long enough to overrun the allocation; our independent assessment keeps the same confidentiality and integrity impact while raising attack complexity and adding availability impact. No public exploit code has been identified at time of analysis, and no confirmed active exploitation is known.

Heap-based buffer overflow in iperf3 3.20 and 3.21 allows an unauthenticated remote client to overrun a 256-byte RSA buffer inside decrypt_rsa_message() by sending an oversized authtoken, corrupting heap memory on the server and potentially achieving remote code execution or a crash (CWE-122). The flaw is only reachable when an operator has explicitly started the iperf3 server in RSA-authentication mode with --rsa-private-key-path and --authorized-users-path; default iperf3 servers run without authentication and never enter the vulnerable code path, which is reflected in the upstream CVSS 4.0 vector's AT:P (attack requirements present) and in our independent assessment of CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H. No public exploit identified at time of analysis, no CISA KEV listing, and no EPSS score was supplied; a vendor fix is released as iperf3 3.22.

Heap-based buffer overflow in RPM's package-header parsing lets a crafted, unsigned RPM overwrite memory when a victim merely inspects it with rpm2cpio, rpm2archive, or 'rpm -qlvp', giving an attacker-controlled heap write past a one-byte allocation (CWE-122, assessed CVSS 3.1 7.1). Affected code ships with RPM as distributed in Red Hat Enterprise Linux 6, 7, 8, 9, and 10 as well as Red Hat Hardened Images, so build farms, CI pipelines, package mirrors, and malware-analysis hosts that routinely open untrusted packages are the realistic exposure surface. Exploitation is local (AV:L), low complexity (AC:L), and unauthenticated (PR:N) but requires user interaction (UI:R) to invoke an rpm tool against the malicious file; signature verification is no barrier because the overflow happens during header decoding. No public exploit identified at time of analysis.

Remote code execution is possible in Google Chrome on Android builds prior to 154.0.8037.92, where a heap-based buffer overflow in the ANGLE graphics layer can be triggered when a user renders a crafted HTML page. Successful exploitation corrupts memory out of bounds and, per Google's Critical severity rating and the scope-changed CVSS vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6), can potentially execute arbitrary code outside the browser sandbox. The issue is remotely deliverable without authentication but hinges on user interaction, and no public exploit code or active exploitation has been identified at time of analysis; CISA's SSVC assessment likewise records no observed exploitation and rates the flaw non-automatable, while a vendor patch (154.0.8037.92) is available.

Heap-based buffer overflow in TeamViewer Full Client and Host for Linux and macOS before version 15.82 allows arbitrary code execution at the victim user's privilege level when a crafted .tvs session recording is opened through the 'Play or convert recorded session…' feature. Exploitation is gated by heavy prerequisites: the attacker must land the malicious file on the target host and socially engineer the user into opening it (CVSS 3.1 7.8, AV:L/AC:L/PR:N/UI:R), and the resulting code runs only as the current user with no privilege escalation and no network-reachable path. No public exploit code or confirmed active exploitation is identified at time of analysis, so real-world risk is materially below the raw score.

Malformed SCTP traffic can crash the Wireshark/tshark dissector in versions 4.6.0 through 4.6.8 and 4.4.0 through 4.4.18, turning a heap-based buffer overflow (CWE-122) in the SCTP dissector into a denial of service against the analyst's own capture session rather than against any remote service. Exploitation requires the tool to process an attacker-supplied packet - either live-captured on a monitored interface carrying crafted SCTP traffic or opened from a malicious capture file - and the packet must be specifically malformed, which is why the high attack-complexity rating applies. Access requirements are unauthenticated per the CVSS vector (PR:N), and the realistic outcome is a crash of the Wireshark/tshark process, not code execution or host compromise; no public exploit code and no confirmed active exploitation were identified at time of analysis. Note that the originally supplied CVSS vector claimed high confidentiality and integrity impact, which the independent assessment corrected to availability-only (C:N/I:N/A:H).

Wireshark 4.6.0 through 4.6.8 and 4.4.0 through 4.4.18 can be crashed by processing attacker-controlled SPDY protocol data, an availability-only denial-of-service condition that our independent assessment scores as CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L. The signals conflict and, on balance, point to a LOWER real-world priority than the headline 8.8 suggests: exploitation requires the victim to open a crafted capture file or live-capture crafted SPDY traffic, publicly available exploit code exists, EPSS is only 0.45% (37th percentile), and there is no confirmed active exploitation (CISA KEV). Unauthenticated attackers can trigger the crash, but user interaction is mandatory and the impact is limited to terminating the Wireshark process, not code execution or data compromise.

Denial of service in Wireshark 4.6.0 through 4.6.8 and 4.4.0 through 4.4.18 allows a malformed X11 protocol message to crash the application via a heap-based buffer overflow in the X11 dissector. Exploitation requires a user to load a crafted capture file or dissect attacker-supplied live X11 traffic, giving a local, user-interaction-dependent vector (CVSS:3.1/AV:L/AC:L/PR:N/UI:R) that, per the assessed vector, degrades only availability with no confidentiality or integrity impact - despite the vendor's 7.1 base score, which rated confidentiality high. Publicly available exploit code exists and CISA's SSVC rates the issue as proof-of-concept exploitation, not automatable, with partial technical impact; active exploitation is not indicated, and EPSS is only 0.13% (2nd percentile), so real-world risk is low. A vendor fix is available in 4.6.9 and 4.4.19.

Heap-based buffer overflow in the Nanomsg WebSocket transport (versions 0.5-beta through 1.x before 1.2.3) allows remote attackers to corrupt heap memory by sending an oversized Sec-WebSocket-Version header during the WebSocket handshake, which is processed before any authentication or user interaction takes place. Exploitation requires that the target application actually enable and expose nanomsg's ws transport; TCP- or IPC-only deployments are unaffected. The flaw yields high integrity and availability impact, and while reliable code execution depends on heap layout and platform, no public exploit code has been identified at time of analysis and the vulnerability is not confirmed as actively exploited (not in CISA KEV).

Remote code execution in Microsoft Outlook affects Microsoft 365 Apps for Enterprise, Office LTSC 2021, and Office LTSC 2024 when a targeted user opens or previews a specially crafted email message. The CVSS vector (AV:N/AC:L/PR:N/UI:R) indicates an unauthenticated remote attacker can trigger the flaw with no credentials, but success depends on the victim interacting with the malicious message - Outlook's Preview Pane is a plausible trigger surface for message-borne code execution. No public exploit code has been identified at time of analysis (E:U) and Microsoft has released an update, so this is a high-priority patching candidate given the enormous installed base of Outlook, but not an emergency requiring emergency change control.

Heap-based memory corruption in Claris FileMaker Server's database engine block-parsing routine allows a maliciously crafted .fmp12 database file to overflow a heap buffer, potentially enabling arbitrary code execution in the context of the FileMaker Server process. All FileMaker Server releases prior to 26.0.3 are affected; exploitation requires that the crafted database be delivered to and processed by the server and that an operator open or host it (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 7.8), so the local delivery path and required user interaction are the principal limiting factors rather than any authentication barrier, since no privileges are needed (PR:N). No public exploit code has been identified at time of analysis, CISA SSVC records Exploitation: none with Automatable: no, and EPSS is low at 0.16% (4th percentile), making this a moderate-priority memory-corruption fix rather than an urgent field threat; Claris has released a vendor patch in FileMaker Server 26.0.3.

Risk cannot be meaningfully assessed from the available data. CVE-2026-95281 is tracked in the Ubuntu security database, which establishes only that it affects software shipped as a package within the Ubuntu distribution; the upstream project, the vulnerable component, and the affected Ubuntu releases are all unspecified. No description, CVSS vector, CWE, CPE, KEV status, or exploit data was provided, and no public exploit has been identified at time of analysis, so the attack vector, privilege requirements, and user-interaction prerequisites remain unknown and must be sourced from the corresponding Ubuntu Security Notice or the NVD entry.

CVE-2026-95318 is currently an unenriched record that cannot be meaningfully risk-assessed: the only attributable data point is that it was reported by vendor:ubuntu, with no description, no CPE strings, no CWE, no CVSS score or vector, and no references supplied. There is no confirmation of what component, package, or Ubuntu release is affected, whether exploitation requires authentication or user interaction, or what the resulting impact would be. Neither confirmed active exploitation (CISA KEV) nor publicly available exploit code exists in the available data, so the exploitation status is best described as no public exploit identified at time of analysis. This analysis should be treated as provisional and re-run once Ubuntu Security Notices or NVD enrichment supply a description, affected version range, and CVSS vector.

Risk cannot be meaningfully assessed from the supplied data: CVE-2026-95283 is recorded only as a vendor-reported entry from Ubuntu, with the description marked '[Unknown description]' and no CVSS score, CVSS vector, CWE, CPE, or affected source package provided. Because the impacted component, deployment mode, and attack surface are all unidentified, no statement can be made about what an attacker could achieve, which versions are affected, or what preconditions (authentication, user interaction, configuration) would be required. There is no KEV listing and no public exploit code identified at time of analysis, so the entry should be treated as an unassessed tracking record rather than a confirmed exploitable issue.

Heap-based buffer overflow in Google Chrome desktop (stable channel) allows a remote, unauthenticated attacker to corrupt heap memory when a victim renders attacker-controlled web content such as a malicious page, iframe, or ad, yielding high impact to confidentiality, integrity, and availability with a changed scope that suggests effects can extend beyond the initially affected component. Exploitation requires user interaction (UI:R) - the victim must load the hostile content - but needs no credentials (PR:N), is network-reachable (AV:N) and low complexity (AC:L), making actively browsing, unpatched endpoints the realistic exposure. No public exploit has been identified at time of analysis; the referenced Chrome stable channel advisory and Chromium issue 551573368 confirm a vendor fix, and the independent assessment rates this a genuine high priority at CVSS 9.6.

Heap-based buffer overflow (CWE-122) in Google Chrome's stable channel, addressed in the September 2026 desktop stable-channel update, lets remote, unauthenticated attackers corrupt heap memory in a vulnerable build and potentially escape the browser's renderer sandbox for full confidentiality, integrity, and availability impact (CVSS 3.1 base 9.6, S:C). Exploitation requires the victim to interact with attacker-controlled web content - typically visiting a malicious page or rendering a hostile ad - so the practical window depends on how quickly users and Linux distributions apply the update. No public exploit identified at time of analysis, and the issue is not listed in CISA KEV; details remain limited because the referenced Chromium issue tracker entry is access-restricted.

Heap-based buffer overflow in Google Chrome builds earlier than 154.0.8037.57 allows unauthenticated remote attackers to corrupt memory when a victim loads attacker-controlled web content, with a CVSS base score of 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H) reflecting scope change and potential high confidentiality, integrity, and availability impact. Exploitation requires user interaction - visiting a malicious site, a compromised page, or a malicious ad - and full host compromise would most likely require chaining this renderer-process overflow with a separate sandbox-escape bug rather than this flaw alone. Risk signals conflict in the usual browser-bug pattern: EPSS is only 0.29% (19th percentile), there is no CISA KEV listing, and no public exploit identified at time of analysis, while Chrome's silent auto-update rapidly shrinks the vulnerable population and a vendor patch is already available.

Opening a crafted file in Adobe Bridge can trigger a heap-based buffer overflow that results in arbitrary code execution with the privileges of the user running Bridge (CVE-2026-75649, CVSS 7.8). The attack is local-host only and depends on user interaction - a victim must open an attacker-supplied malicious file - so it cannot be triggered remotely or automatically, and code executes in the current user's context with no privilege escalation (AV:L/PR:N/UI:R/S:U). At time of analysis there is no confirmed active exploitation (not in CISA KEV) and no public exploit code identified, but because the advisory is vendor-published and the flaw is a memory-corruption RCE class, it should be treated as a genuine but conditional risk requiring social engineering to deliver.

Heap-based buffer overflow in Adobe Bridge lets an attacker execute arbitrary code in the context of the current user when a victim opens a specially crafted file. The flaw carries a CVSS 3.1 base score of 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), meaning the attacker needs no prior privileges but must rely on social engineering to get the target to open a malicious file locally; successful exploitation yields full confidentiality, integrity, and availability impact within the user's own security context, with no privilege escalation to system level. There is no public exploit identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV), so this is a genuine but non-urgent priority that should be handled through routine vendor patching; Adobe has published an advisory (APSB26-148) with fixed builds.

Heap-based memory corruption in RTI Connext Professional Core Libraries (7.4.0 before 7.7.0.1, 7.0.0 before 7.3.1.6, and the 6.1, 6.0, 5.3, and 5.2.3 branches) lets unauthenticated remote attackers who can reach a DDS domain corrupt heap memory by sending crafted RTPS/DDS traffic, yielding high integrity and availability impact with no confidentiality exposure. No public exploit has been identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV), though the CVSS 4.0 AT:P metric indicates exploitation depends on a specific attack precondition such as a particular message state or sequence. Risk is concentrated in environments where DDS traffic is reachable from untrusted network positions rather than in isolated OT, robotics, or simulation segments.

Remote code execution affects F5 BIG-IP systems that terminate traffic on a virtual server configured with both an APM (Access Policy Manager) access policy and an OAuth profile, where crafted malicious traffic can trigger a heap-based buffer overflow in the data plane. The flaw is remotely reachable, unauthenticated and low complexity per the vendor's CVSS 4.0 base score of 9.3, and the independent assessment confirms full confidentiality, integrity and availability impact (C:H/I:H/A:H) with no control-plane exposure; Appliance mode does not mitigate it. Exploitability is sharply limited by configuration - instances without APM or without an OAuth profile bound to a virtual server are not affected - and no public exploit code was identified at time of analysis, though the combination of unauthenticated RCE and a widely deployed enterprise appliance makes prompt hotfix deployment the priority.

A heap-based buffer overflow (CWE-122) in the IOCTL handler (sub_140001000) of mtdispkm64.sys, the kernel-mode display driver shipped with the Moore Threads MTT S80 GPU driver package up to version 340.150, lets a local low-privileged user who can open a handle to the driver's device object supply a malformed IOCTL request and corrupt kernel pool memory, potentially achieving elevation to SYSTEM. The flaw is not remotely reachable (AV:L, PR:L per the assessed CVSS:3.1 vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, rated 9.3), and exploitation is confined to Windows hosts that actually have this niche GPU driver installed and loaded. There is no vendor patch because Moore Threads did not respond to the disclosure, and no public exploit code has been identified at time of analysis.

Heap-based buffer overflow in X.Org libXrender before 0.9.13 allows a malicious or compromised X server to inject and execute arbitrary code in attached X11 clients via a crafted response to the RenderQueryPictFormats request. This is a reverse-direction attack where the victim must actively connect a vulnerable X11 client (linked against libXrender < 0.9.13) to an attacker-controlled or hijacked X server - typical exposure is via SSH X11 forwarding to an untrusted host or a remote DISPLAY connection; local trusted X servers are not affected. No public exploit code has been identified at time of analysis, and exploitation is non-trivial (AC:H) with no attacker authentication required (PR:N), but an upstream fix is available and the CVE description identifies 0.9.13 as the fixed version boundary.

Heap-based buffer overflow in libX11 before 1.8.14 allows a malicious or compromised X server to corrupt memory in connecting X11 clients via a crafted XkbGetMap reply that overflows the key_sym_map. This client-side vulnerability has an inverted threat model: the attacker must control the X server the victim connects to, with exploitation requiring user interaction (UI:R) and high attack complexity (AC:H). CVSS 3.1 score is 7.5 High; no public exploit code has been identified at time of analysis.

Out-of-bounds heap read and write in FluidSynth's MIDI player channel-tracking logic corrupts memory whenever the synth.midi-channels setting is configured above its default of 16, letting a local user who can influence that configuration crash the synthesizer and potentially achieve memory corruption with confidentiality, integrity and availability impact in the playing process. All releases from 2.2.4 up to but not including 2.5.6 are affected; the unsafe state is created by configuration alone plus ordinary playback, so no specially crafted MIDI file is required. No public exploit code and no confirmed active exploitation (CISA KEV) have been identified at time of analysis, and although the assessed CVSS 3.1 score is 7.8 High (AV:L/AC:H/PR:L/UI:R/S:U/C:H/I:H/A:H), the real-world risk is materially lower because default installations that leave synth.midi-channels at 16 never reach the vulnerable path.

Out-of-bounds reads in FluidSynth 2.5.0 through 2.5.5 can be triggered when the process loads and renders an attacker-controlled DLS soundfont, allowing memory disclosure and denial of service. Only builds compiled with the CMake option enable-native-dls enabled expose the vulnerable loader in src/sfloader/fluid_dls.cpp; builds with that option set to OFF are unaffected. The vendor rates this 8.0 (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:H), while independent assessment narrows the impact to confidentiality and availability (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H) because the crafted file must reach the process locally and no public exploit code has been identified at time of analysis. A vendor-released fix is available in version 2.5.6.

Out-of-bounds heap write in FluidSynth's command handler lets an attacker supply an out-of-range channel argument to the pitch_bend_range command, which is written through the selected synth channel without bounds checking. The worst-case exposure is unauthenticated remote code execution or denial of service (CVSS 3.1 9.8, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) when FluidSynth runs as a TCP command server via new_fluid_server() or 'fluidsynth -s'; absent that network mode, the flaw is only locally reachable through malicious commands fed to the interactive shell on standard input, and applications that embed the library without the shell, command handler, or TCP server are unaffected. The vendor has released a fix in FluidSynth 2.5.6 (spanning affected releases from 1.1.2); no public exploit code was identified at time of analysis and there is no confirmed active exploitation (CISA KEV).

Heap-based buffer overflow in the IBM MQ C client shipped with IBM MQ for HPE NonStop 8.1.0 through 8.1.0.40 lets a remote attacker who controls the queue manager's responses crash the client process or potentially execute arbitrary code in its context (CVSS 3.1 base 8.1). The flaw is triggered when the client requests AMS (Advanced Message Security) policy data and the client fails to properly validate the returned queue manager response; exploitation is unauthenticated from the client side (PR:N) but requires the attacker to operate a malicious or compromised queue manager or to man-in-the-middle the client-to-queue-manager channel, which is why the vector carries AC:H. No public exploit code or confirmed active exploitation was identified at time of analysis, and a vendor patch is available.

IBM MQ for HPE NonStop versions 8.1.0 through 8.1.0.40 contain a heap-based buffer overflow (CWE-122) that is triggered during queue manager startup when improperly validated cluster migration data is processed. The flaw is exploitable only by an authenticated attacker who can supply crafted migration data to a queue manager participating in MQ clustering, and the dependable outcome is a denial of service (queue manager startup failure or crash), with arbitrary code execution considered only potentially achievable. Independent assessment rates the realistic impact lower than the vendor's 7.5 score (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:H), and there is confirmed no public exploit code and no CISA KEV listing - no public exploit identified at time of analysis. A vendor patch is available via IBM support page node 7287705.

Remote denial of service in Osmocom osmo-bsc 1.0.1 through 1.14.1: a heap-based buffer overflow in ipaccess_proxy_read_msg() is triggered when a crafted IPA frame carries an attacker-controlled length value that is used without adequate validation against the actual buffer size. The issue is remotely reachable and requires no authentication or user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N) from any host able to talk to an osmo-bsc instance with the ipaccess proxy component deployed, and the assessed impact is availability-only (C:N/I:N/A:H), meaning a successful trigger corrupts heap memory and crashes the process. There is no public exploit identified at time of analysis and EPSS is a low 0.14% (4th percentile), consistent with the deployment reality that BSC signaling paths such as the IPA/A-bis proxy are normally confined to segmented, non-public operator networks.

Local privilege escalation in the virtio-win Viosock (vsock) paravirtualized driver, builds mm210 through mm319, lets an attacker who already has low-privilege code execution inside a Windows guest corrupt kernel memory and escalate to SYSTEM. The driver's IOCTL_SELECT handler adds three attacker-controlled descriptor counts with 32-bit arithmetic, so an integer-wrapped total passes the FD_SETSIZE bounds check while an individual fd_count remains far above the expected limit; the subsequent copy routine then walks the unchecked count and writes past the NonPagedPool-allocated pPkt->Fds array. Exploitation is local only (AV:L) and requires a low-privileged foothold (PR:L) with no user interaction; no public exploit code was identified at time of analysis, and the vendor fixed the issue in build mm320 via commit c6bef93d7909584bbda4e5c87603ea175825f342.

Heap-based memory corruption in the IBM MQ for HPE NonStop queue manager lets an attacker who already holds a valid, low-privileged authenticated channel connection (PR:L) crash or potentially take over the broker by sending a message carrying a malformed distribution list structure, yielding the full confidentiality, integrity and availability impact reflected in the CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The flaw is a heap buffer overflow (CWE-122) arising from improper validation of the multi-recipient list records embedded in an MQ message, so exploitation is network-reachable and requires no user interaction, but it is not reachable pre-authentication or against a default queue manager configuration. IBM has published a vendor patch and no public exploit code or evidence of active exploitation was identified at time of analysis.

IBM MQ queue managers that process XA (X/Open distributed) transactions are vulnerable to a memory-corruption buffer overflow triggered when a malformed XA transaction identifier (XID) is parsed, allowing an authenticated attacker with network access to crash the queue manager and potentially execute arbitrary code in its context. Exploitation requires valid credentials and the ability to drive XA transaction operations over an MQ channel (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, vendor score 8.8), so the reliably achievable outcome is denial of service while code execution remains a potential, not guaranteed, consequence. There is no public exploit identified at time of analysis and no confirmed active exploitation, but a vendor patch is available and the low attack complexity combined with the complete loss of confidentiality, integrity and availability impact makes prompt remediation important.

Heap buffer underflow in IBM MQ for HPE NonStop 8.1.0 through 8.1.0.40 allows an authenticated remote attacker to crash or destabilize the queue manager, and potentially to execute arbitrary code, by submitting a crafted multi-segment message that is reassembled during processing. The dependable outcome is denial of service: reliable code execution is not confirmed, and exploitation requires valid low-privilege credentials (PR:L) plus access to a channel or queue that accepts submitted messages. There is no public exploit identified at time of analysis and the flaw has not been added to CISA KEV; urgency is real but constrained because only the specialized HPE NonStop build is affected, not general IBM MQ distributions.

A pre-authentication heap buffer overflow in IBM MQ Appliance protocol message processing lets a remote, unauthenticated attacker crash the appliance (denial of service) or potentially execute arbitrary code in the context of the MQ appliance firmware. Only network reachability to the appliance's protocol message listener is required - no credentials, session, or user interaction - and the vendor rates this 10.0 with a scope change, while our independent assessment keeps the same base metrics but scores scope as unchanged (S:U) because the overflow occurs in the MQ process itself rather than crossing a security boundary. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (not in CISA KEV), but the combination of a CVSS 10.0, zero-click pre-auth reachability, and confirmed code-execution potential makes this a genuine top-priority vulnerability rather than a high-CVSS-but-low-real-risk case; an IBM vendor advisory with a patch is available.

Heap corruption in IBM MQ for HPE NonStop 8.1.0 through 8.1.0.40 allows an authenticated remote user with a valid MQ session to crash the queue manager via a crafted MQINQ inquire request, and the same integer-overflow defect in request validation creates the potential for privilege escalation under specific memory-layout conditions. The issue is rated 7.5 (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning credentials are required and the overflow is non-trivial to trigger reliably; there is no public exploit code and no public exploit identified at time of analysis, and IBM has published a vendor fix. Risk is further bounded because exploitation is confined to the specialized HPE NonStop platform running the affected 8.1.0.x maintenance levels, so deployments that have applied the patched level are not exposed.

Heap-based buffer overflow in IBM MQ allows an authenticated, low-privilege attacker who can reach a queue manager to cause a denial of service or potentially escalate privileges by issuing an MQPUT operation that carries a malformed distribution header (the MQDH distribution-list header). The flaw is network-reachable, low complexity, and requires no user interaction (CVSS 3.1 base 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), with the assessed impact spanning confidentiality, integrity, and availability, although reliable privilege escalation beyond a crash remains unconfirmed. No public exploit identified at time of analysis, and the vendor has published a patch advisory at IBM support node 7287778.

Heap-based out-of-bounds write in OpenImageIO before 3.1.16.0 lets remote attackers corrupt memory whenever an application linked against the library reads a crafted 1-bit contiguous CMYK TIFF, a condition that maps to CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:H (7.6). The flaw is reachable unauthenticated from the network perspective of the file, but exploitation is limited by the requirement that a victim open or process the malicious image (UI:R), and only that narrow PhotometricInterpretation 5 / BitsPerSample 1 / planarconfig contig code path is affected. Vendor-released patch: 3.1.16.0; no public exploit identified at time of analysis, though the upstream fix commit ships a regression test using a crafted sample (crash-cmyk-1bit.tif) that documents the exact triggering structure.

Decoding a crafted tiled OpenEXR image with OpenImageIO releases prior to 3.0.21.0, 3.1.16.0, or 3.2.0.3-beta1 can corrupt the heap, because the tiled reader copies decoded rows into the caller's buffer using a padded whole-tile stride instead of the width of the requested rectangle; affected files are those whose width is not an exact multiple of the tile width and are read as a partial edge-tile rectangle. The flaw is reachable without any privileges (PR:N) but requires the victim to open or process the malicious file (UI:R) and is scored as a local-vector bug (AV:L), yielding CVSS 7.8 with high confidentiality, integrity, and availability impact; both the classic and OpenEXR-Core readers (src/openexr.imageio/exrinput.cpp and exrinput_c.cpp) are affected. No public exploit identified at time of analysis, and vendor fixes are available in the three named release lines.

Heap buffer overflow in PDFium, the PDF rendering engine built into Google Chrome, allows a remote attacker to potentially execute arbitrary code inside the Chrome renderer sandbox on Windows systems running versions prior to 153.0.8010.52. Exploitation requires the victim to open an attacker-supplied crafted PDF (UI:R), so the attack is delivered via social engineering rather than direct network exploitation; no credentials are needed (PR:N) and default Chrome installations render PDFs without any special configuration. The vendor rates this High severity with 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 although a vendor patch is available, no public exploit code has been identified at time of analysis and there is no confirmed active exploitation (not in CISA KEV). Because code execution is confined to the renderer sandbox, full host compromise would additionally require a separate sandbox-escape vulnerability not covered by this advisory.

Heap-based buffer overflow in the SAIL image library's PSD decoder affects versions 0.9.10 and earlier, letting a crafted PSD file corrupt heap memory, reliably crash the host process, and potentially achieve code execution. Any application that passes attacker-controlled PSD data to sail_load_from_file() or sail_load_from_memory() is exposed; the CVSS vector carries PR:N (unauthenticated against the library), but practical exploitation still requires a victim to open or process a malicious image (UI:R), so the vendor's 9.8/UI:N rating overstates real-world risk. No public exploit code or confirmed active exploitation was identified at time of analysis, and the flaw is fixed in SAIL 1.0.0.

Heap-based buffer overflow in the SAIL cross-platform image library version 0.9.10 and earlier allows an attacker who supplies a crafted color-mapped, run-length-encoded TGA file (image_type == 9) to write attacker-controlled bytes past the end of a heap pixel buffer, causing heap corruption, a reliable crash, or potential code execution. The flaw is an incomplete fix for CVE-2026-40494: the earlier pixel-count clamp limits how many pixels are written but never constrains the per-pixel write width, which is derived from an attacker-controlled header bpp value of 9 through 32 (2-4 bytes) while the destination buffer is allocated as one-byte-per-pixel SAIL_PIXEL_FORMAT_BPP8_INDEXED. Although the CVSS vector is AV:N/PR:N, exploitation requires the victim's application to load the malicious image through sail_load_from_file() or sail_load_from_memory(), so a user-interaction condition is inherent; no public exploit code was identified at time of analysis, and the issue is fixed in SAIL 1.0.0. Note that the vendor-published CVSS of 9.8 (UI:N) overstates exploitability relative to the independent assessment of CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H.

Heap-based buffer overflow in rabbitmq-c, the C-language AMQP client library, affects all versions prior to 0.16.0 and is triggered when a malicious or compromised AMQP broker sends an undersized connection.tune frame_max value during the amqp_login() handshake. Because amqp_tune_connection() reallocates the outbound frame buffer using the attacker-supplied value without enforcing AMQP_FRAME_MIN_SIZE, the immediately serialized connection.tune-ok frame overflows the undersized heap allocation, producing memory corruption and likely denial of service, with code execution considered theoretically possible but not demonstrated. Exploitation requires the victim client to initiate a connection to attacker-controlled infrastructure (CVSS 7.1, AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:H), or an on-path attacker to inject the malicious tune frame into plaintext, non-TLS AMQP traffic; no public exploit code or confirmed active exploitation was identified at time of analysis, and a vendor-released patch in version 0.16.0 is available.

Remote code execution in Dell OpenManage Server Administrator (OMSA) managed-node installations prior to 11.1.0.3: a heap-based buffer overflow (CWE-122) that an attacker holding administrator-level privileges on the OMSA service can trigger over the network without user interaction, gaining code execution on the managed host with full confidentiality, integrity, and availability impact. The flaw scores 7.2 (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) and affects Windows, RHEL 8.10, RHEL 9.4, SLES 15, and Ubuntu 22.04 managed nodes. No public exploit code and no confirmed active exploitation were identified at time of analysis; the high-privilege prerequisite keeps this a privileged-user-to-code-execution escalation rather than a pre-authentication internet-facing exploit, with risk rising where OMSA is exposed to untrusted networks or chained after an authentication bypass such as CVE-2026-81475 in the same DSA-2026-403 bundle.

A heap-based buffer overflow in Dell OpenManage Server Administrator (OMSA) versions prior to 11.1.0.3 allows an authenticated local attacker with low privileges to corrupt process memory and escalate to full root/SYSTEM-level control of the managed node. Only hosts with the OMSA managed-node component installed and running are affected, across Windows, RHEL 8.10, RHEL 9.4, SLES 15, and Ubuntu 22.04 packages. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.8 High) confirms a local elevation-of-privilege primitive requiring an existing local account but no user interaction; no public exploit code and no confirmed active exploitation were identified at time of analysis, and the advisory's 'network access' title does not imply an unauthenticated remote path for this CVE.

Heap-based buffer overflow (CWE-122) in HP's HPLIP - the HP Linux Imaging and Printing Software stack shipped as the default printer/scanner driver on most Linux distributions - can be triggered when attacker-influenced data is processed by a vulnerable component, potentially leading to remote code execution, privilege escalation, denial of service, information disclosure, or unauthorized file modification. This is a bundled advisory covering multiple externally reported flaws across several HPLIP components, so the precise prerequisites vary per sub-vulnerability; the vendor assigns CVSS 4.0 score 9.3 (Critical) with a remote, unauthenticated, low-complexity vector, while the independent assessment is more conservative at CVSS 3.1 AV:N/AC:H/PR:N/UI:N, reflecting that the system must be running HPLIP and actually process malicious input. No public exploit code and no confirmed active exploitation were identified at time of analysis.

HPLIP (HP Linux Imaging and Printing Software) is affected by multiple heap-based buffer overflow vulnerabilities (CWE-122) that can lead to remote code execution, privilege escalation, denial of service, information disclosure, or unauthorized file modification. Exploitation requires user interaction, such as a victim performing a print or scan operation or processing attacker-supplied imaging data, but no authentication is needed, and the attack is network-reachable. HP has remediated the issues; no public exploit code has been identified at the time of analysis.

Heap-based buffer overflow and related memory-safety flaws in HP Linux Imaging and Printing (HPLIP) can allow remote code execution, privilege escalation, denial of service, information disclosure, or unauthorized file modification on Linux hosts where HPLIP is installed and the affected component is active. This is an aggregate HP bulletin (hpsbpi04151) that bundles multiple externally reported issues under one CVE, so the published CVSS 4.0 score of 9.3 (AV:N/AC:L/PR:N/UI:N/VC:H/VI:H/VA:H) represents the worst-case component rather than any single flaw, and the assessed CVSS 3.1 score is lower (AV:N/AC:H) because several sub-issues are more likely local than remote and heap exploitation requires reliable memory grooming. No public exploit code or confirmed active exploitation was identified at time of analysis, and the exposure is limited to Linux systems on which HPLIP is deployed rather than being a universal service.

Heap-based buffer overflows and related memory-safety flaws in HPLIP (HP Linux Imaging and Printing Software) let remote attackers corrupt memory in the print, scan, and device-discovery stack, potentially yielding remote code execution, privilege escalation, denial of service, information disclosure, or unauthorized file modification. Only Linux hosts with HPLIP installed and actively processing attacker-influenced input - a crafted print job, a rogue printer/scanner response, or a file handled by the HPLIP stack - are affected, and exploitation is gated on active user interaction (initiating or accepting the malicious print/scan operation) rather than being a fully autonomous remote exploit. The flaws are unauthenticated per the vendor CVSS vector (PR:N), impact varies depending on which bundled sub-vulnerability is triggered, and no public exploit identified at time of analysis.

Heap memory corruption in the userspace SMB daemon of MikroTik RouterOS before 7.24 lets remote, unauthenticated attackers crash or destabilize the service by sending a crafted SMB1 SessionSetupAndX request whose uniPwdLen field triggers an integer underflow and an oversized copy into a smaller heap buffer (CWE-122). The independently assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) rates this as an availability-only impact - adjacent heap corruption in a userspace daemon, not a confirmed path to code execution - and the primary limiting factor is that the SMB service is not enabled by default on RouterOS. No public exploit code has been identified at time of analysis, and exploitation requires the SMB service to be enabled and network-reachable with legacy SMB1 dialect handling active; a vendor fix shipped in RouterOS 7.24.

Heap-based memory corruption in NLnet Labs Unbound up to and including 1.26.0 lets a remote, unauthenticated attacker who controls or spoofs the upstream DNS response (PR:N/UI:N) gradually overwrite heap memory, with the reliable outcome being a crash and remote code execution possible only on certain systems and compilation options that lack hardening. The flaw is scored CVSS 8.4 (CVSS:4.0) and by the independent assessment as CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H, with the high attack complexity reflecting heavy dependence on heap layout and non-deterministic results. No public exploit code and no confirmed active exploitation were identified at time of analysis, and no KEV listing or EPSS signal is present, so this is a genuine but not-yet-urgent priority for internet-facing recursive resolvers.

A crafted DNSKEY whose owner name is a compression pointer into its own RDATA overflows the digest buffer in the DNSSEC validator of NLnet Labs Unbound 1.26.0 and earlier, letting an attacker who controls an authoritative zone crash a validating recursive resolver and, depending on heap layout, potentially execute code with attacker-influenced data. Exploitation is unauthenticated over the network per the CVSS vectors but is gated on DNSSEC validation being active and on inducing the resolver to query a name in the attacker's zone; the independently assessed impact is primarily denial of service (availability High, confidentiality and integrity Low), with remote code execution only possible rather than demonstrated. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, although the vendor rates the issue 9.1 under CVSS 4.0 and an advisory has been published.

Heap buffer overflow in NLnet Labs Unbound 1.26.0 and earlier can be triggered when a resolver processing a large TCP-framed DNS response encounters an RRSet whose owner name reaches the 255-byte maximum, crashing the resolver process and yielding a denial of service (availability-only impact, C:N/I:N/A:H). An attacker must either operate an authoritative name server that the victim resolver queries or hold an on-path position to tamper with an incoming DNS response, and the malicious answer must be delivered over TCP, be large, and carry the maximal-length owner name; crafting and delivering that payload raises practical complexity above the vendor's AC:L rating, which is why our assessment uses AC:H. No public exploit code or confirmed active exploitation has been identified at time of analysis, and because canonicalisation runs before DNSSEC validation, signature validation does not mitigate the issue. NLnet Labs has published an advisory at https://www.nlnetlabs.nl/downloads/unbound/CVE-2026-81634.txt.

Heap-based buffer overflow in Microsoft Edge (Chromium-based) versions 1.0.0.0 through 153.0.4234.32 allows remote attackers to execute arbitrary code in the browser by getting a victim to load attacker-controlled web content. 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), meaning no authentication or privileges are needed but successful exploitation requires user interaction such as visiting a crafted page or opening malicious content rendered by Edge. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, but a vendor patch is available from Microsoft and the affected range is bounded precisely by the fixed build, so exposure is limited to unpatched or unmanaged installations.

Local privilege escalation in Google Android allows an unprivileged app already running on the device to trigger a heap buffer overflow in the gf_ta_test_set_config routine of gf_ta_test.c, potentially gaining elevated code execution within the affected component. The flaw carries CVSS 8.4 (AV:L/AC:L/PR:N/UI:N, C/I/A High), requires on-device execution but no elevated privileges or user interaction, and affects Android builds where the vulnerable fingerprint/trusted-application test/config code is present. EPSS is very low at 0.12% (2nd percentile), no public exploit identified at time of analysis, and the issue is fixed in the 2026-09-01 Pixel security patch level.

A heap-based buffer overflow (out-of-bounds write) exists in the Android Cellular Modem component, allowing an attacker within adjacent/proximal radio range to corrupt heap memory and potentially execute code in the modem context without user interaction. The flaw carries a CVSS base score of 8.0 (AV:A/AC:L/PR:L/UI:N) and affects Google Android devices per the Android/Google Devices CPE. No public exploit code or CISA KEV listing was provided at time of analysis, so exploitation status is unconfirmed; the vendor fix is documented in the September 2026 Pixel/Android Security Bulletin.

Local privilege escalation in the Android kernel's fingerprint (gf) driver allows a process with access to the fingerprint device interface to corrupt kernel heap memory and gain root-level code execution. The flaw is a heap-based out-of-bounds write in gf_base_update_finger_base() within gf_base.c, exploitable with a low-privileged local context and no user interaction, consistent with a CVSS 3.1 base score of 7.8 (AV:L/AC:L/PR:L/UI:N). Fixes are delivered through the Android/Pixel Security Bulletin dated 2026-09-01; no public exploit code or CISA KEV listing was identified at time of analysis.

Remote exploitation of the cellular modem stack in Google Android devices allows an attacker who controls the radio path to trigger a heap-based out-of-bounds write and escalate privileges on the handset, without any user interaction. The supplied CVSS 3.1 base score of 8.8 reflects high confidentiality, integrity and availability impact, but its PR:L metric (low privileges required) conflicts with the vendor description stating that no additional execution privileges are needed. No public exploit code, EPSS score, or CISA KEV entry was included in the intelligence feed, so active exploitation is unconfirmed at the time of analysis.

Heap-based buffer overflow in Ashlar-Vellum Cobalt during parsing of VS drawing files allows an attacker to execute arbitrary code in the context of the victim's process. Exploitation requires the target to open a crafted VS file (user interaction), and no authentication or server-side access is needed because the flaw sits in the file parser. No public exploit code has been identified and the issue is not listed in CISA KEV; the vendor advisory is ZDI-26-587.

Heap-based buffer overflow in FreeRDP client versions before 3.31.0 allows a malicious or compromised RDP server to corrupt client memory by sending a Server Redirection PDU whose LoadBalanceInfo field is longer than the fixed 512-byte heap buffer used in nego_send_negotiation_request. Successful exploitation crashes the client and, when chained with a memory-disclosure primitive, could lead to code execution on the connecting workstation. No public exploit code and no CISA KEV listing were identified at time of analysis, and no EPSS score was supplied with this record, so current exploitation appears opportunistic rather than confirmed in the wild.

Heap-based buffer overflow in Ghostscript's JPEG 2000 (JPX) stream decoder (base/sjpx_openjpeg.c) allows unauthenticated remote attackers to corrupt memory, and potentially achieve code execution, by supplying a crafted PDF containing a JPEG 2000 image whose components declare mismatched subsampling factors. All Ghostscript/GhostPDL releases before 10.08.0 are affected; exploitation requires only that the target render the malicious file, which is effectively automatic in server-side pipelines such as CUPS/print spoolers, ImageMagick/GhostPDL conversion services and web PDF renderers, while desktop use requires a victim to open the document. Vendor-released patch: Ghostscript 10.08.0; no public exploit code identified at time of analysis and no confirmed active exploitation (not listed in CISA KEV), though the CVSS 4.0 base score of 9.3 reflects the trivial attack complexity and the high confidentiality, integrity and availability impact of a heap allocator corruption primitive.

Heap buffer overflow in Freeciv's worklist_load() function allows memory corruption when a crafted savegame file declares a worklist length exceeding the fixed MAX_LEN_WORKLIST bound of 64 entries. Both savegame format v2 (savegame2.c) and v3 (savegame3.c) code paths are vulnerable in all releases before 3.2.6, meaning any user or server operator who loads a malicious .sav file may have heap-adjacent struct fields overwritten, potentially enabling arbitrary code execution. No public exploit has been identified at time of analysis, but the patch diff is publicly available on GitHub, lowering the bar for future weaponization.

Heap-based buffer overflow in the Sofia IPC daemon's WS-Addressing Action transformation function allows remote unauthenticated attackers to crash Xiongmai XM530 IP cameras or potentially achieve arbitrary code execution by sending a crafted SOAP request containing a wsa5:Action string exceeding 128 bytes. Affected firmware is HMT.CM2005-v220608.1837 and all earlier versions. A public vulnerability research repository exists for this CVE, suggesting exploit code or detailed PoC is available. No public exploit identified as confirmed actively exploited at time of analysis.

Heap-based buffer overflow in Bosch Sensortec COINES_SDK versions 2.10 through 2.12.2 allows a malicious or compromised USB or BLE peripheral to corrupt host heap memory, leading to process crash or potential arbitrary code execution on the developer's machine. The root cause is that the PC bridge protocol decoder in bridge_decoder.c unconditionally trusts the packet length field supplied by the connected peripheral, passing it directly to mqueue_add_data without validating it against the fixed 255-byte queue slot - enabling a payload of up to ~3 KB to overwrite adjacent heap metadata via memcpy. No public exploit or CISA KEV listing has been identified at time of analysis; exploitation is constrained by the requirement for physical or BLE proximity and user-initiated device pairing.

Opening a crafted legacy Excel (.xls) file in libxls 1.6.3, or in any application that embeds it, can corrupt the heap and potentially execute arbitrary code because xls_getCSS() trusts a file-controlled font index without validating it against the workbook's font count. The same code path also permits use-after-free/out-of-bounds access to the font array while generating CSS from XF formatting records. Exploitation requires a victim to open a malicious file (CVSS AV:L/UI:R); no public exploit code has been confirmed and CISA KEV does not list this CVE, with EPSS very low at 0.15% (5th percentile), indicating limited real-world targeting at time of analysis.

Remote code execution in Check Point Quantum Security Gateway and Quantum Security Management stems from a heap-based buffer overflow in the ASN.1 decoder that parses VPN certificates, reachable by unauthenticated remote attackers. Because the flaw sits in the certificate-handling path of the internet-facing VPN service, a single crafted certificate or handshake can overflow heap memory and execute attacker-controlled code on security appliances that sit at the network perimeter. No public exploit identified at time of analysis, and the CVE carries no EPSS or KEV signal, but the pre-auth network-reachable RCE profile makes it a top-tier patching priority.

Heap buffer overflow in Samsung KnoxVault trustlet (hwvault trusted application) on Samsung Mobile Devices prior to SMR Sep-2026 Release 1 enables local privileged attackers to execute arbitrary code within the Trusted Execution Environment. The CVSS 4.0 score of 7.1 with AV:L/AC:H/PR:H reflects a high technical bar: exploitation demands pre-existing high-privilege local access plus significant exploit engineering to achieve reliable heap corruption. Samsung confirmed the fix in the September 2026 Monthly Security Release; no public exploit or active exploitation has been identified.

Remote code execution in Samsung Mobile Devices arises from a heap-based buffer overflow in the JPEG decoding path of libimagecodec.quram.so (the proprietary Quram/Qmage image codec) on builds prior to SMR Sep-2026 Release 1. A remote attacker who delivers a maliciously crafted JPEG image to a vulnerable device can corrupt heap memory and execute arbitrary code in the context of the image-processing component. No public exploit was identified at time of analysis, and the CVE is not listed in CISA KEV; Samsung rates it CVSS 4.0 9.2 (critical).

Remote code execution in the DNG (Adobe Digital Negative) image decoder within Samsung's Quram imaging library (libimagecodec.quram.so) affects Samsung mobile devices on Android 14, 15, 16, and 17 prior to the SMR Sep-2026 Release 1 patch. A crafted DNG image parsed by the library triggers a heap-based buffer overflow, letting a remote attacker run arbitrary code in the context of the process handling the image. No public exploit identified at time of analysis, and it is not on the CISA KEV list, but Quram image-parsing flaws have a strong historical track record of weaponization on Samsung/Android.

Heap buffer overflow in OpenIDC/cjose versions prior to 0.6.2.5 allows a remote unauthenticated attacker to corrupt process heap memory by submitting a crafted JWE token with an oversized `encrypted_key` segment targeting the AES Key Wrap decryption path. The `cjose_jwe_import()` and `cjose_jwe_decrypt()` functions are pre-authentication entry points that accept fully attacker-controlled input, making every application that decrypts AES-KW JWEs with this library directly reachable. Impact ranges from a reliable denial of service (process crash) to potential memory-corruption-based code execution depending on heap layout and allocator behavior. No public exploit has been identified at time of analysis, but the patch commit confirms the exact boundary condition and includes a regression test demonstrating the overflow trigger.

Heap-based buffer overflow in Google Chrome's WebRTC component (all versions prior to 153.0.8010.36) enables a remote unauthenticated attacker to potentially execute arbitrary code within the Chrome renderer sandbox by luring a target to a crafted HTML page. The vulnerability is classified CWE-122 and carries a CVSS base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H); however, Chromium's own internal severity rating is 'Low,' which is notably discordant and implies that exploitation is constrained to within-sandbox code execution rather than full OS compromise. No public exploit code and no CISA KEV listing have been identified at the time of analysis.

Heap-based buffer overflow in the WebRTC component of Google Chrome prior to 153.0.8010.36 allows a remote unauthenticated attacker to execute arbitrary code within the Chrome renderer sandbox by luring a user to a crafted HTML page. The RCE is sandbox-confined (CVSS S:U), meaning a chained sandbox-escape exploit would be needed for full host-level compromise. No public exploit or active exploitation has been identified at time of analysis, and EPSS sits at a low 0.24% (15th percentile), consistent with Chromium's own 'Medium' severity designation despite the 8.8 CVSS base score.

Remote code execution in Google Chrome on Windows (versions prior to 153.0.8010.36) arises from a heap buffer overflow in ANGLE, Chrome's graphics abstraction layer. A remote attacker who lures a victim to a crafted HTML page can corrupt heap memory and execute arbitrary code outside the renderer sandbox, gaining full compromise of the host. No public exploit is identified at time of analysis and EPSS is low (0.33%), but the sandbox-escape scope and Chrome's near-universal footprint make prompt patching essential.

Remote code execution in Google Chrome prior to 153.0.8010.36 allows a remote attacker to escape the renderer sandbox and run arbitrary code on the host by luring a victim to a crafted HTML page that triggers a heap buffer overflow in the WebGL implementation. Chromium rates this Critical and the CVSS 9.6 score reflects a scope-changing sandbox escape; no public exploit is identified at time of analysis, and EPSS is low at 0.29% (21st percentile). Patched in the September 2026 stable-channel desktop release.

Heap-based buffer overflow in Adobe Acrobat Reader and Acrobat 2024 enables arbitrary code execution at current-user privilege level when a victim opens a crafted PDF or supported file format. Affected versions span Acrobat Reader ≤26.002.21900 and Acrobat 2024 ≤24.001.30383 across all supported platforms, as documented in Adobe advisory APSB26-141. No public exploit code or active exploitation in the wild has been identified at the time of this analysis, but Adobe Acrobat's ubiquity in enterprise document workflows makes this a credible phishing or spear-phishing vehicle.

Heap-based buffer overflow in Adobe Photoshop Desktop allows arbitrary code execution in the context of the current user when a specially crafted malicious file is opened. Affected versions span both the Photoshop 2025 line (≤26.11.6) and Photoshop 2026 line (≤27.6), covering a broad install base of creative and enterprise users. No public exploit has been identified at time of analysis, though the file-based delivery mechanism makes phishing or watering-hole distribution a natural attack path.

Local privilege escalation affects Android versions 16, 16-qpr2, and 17 via heap-based buffer overflow triggered by integer overflow in multiple framework locations. An attacker with basic local code execution (low-privileged app or shell) can exploit the memory safety flaw - requiring no additional privileges or user interaction - to gain full control of the device, compromising confidentiality, integrity, and availability. No public exploit or active exploitation is identified at time of analysis; EPSS of 0.12% (2nd percentile) indicates low probability of near-term observed exploitation.

Heap buffer overflow in Android's HEVC decoder (`ihevcd_get_tu_data_size` in `ihevcd_utils.c`) enables local privilege escalation across Android 14 through Android 17 with no additional execution privileges or user interaction required. A low-privileged attacker - such as a malicious application - can craft HEVC video input that triggers an out-of-bounds write on the heap, corrupting adjacent memory structures and ultimately gaining elevated device privileges. No public exploit code has been identified at time of analysis, and SSVC currently rates active exploitation as none, though the technical impact is classified as total.

Heap-based buffer overflow in parseParts of PduParser.java enables local privilege escalation across Android 14 through 17 (including Android 16-QPR2). A low-privileged process on the device can trigger an out-of-bounds read via a malformed PDU, corrupting heap memory to achieve full confidentiality, integrity, and availability compromise without requiring user interaction. No public exploit code or KEV listing has been identified at time of analysis.

Remote code execution in Google Android (versions 14 through 17, including 16-qpr2) arises from a heap buffer overflow (CWE-122) present in multiple system code paths, per the September 2026 Android Security Bulletin. The flaw is reported by Google's Android security team as exploitable with no additional execution privileges and no user interaction, giving a remote attacker full compromise of the affected process context. SSVC rates exploitation as 'none' and there is no public exploit identified at time of analysis, but CISA's automatable=yes / technical-impact=total assessment marks it as a high-priority patch target.

Remote code execution is achievable in Android's NFC subsystem across Android 14 through 17, including Android 16-QPR2, via a heap buffer overflow in the MIFARE Classic tag reader function rw_mfc_handle_read_op() within rw_mfc.cc. An attacker within NFC proximity can present a crafted MIFARE Classic tag that overflows a heap-allocated buffer in the NFC daemon, yielding full device control with no victim interaction required and no privileges needed on the target. No public exploit has been identified at time of analysis, though the SSVC framework rates the technical impact as total given the unauthenticated RCE capability.