Buffer Overflow

Memory corruption in Mozilla Firefox's Networking: JAR component (the handler for jar: URLs and JAR-packaged resources) arises from an integer overflow that can drive out-of-bounds heap access and potential remote code execution. All Firefox builds before Firefox 151 and Firefox ESR 140.11 are affected; the flaw was reported and fixed by Mozilla. No public exploit is identified at time of analysis and EPSS probability is very low (0.05%, 14th percentile), yet SSVC rates technical impact as total and the technique as automatable.

Memory-safety corruption in the Audio/Video component of Mozilla Firefox stems from incorrect boundary conditions combined with an integer overflow, and is fixed in Firefox 151 and Firefox ESR 140.11. Remote attackers can trigger the flaw by serving crafted media to an affected browser, with NVD scoring a high confidentiality impact (CVSS 7.5, C:H/I:N/A:N); there is no public exploit identified at time of analysis and EPSS is very low (0.03%, 10th percentile). CISA's SSVC framework marks exploitation status as none but flags the issue as automatable with partial technical impact.

Denial of service in Mozilla Firefox (fixed in Firefox 151 and Firefox ESR 140.11) arises from an integer overflow (CWE-190) in the Windows-specific 'Widget: Win32' component, allowing remote attackers to crash the browser or corrupt memory state via crafted web content. The CVSS 3.1 vector scores availability-only impact (C:N/I:N/A:H), indicating a reliability/crash issue rather than confirmed code execution. There is no public exploit identified at time of analysis, and EPSS is very low (0.04%, 14th percentile).

Out-of-bounds memory access in the Firefox Web Codecs (Audio/Video) component allows a remote attacker to disclose sensitive process memory by serving a specially crafted media stream to a victim's browser. Rated CVSS 7.5 with a confidentiality-only impact (C:H/I:N/A:N), it affects Firefox before 151 and the ESR 115.x and 140.x branches; a vendor patch is available and it carries no public exploit and a negligible EPSS score (0.04%), with CISA SSVC recording no observed exploitation.

Out-of-bounds write in Samsung's Escargot lightweight JavaScript engine (commit 590345cc6258317c5da850d846ce6baaf2afc2d3) allows attackers to corrupt memory by inducing buffer overflows through crafted JavaScript. Exploitation requires local execution of attacker-supplied script content with user interaction, but successful triggering yields high impact to confidentiality, integrity, and availability (CVSS 7.8). No public exploit identified at time of analysis and the issue is not on the CISA KEV list.

Heap-based buffer overflow in Samsung's Escargot JavaScript engine (commit 590345cc6258317c5da850d846ce6baaf2afc2d3) allows remote attackers to corrupt heap memory and likely achieve arbitrary code execution when a victim processes attacker-controlled JavaScript. No public exploit identified at time of analysis, but the upstream fix (PR #1565) reveals multiple memory-safety hardening changes including integer underflow protection in TypedArray.copyWithin, fast-mode array conversion checks during spread operations, and OOM handling, indicating concrete reachable corruption paths. CVSS 7.8 with local attack vector and required user interaction reflects the engine's typical embedding context (apps, IoT, smart TV runtimes) rather than network-facing services.

Out-of-bounds write in OpenHarmony v6.0 and earlier enables a local low-privileged attacker to corrupt memory and trigger an unrecoverable denial-of-service condition on affected devices. The flaw was disclosed by the OpenHarmony project itself, and no public exploit identified at time of analysis. Although CVSS scores it 8.4 (High) due to scope change and high confidentiality/integrity impact, the vector indicates local-only access with low privileges already required.

Arbitrary code execution in OpenHarmony v6.0 and earlier enables remote attackers with low privileges to execute code within pre-installed apps via an out-of-bounds write (CWE-787). The CVSS 8.8 vector reflects network-reachable exploitation with low complexity and no user interaction once minimal privileges are obtained, yielding high impact across confidentiality, integrity, and availability. No public exploit identified at time of analysis and the issue is not listed in CISA KEV.

Heap-based buffer over-write in ImageMagick's IPL decoder (exposed through Magick.NET bindings) can be triggered when the library reads a multi-image stream whose frames have differing dimensions, leading to memory corruption and process crash. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/C:N/I:N/A:H) signals an availability-only impact reachable without authentication, and no public exploit identified at time of analysis. Risk is amplified by how widely ImageMagick is embedded in image-processing pipelines that accept untrusted user uploads.

Stack-based buffer overflow in lwIP's SNMPv3 USM handler exposes embedded and IoT devices running versions 2.1.0 through 2.2.1 to remote unauthenticated code execution. The flaw in snmp_parse_inbound_frame() allowed an attacker-controlled msgAuthenticationParameters TLV length to be used directly in a stack buffer copy without bounds validation - a protective assertion had been explicitly commented out in the codebase. With CVSS 4.0 scoring 8.9, SSVC classifying the attack as automatable with total technical impact, and proof-of-concept code in existence (E:P), this is a high-priority remediation target for any network-accessible lwIP deployment with SNMPv3 enabled; no CISA KEV listing has occurred at time of analysis.

Stack buffer overflow in the Edimax BR-6428NS router (firmware 1.10) allows remote authenticated attackers to corrupt memory by sending an overlong pptpUserName parameter to the /goform/formPPTPSetup endpoint. Publicly available exploit code exists per VulDB disclosure, and no public exploit identified at time of analysis in CISA KEV. The vendor was reportedly contacted prior to disclosure but did not respond, leaving the device line without a confirmed fix.

Stack buffer overflow in the Edimax BR-6428NS router firmware version 1.10 allows authenticated remote attackers to corrupt memory by sending a crafted POST request to the formL2TPSetup handler with an oversized L2TPUserName parameter. Publicly available exploit code exists via a third-party Notion writeup, and the vendor was contacted but did not respond, leaving devices exposed without a coordinated fix. No CISA KEV listing or EPSS data is available to confirm active mass exploitation, but the combination of a public PoC and unresponsive vendor elevates real-world risk for any internet-exposed device.

Remote buffer overflow in H3C Magic B3 routers (firmware up to 100R002) allows attackers with high privileges to corrupt memory via the UpdateWanParams function in /goform/aspForm by manipulating the param argument. Publicly available exploit code exists per VulDB disclosure, though the vendor did not respond to coordinated disclosure attempts. With CVSS 4.0 score of 7.3 and PR:H requirement, exploitation hinges on prior administrative access to the device's web interface.

Heap out-of-bounds write in the Crypt::OpenSSL::PKCS12 Perl module (versions up to and including 1.94) allows attackers who can supply a malicious PKCS12 file processed via info() or info_as_hash() to corrupt heap memory and potentially achieve remote code execution. The flaw stems from an integer overflow when an OCTET STRING or BIT STRING attribute on a SAFEBAG is >= 1 GiB in size, causing an undersized allocation followed by an OOB write. No public exploit identified at time of analysis, but the upstream patch and oss-security disclosure are public.

Memory corruption in radare2 6.1.5's GDB client allows remote attackers to crash the application or potentially execute code through malformed thread information responses. The vulnerability triggers when the GDB remote protocol's qsThreadInfo command fails after qfThreadInfo has allocated memory, causing a use-after-free condition. While no public exploits have been identified, the CVSS 8.7 score reflects the potential for remote unauthenticated denial of service impact.

Denial of service vulnerability in coreMQTT versions before 5.0.1 allows remote MQTT brokers to crash client applications through malformed MQTT v5.0 property packets. The vulnerability stems from missing bounds validation in the property parser, enabling out-of-bounds read conditions (CWE-125). Amazon Web Services has issued a security bulletin and released version 5.0.1 to address this issue.

Remote attackers can trigger memory corruption in radare2 6.1.5 through its GDB remote debugging interface, causing denial of service or potentially achieving code execution. The use-after-free vulnerability in gdbr_threads_list() occurs when processing a valid qfThreadInfo response followed by a malformed qsThreadInfo response, leading to improper memory management. VulnCheck reported this issue and vendor patch commit c213ad6894a1eb9086ac8bf5fae35757e9e1683c addresses the vulnerability.

Out-of-bounds read and buffer overflow in the Linux kernel's ksmbd SMB server allows authenticated remote attackers to corrupt memory or read past allocated buffers by sending a malformed inheritable ACE with an inflated num_subauth value. The flaw resides in smb_inherit_dacl() and smb_set_ace(), where the variable-length SID is not bounds-checked during DACL inheritance, enabling heap corruption with potential for remote code execution against any SMB server using ksmbd. EPSS is very low (0.02%) and no public exploit identified at time of analysis, but the vendor patch is available across multiple stable branches.

Integer overflow in libyang's lyb_read_string() function leads to heap buffer overflow during LYB binary parsing, enabling remote denial-of-service attacks against NETCONF servers, sysrepo, and other YANG data consumers. The vulnerability (CWE-190) allows unauthenticated attackers to crash services by supplying maliciously crafted LYB blobs over network connections. Fixed in version SO 5.2.15. CVSS 7.5 (High) with network attack vector and low complexity, though currently limited to availability impact. No active exploitation confirmed (not in CISA KEV); public exploit code status unknown.

Heap buffer overflow in libsixel versions up to 1.8.7-r1 enables local attackers to corrupt memory and potentially execute code by supplying maliciously crafted SIXEL image data. A signed integer overflow in the SIXEL parser's buffer resizing logic bypasses allocation size checks, allowing out-of-bounds writes with attacker-controlled offsets. The vulnerability requires user interaction to process a malicious SIXEL file but does not require authentication. Fixed in version 1.8.7-r2. No active exploitation confirmed (not in CISA KEV); public exploit code status unknown.

Heap buffer overflow in libsixel 1.8.7-r1 and earlier allows local attackers to execute arbitrary code or crash the application when encoding images with dimensions exceeding 2.15 billion pixels. The sixel_encode_highcolor function contains a signed integer overflow in allocation size calculation that wraps to a small value, causing malloc to succeed with an undersized buffer that the encoder subsequently overflows. Fixed in version 1.8.7-r2. No CISA KEV listing or public exploit code identified at time of analysis, with EPSS exploitation probability presumably low given the highly specific triggering conditions.

Sandbox escape in Google Chrome on Windows (versions prior to 148.0.7778.168) can be triggered by an integer overflow in the codecs component when the browser processes a crafted video file, allowing a remote attacker to potentially break out of the renderer sandbox. Chromium rates the security severity as Medium; the assigned CVSS is 8.3 due to high complexity but scope change and full CIA impact. There is no public exploit identified at time of analysis, EPSS is very low (0.07%), and CISA SSVC lists exploitation status as none, indicating no observed attacks.

Sandbox escape in Google Chrome for macOS (versions prior to 148.0.7778.168) stems from an out-of-bounds write in the browser's media codec handling, letting a remote unauthenticated attacker who lures a victim into opening a crafted video file corrupt memory and potentially break out of the renderer sandbox. The flaw carries a CVSS 8.3 rating driven by a scope-changing, full-triad impact, though Chromium internally rated the security severity only Medium. There is no public exploit identified at time of analysis, EPSS is very low at 0.07%, and CISA SSVC records exploitation as none.

Sandbox escape in Google Chrome's Media component (versions prior to 148.0.7778.168) allows a remote attacker who has already compromised the renderer process to break out of the browser sandbox via a crafted HTML page. This is an out-of-bounds write (CWE-787) rated High by Chromium and CVSS 8.3, but exploitation is gated on chaining from a prior renderer compromise, and there is no public exploit identified at time of analysis. EPSS is very low (0.07%, 21st percentile) and CISA SSVC lists exploitation status as none.

Sandbox escape in the GPU process of Google Chrome (and ChromeOS) on Linux, fixed in 148.0.7778.168, lets an attacker who has ALREADY compromised the renderer process break out of the browser sandbox via a crafted HTML page. This is a second-stage bug rather than an initial-access flaw, so it must be chained with a separate renderer exploit to be useful. There is no public exploit identified at time of analysis, EPSS is very low (0.07%), and CISA SSVC lists exploitation as none, though the technical impact if exploited is total.

Heap buffer overflow in Google Chrome's WebML component on Windows lets a remote attacker trigger heap corruption-and potentially achieve code execution in the renderer-by luring a victim to a crafted HTML page in a version prior to 148.0.7778.168. Chromium rates the flaw High severity, and a vendor patch is available. There is no public exploit identified at time of analysis, and EPSS exploitation probability is low (0.06%).

Remote code execution in Google Chrome desktop prior to 148.0.7778.168 stems from a heap buffer overflow in the browser's media Codecs component, allowing a remote attacker to run arbitrary code within the renderer sandbox when a victim processes a crafted video file. Reported internally by the Chrome team and rated High severity by Chromium, it carries CVSS 8.8 but requires user interaction (UI:R). There is no public exploit identified at time of analysis, and EPSS is low at 0.07%.

Out-of-bounds write in the WebRTC component of Google Chrome before 148.0.7778.168 lets a remote attacker achieve arbitrary code execution inside the renderer sandbox when a victim opens a crafted HTML page. Rated High by Chromium and CVSS 8.8, it requires user interaction (visiting a page) but no authentication. There is no public exploit identified at time of analysis, EPSS is low (0.07%), and CISA SSVC lists exploitation as none, indicating no observed in-the-wild activity yet.

Sandbox escape in Google Chrome for macOS before 148.0.7778.168 stems from a heap buffer overflow in the ANGLE graphics abstraction layer, letting a remote attacker who lures a victim to a crafted HTML page potentially break out of the renderer sandbox and cross into a higher-privilege context. Google rates the Chromium severity High and a fixed build is available, but there is no public exploit identified at time of analysis. EPSS is very low (0.06%) and CISA SSVC records exploitation status as none, indicating no observed attacks.

Out-of-bounds write in Google Chrome's WebAudio component (versions prior to 148.0.7778.168) lets a remote attacker achieve arbitrary code execution within the renderer sandbox when a victim opens a crafted HTML page. Google rates the Chromium severity as High and has shipped a fixed Stable channel build; there is no public exploit identified at time of analysis and the EPSS score is very low (0.07%). Because execution is confined to the sandbox, real-world impact typically requires chaining a separate sandbox-escape bug.

Renderer-sandboxed remote code execution in Google Chrome's Fonts component (versions prior to 148.0.7778.168) lets a remote attacker run arbitrary code inside the renderer sandbox when a victim opens a crafted HTML page. Rated High by Chromium and CVSS 8.8, the flaw is a CWE-787 out-of-bounds write reported internally by the Chrome team. There is no public exploit identified at time of analysis, and EPSS is very low (0.04%, 11th percentile), consistent with the CISA SSVC assessment of no known exploitation.

Out-of-bounds memory write in Google Chrome's ANGLE graphics abstraction layer on Windows before 148.0.7778.168 lets a remote attacker corrupt memory by luring a victim to a crafted HTML page, potentially leading to renderer-process code execution. Rated Critical by Chromium and scored CVSS 8.8, it requires user interaction (visiting a page) but no authentication. Currently there is no public exploit identified and the SSVC exploitation status is 'none', though the very low EPSS (0.07%) reflects newness rather than confirmed safety.

Out-of-bounds memory write in Google Chrome's Skia graphics library on Windows (versions prior to 148.0.7778.168) lets an attacker who has already compromised the renderer process trigger an integer overflow via a crafted HTML page, corrupting memory in a Critical-rated flaw. It is a second-stage primitive used to widen an existing renderer foothold, not a standalone remote-entry bug. No public exploit identified at time of analysis, and EPSS is very low (0.07%, 21st percentile), consistent with the SSVC 'Exploitation: none' assessment.

Remote code execution in Google Chrome's WebML component (versions prior to 148.0.7778.168) allows a remote attacker to run arbitrary code within the browser's renderer sandbox by luring a victim to a crafted HTML page. Chromium rates this a Critical severity heap buffer overflow (CWE-122), though the CVSS base is 8.8 because code execution is contained inside the sandbox rather than achieving a full host compromise. There is no public exploit identified at time of analysis, and the EPSS score is very low (0.06%, 20th percentile), consistent with SSVC showing no observed exploitation.

Heap buffer overflow in OpenImageIO's SGI image decoder allows arbitrary code execution via specially crafted .sgi files. Affects versions before 3.0.18.0 and 3.1.13.0 when processing malicious SGI images with invalid RLE compression parameters. Publicly available exploit code exists (SSVC POC status confirmed). Attack requires local file access and user interaction to open the malicious file, but CVSS 8.4 reflects high impact potential (code execution) in VFX/animation production environments where SGI format handling is common. EPSS data unavailable, not listed in CISA KEV.

Heap buffer overflow in OpenImageIO versions before 3.0.18.0 and 3.1.13.0 allows local attackers to corrupt up to 65,535 bytes of memory via malicious Softimage .pic files. The vulnerability arises when processing RLE-compressed images where run-length validation is missing in two code paths (softimageinput.cpp lines 469 and 345), though the raw packet path correctly implements bounds checking. EPSS data not available. Not listed in CISA KEV. Patches released by Academy Software Foundation in versions 3.0.18.0 and 3.1.13.0.

Heap overflow in OpenImageIO's JPEG 2000 decoder allows local attackers with malicious image files to execute arbitrary code. Affects versions before 3.0.18.0 and 3.1.x before 3.1.13.0 when compiled with USE_OPENJPH flag. Integer overflow in buffer size calculation causes undersized heap allocation, leading to memory corruption during pixel writes. No public exploit identified at time of analysis, but SSVC framework indicates POC exists. Vendor-released patches available in versions 3.0.18.0 and 3.1.13.0.

Heap buffer overflow in OpenImageIO 3.0.x (before 3.0.18.0) and 3.1.x (before 3.1.13.0) allows remote attackers to achieve denial of service or potentially arbitrary code execution via crafted DPX image files. The vulnerability stems from signed integer overflow in buffer size calculations within the DPX color converter, causing undersized heap allocations. Attack requires victim to open a malicious DPX file (user interaction required per CVSS UI:R). No public exploit code or active exploitation confirmed at time of analysis, though the technical details in the GitHub advisory provide sufficient detail for proof-of-concept development.

Out-of-bounds write in OpenImageIO versions prior to 3.0.18.0 and 3.1.13.0 allows remote attackers to crash applications or potentially execute arbitrary code by delivering maliciously crafted CbYCrY image files. A signed integer overflow in the ConvertCbYCrYToRGB() pixel-loop calculation generates large negative pointer offsets, corrupting memory during image processing. EPSS data not available; no evidence of active exploitation (not in CISA KEV); exploitation requires user interaction to process attacker-supplied image files.

Remote code execution in OpenImageIO versions before 3.0.18.0 and 3.1.13.0 allows unauthenticated attackers to achieve arbitrary read/write memory access by delivering a maliciously crafted kABGR DPX image file with oversized dimensions. The signed integer overflow in SwapRGBABytes() creates a negative pointer offset that enables both out-of-bounds read via memcpy and subsequent out-of-bounds writes, potentially leading to code execution when a user opens the malicious image. EPSS data not available; no confirmed active exploitation (not in CISA KEV), though the vendor-disclosed nature and VFX industry targeting suggests focused adversary interest in content creation pipelines.

Heap-based buffer overflow in OpenImageIO's HEIF decoder enables arbitrary code execution via crafted image files. Affects OpenImageIO versions prior to 3.0.18.0 and 3.1.13.0. Exploitation requires local access and user interaction (opening a malicious image file), but no authentication. Attack complexity is low once the malicious file is delivered. Vendor-released patches available in versions 3.0.18.0 and 3.1.13.0. No confirmed active exploitation (not listed in CISA KEV) and no public POC identified at time of analysis, though the technical details suggest straightforward exploitation once the attacker can deliver a crafted HEIF image to a target user.

Stack buffer overflow in PostgreSQL's refint module allows low-privileged database users to execute arbitrary code as the database operating system user across all supported versions before 14.23, 15.18, 16.14, 17.10, and 18.4. The vulnerability enables two distinct attack paths: direct stack overflow leading to OS-level code execution, and SQL injection when applications expose user-controlled columns configured as refint cascade primary keys. With CVSS 8.8 (AV:N/AC:L/PR:L) and network-based exploitation requiring only low-privilege database credentials, this represents a critical privilege escalation risk for PostgreSQL deployments. No active exploitation (CISA KEV) or public POC identified at time of analysis.

Remote code execution and denial-of-service in Palo Alto Networks PAN-OS software stems from a buffer overflow in the IKEv2 processing path, allowing unauthenticated network attackers to either crash the firewall or run arbitrary code with elevated privileges. The flaw affects multiple PAN-OS branches (11.1.x, 11.2.x, and 12.1.x) while Panorama, Cloud NGFW, and Prisma Access remain unaffected. There is no public exploit identified at time of analysis, EPSS sits at a low 0.06% (19th percentile), and CISA SSVC currently lists exploitation as 'none'.

Heap-based buffer overflow in the DNS proxy and DNS Server features of Palo Alto Networks PAN-OS allows unauthenticated remote attackers to trigger a denial-of-service condition across all PAN-OS platforms (except Cloud NGFW and Prisma Access) and potentially achieve arbitrary code execution on PA-Series hardware appliances via specially crafted network traffic. The flaw is rated CVSS 7.2 with high attack complexity; no public exploit identified at time of analysis and EPSS is 0.07%, but the technical impact is rated total by SSVC.

Heap buffer overflow in NGINX Plus and NGINX Open Source ngx_http_rewrite_module allows remote attackers to crash worker processes and potentially execute code on systems without ASLR. The vulnerability requires specific rewrite directive configurations using PCRE captures with question marks in replacement strings, combined with attacker-crafted HTTP requests and conditions beyond the attacker's control. F5 has released patches addressing this critical flaw. EPSS data unavailable; no KEV listing or public exploit identified at time of analysis, though the specific configuration requirements and dependency on external conditions likely limit widespread exploitation despite the 9.2 CVSS score.

Remote denial-of-service in F5 BIG-IP allows unauthenticated attackers to crash the Traffic Management Microkernel (TMM) by sending specially crafted UDP requests to virtual servers with classification profiles enabled. The vulnerability affects BIG-IP, BIG-IP Next CNF, and BIG-IP Next for Kubernetes platforms. No public exploit identified at time of analysis, with EPSS data unavailable for this recent CVE. Vendor-released patch available per F5 advisory K000158038.

Privilege escalation in F5 BIG-IP allows authenticated administrators to cross security boundaries and achieve elevated system access through a stack buffer overflow. The vulnerability affects all BIG-IP versions and requires high-privilege administrative credentials and direct network access to exploit. No public exploit code or active exploitation has been identified at time of analysis, but a vendor patch is available.

Remote denial of service in F5 BIG-IP Access Policy Manager (APM) allows unauthenticated attackers to crash the apmd process by sending specially crafted traffic to virtual servers with APM access policies configured. The vulnerability stems from a buffer overflow (CWE-120) and requires no authentication or user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N). EPSS data not provided; no CISA KEV listing indicates no confirmed widespread exploitation at time of analysis. F5 has released vendor patches per advisory K000161056.

Remote code execution in GUARDIANWALL MailSuite and GUARDIANWALL Mail Security Cloud allows unauthenticated network attackers to execute arbitrary code via stack-based buffer overflow when pop3wallpasswd runs with grdnwww user privileges. Canon Marketing Japan has released patches for both on-premises (versions 1.4.00-2.4.26 affected) and SaaS deployments (pre-April 30, 2026 maintenance). CVSS 9.3 indicates critical severity with network vector and no authentication required, though EPSS score of 0.14% (33rd percentile) suggests limited real-world exploitation probability at time of analysis. SSVC assessment marks this as automatable with total technical impact but no confirmed exploitation.

Out-of-bounds memory write in MongoDB Server's time-series collection feature enables arbitrary code execution by authenticated users with database write privileges. Affects all active release branches (5.0 through 8.3) when exploiting field-name-to-index mapping inconsistencies in the time-series bucket catalog. EPSS score of 0.06% (20th percentile) suggests low widespread exploitation probability despite high CVSS 8.7, but requires authentication and database privileges, limiting attack surface to insider threats or compromised application credentials. No public exploit code or CISA KEV listing identified at time of analysis.

Stack-based buffer overflow in the arduino-esp32 WebServer multipart form parser (all releases prior to 3.3.8) lets a remote attacker crash the device and potentially achieve code execution by sending an oversized multipart/form-data boundary value. The parser sizes a stack Variable Length Array from the attacker-controlled Content-Type boundary field with no length cap, so a boundary longer than ~8000 characters overruns the 8192-byte loopTask stack. Publicly available proof-of-concept exploit code exists (SSVC: poc); it is not listed in CISA KEV and EPSS remains low at 0.20%.

Heap out-of-bounds read and subsequent heap corruption in the Linux kernel's in-kernel SMB server (ksmbd) lets an authenticated remote SMB client with directory-creation rights corrupt kernel memory through the ACL inheritance path. By writing a crafted DACL whose SID carries an inflated num_subauth field and then creating child entries, an attacker can crash the kernel (DoS) or potentially escalate to kernel code execution. No public exploit identified at time of analysis; EPSS is low (0.18%, 39th percentile) and the flaw is not in CISA KEV, so exploitation is not confirmed in the wild.

Arbitrary code execution in Adobe After Effects 26.0, 25.6.4 and all earlier versions arises from a stack-based buffer overflow (CWE-121) triggered when a victim opens a maliciously crafted project or media file, running code in the context of the current user. Reported by Adobe and tracked in APSB26-48, it carries a CVSS 7.8 (High) with a local attack vector and required user interaction; there is no public exploit identified at time of analysis, and the EPSS score is 0.01% (1st percentile). SSVC indicates no observed exploitation but total technical impact, making this a patch-on-schedule priority rather than an emergency.

Arbitrary code execution in HPE Aruba Networking Wireless Operating System (AOS-8 and AOS-10) allows an authenticated administrator to run code with elevated privileges on the underlying OS by sending crafted requests to management service components reached via the command-line interface. Multiple stack-based buffer overflows (CWE-121) underlie the issue, affecting AOS 8.10.x, 8.12.x, 8.13.x, 10.4.x, 10.7.x and 10.8.0.0. No public exploit identified at time of analysis, and EPSS is very low (0.07%, 22nd percentile), consistent with CISA SSVC scoring exploitation as 'none'.

Privilege-to-OS remote code execution affects HPE Aruba Networking Wireless Operating System (AOS-8 and AOS-10), where several CLI-accessible management service components contain stack-based buffer overflows (CWE-121). An authenticated administrator can send specially crafted requests to these services to execute arbitrary code with elevated privileges on the underlying OS, escaping the constrained management context. There is no public exploit identified at time of analysis, EPSS is very low (0.07%, 22nd percentile), and it is not listed in CISA KEV.

Privilege escalation to arbitrary code execution affects HPE Aruba Networking Wireless Operating System (AOS-8 and AOS-10) management service components reachable via the command-line interface. An administrator-authenticated attacker can send crafted requests to trigger stack-based buffer overflows and run arbitrary code with elevated privileges on the underlying OS of the wireless controller or gateway. There is no public exploit identified at time of analysis, EPSS risk is very low (0.07%), and CISA SSVC lists exploitation status as none.

Authenticated command execution in HPE Aruba Networking Wireless Operating System (AOS-8 and AOS-10) allows an administrator to escalate from the CLI to the underlying OS by triggering stack-based buffer overflows in several management service components. An attacker who already holds administrative CLI credentials can send crafted requests to these services and run arbitrary code with elevated (root-level) privileges on the controller or gateway. There is no public exploit identified at time of analysis, and EPSS is low (0.07%), consistent with the CISA SSVC assessment of no known exploitation.

Authenticated arbitrary code execution in HPE Aruba Networking AOS-8 and AOS-10 wireless operating systems lets an attacker with administrative CLI privileges run code with elevated OS-level privileges via stack-based buffer overflows in several backend management service components. An administrator sending specially crafted requests through the command-line interface can escape the managed CLI context and gain control of the underlying operating system of the controller or gateway. There is no public exploit identified at time of analysis, EPSS probability is very low (0.07%), and CISA SSVC records no known exploitation.

Remote code execution in HPE Aruba Networking Wireless Operating System (AOS-8 and AOS-10) allows an unauthenticated remote attacker to overflow a heap buffer in a network management service and run arbitrary code as a privileged OS user, or trigger a denial-of-service crash of the affected process. It affects Aruba mobility controllers and gateways across multiple 8.x and 10.x branches. No public exploit identified at time of analysis and it is not in CISA KEV; EPSS is low (0.12%, 30th percentile), and notably the vendor CVSS vector scores only availability impact despite the RCE claim.

Arbitrary code execution in Adobe Illustrator versions 29.8.6, 30.3 and earlier arises from a heap-based buffer overflow (CWE-122) triggered when a victim opens a maliciously crafted file, letting an attacker run code with the privileges of the current user. It affects desktop installations of both the 29.x and 30.x release trains and was reported by Adobe PSIRT under advisory APSB26-51. There is no public exploit identified at time of analysis, and the EPSS score is very low (0.03%, 7th percentile), consistent with CISA SSVC rating exploitation as 'none'.

Arbitrary code execution in Adobe Substance 3D Painter versions 12.0.2 and earlier arises from an out-of-bounds write (CWE-787) triggered when a victim opens a maliciously crafted file, executing code in the context of the current user. The flaw was reported by Adobe PSIRT and is fixed per advisory APSB26-55; there is no public exploit identified at time of analysis, and EPSS exploitation probability is very low at 0.03%. Exploitation is local and requires user interaction, limiting it to social-engineering-driven file-opening attacks rather than remote automated compromise.

Arbitrary code execution in Adobe Substance 3D Painter (versions 12.0.2 and earlier) allows an attacker to run code in the context of the current user when a victim opens a maliciously crafted file. The flaw is an out-of-bounds write (CWE-787) triggered during file parsing, so exploitation is file-borne and requires user interaction. There is no public exploit identified at time of analysis, KEV does not list it, and the EPSS score is very low (0.03%), indicating no observed or expected mass exploitation.

Arbitrary code execution in Adobe Illustrator 29.8.6, 30.3 and earlier arises from an out-of-bounds write (CWE-787) triggered when a victim opens a maliciously crafted file, running code in the context of the current user. Only local file-open exploitation applies (CVSS 7.8, AV:L), and there is no public exploit identified at time of analysis; EPSS is very low at 0.03% (7th percentile) and CISA SSVC lists exploitation as none, indicating no observed attacks despite total technical impact.

Local privilege escalation in Intel QuickAssist Technology (QAT) software drivers for Windows before version 1.13 lets an authenticated, unprivileged local user escalate to higher privileges via an out-of-bounds write (CWE-787) in Ring 3 user-application code. The flaw carries a CVSS 4.0 base score of 8.5 with total technical impact but is not known to be exploited - CISA's SSVC framework rates exploitation as 'none' and EPSS is negligible at 0.01% (3rd percentile), with no public exploit identified at time of analysis.

Arbitrary code execution in Adobe Substance3D - Designer (versions 15.1.0 and earlier) arises from an out-of-bounds write when parsing a malicious file, letting an attacker run code in the context of the current user. Exploitation requires the victim to open a crafted file, so it is a local, user-interaction-dependent flaw rather than a remotely triggerable one. There is no public exploit identified at time of analysis and EPSS is very low (0.03%), consistent with CISA SSVC scoring exploitation as 'none'.

Arbitrary code execution in Adobe Substance3D - Designer 15.1.0 and earlier occurs when a victim opens a maliciously crafted asset file, triggering an out-of-bounds write in the application's file parser and running attacker code with the current user's privileges. Adobe self-reported the flaw; there is no public exploit identified at time of analysis, and the EPSS score is very low (0.03%, 7th percentile), consistent with SSVC's assessment of no observed exploitation.

Arbitrary code execution in Adobe Substance3D - Designer versions 15.1.0 and earlier arises from an out-of-bounds write (CWE-787) triggered when a victim opens a maliciously crafted asset or project file, running attacker code in the context of the current user. The flaw was reported by Adobe and patched in advisory APSB26-52; there is no public exploit identified at time of analysis and EPSS is very low (0.03%, 8th percentile). SSVC records no known exploitation, but the technical impact is rated total.

Arbitrary code execution in Adobe Substance3D - Designer (versions 15.1.0 and earlier) arises from an out-of-bounds write (CWE-787) triggered when a victim opens a maliciously crafted file, running attacker code in the context of the current user. No public exploit identified at time of analysis, and the EPSS score is very low (0.03%, 8th percentile), consistent with SSVC 'Exploitation: none.' The flaw is Adobe-reported (APSB26-52) and requires local file-open user interaction rather than remote network access.

Arbitrary code execution in Adobe After Effects 26.0, 25.6.4 and earlier arises from an out-of-bounds write (CWE-787) triggered when a victim opens a maliciously crafted file, running attacker code in the context of the current user. There is no public exploit identified at time of analysis and the EPSS probability is negligible (0.03%), but the CVSS 3.1 base score is 7.8 (High) with total technical impact. Adobe has published a patch in advisory APSB26-48.

Arbitrary code execution in Adobe After Effects 26.0, 25.6.4 and earlier arises from a heap-based buffer overflow (CWE-122) triggered when a victim opens a maliciously crafted project or media file, letting an attacker run code in the context of the current user. Adobe self-reported the issue and released a patch via advisory APSB26-48. There is no public exploit identified at time of analysis, and the EPSS score is very low (0.03%, 7th percentile), consistent with SSVC marking exploitation as 'none'.

Arbitrary code execution in Adobe Media Encoder (versions 26.0.2, 25.6.4 and earlier) stems from an out-of-bounds write (CWE-787) that executes in the context of the current user when a victim opens a crafted media file. No public exploit identified at time of analysis, and EPSS probability is very low (0.03%), consistent with the SSVC 'Exploitation: none' assessment despite the total technical impact rating. Successful exploitation requires local user interaction, making this a file-lure attack rather than a remote-service threat.

Arbitrary code execution in Adobe Premiere Pro 26.0.2, 25.6.4 and all earlier versions arises from an out-of-bounds write (CWE-787) triggered when a victim opens a maliciously crafted project or media file, running attacker code in the context of the current user. The flaw is vendor-reported (Adobe APSB26-46) with no public exploit identified at time of analysis; EPSS is very low at 0.03% (7th percentile) and CISA SSVC records exploitation status as none, though technical impact is rated total. Exploitation is local and requires user interaction, so risk is bounded by social-engineering delivery rather than remote automated attack.

Arbitrary code execution in Adobe Premiere Pro (versions 26.0.2, 25.6.4 and earlier) arises from an out-of-bounds write triggered when a victim opens a maliciously crafted project or media file, letting an attacker run code in the context of the current user. The flaw was reported by Adobe and addressed in advisory APSB26-46; it carries a CVSS 7.8 (High) score but a very low EPSS of 0.03%, and CISA SSVC records no observed exploitation. There is no public exploit identified at time of analysis, and it is not listed in CISA KEV.

Local privilege escalation in the Win32K GRFX (graphics) subsystem of Microsoft Windows allows an authenticated, low-privileged user to execute arbitrary code in the kernel context via a heap-based buffer overflow. All currently supported Windows client and server releases (Windows 10 1607 through Windows 11 26H1, Windows Server 2012 through 2025) are affected. There is no public exploit identified at time of analysis, and EPSS probability is very low (0.02%), but the total technical impact and low exploitation barrier make it a meaningful patch-priority for endpoint hardening.

Local privilege escalation in the Windows Remote Desktop component (CWE-122 heap-based buffer overflow) allows an authenticated low-privileged user to gain SYSTEM-level control across virtually all supported Windows client and server releases, from Windows 10 1607 through Windows 11 26H1 and Windows Server 2012 through 2025. Microsoft has released patches; there is no public exploit identified at time of analysis and EPSS exploitation probability is very low (0.04%), consistent with CISA SSVC rating exploitation as 'none'. The flaw is a serious defense-in-depth concern because it grants total confidentiality, integrity, and availability impact once a foothold exists, but it is not remotely reachable and requires prior local access.

Arbitrary code execution in Microsoft Excel (and the broader Office family through Microsoft 365 Apps, Office 2019, LTSC 2021/2024, Office for Mac, and Office Online Server) is possible when a user opens a maliciously crafted spreadsheet that triggers a heap-based buffer overflow (CWE-122), running attacker code in the context of the current user. There is no public exploit identified at time of analysis and the EPSS probability is very low (0.06%, 18th percentile), but the technical impact is total (full confidentiality, integrity, and availability loss). Microsoft has released patches; exploitation requires the victim to open a file, so it is a phishing/social-engineering-driven local vulnerability rather than a remotely wormable one.

Local information disclosure in the Microsoft Windows Desktop Window Manager (DWM) Core Library affects a broad range of Windows 10, Windows 11 (through 26H1), and Windows Server (2016-2025) builds, where a buffer over-read (CWE-126) lets an already-authenticated local attacker read adjacent process memory. Microsoft's CVSS 7.8 vector rates full confidentiality, integrity, and availability impact even though the description characterizes the outcome as information disclosure, so the leaked memory could plausibly aid further local escalation. There is no public exploit identified at time of analysis, EPSS is negligible (0.04%), and CISA SSVC marks exploitation as none, but a vendor patch is available.

Local privilege escalation in the Microsoft Windows TCP/IP stack (tcpip.sys) lets an already-authenticated low-privileged user corrupt heap memory to gain SYSTEM-level control across virtually all supported Windows client and server releases. Microsoft assigns CVSS 7.8 and reports total technical impact, but SSVC exploitation status is 'none' and EPSS is only 0.06% (18th percentile), and there is no public exploit identified at time of analysis. Microsoft has released a patch via the Security Update Guide.

Local privilege escalation in the Windows Desktop Window Manager (DWM) Core Library affects Windows 11 (24H2, 25H2, 26H1) and Windows Server 2025, where an integer overflow (CWE-190) lets an already-authenticated low-privileged user run code with SYSTEM-level rights. Microsoft has released a patch and reported the flaw itself; there is no public exploit identified at time of analysis, and the EPSS score is very low (0.06%). SSVC rates exploitation as none but technical impact as total, marking it a classic patch-Tuesday local EoP rather than a mass-exploitation threat.

Local code execution in Microsoft Office (LTSC for Mac 2021/2024 and Office for Android) via a heap-based buffer overflow (CWE-122) that an unauthorized attacker triggers when a victim opens a maliciously crafted document, yielding full confidentiality, integrity, and availability impact in the user's context. Exploitation requires user interaction (UI:R) and local access (AV:L), so weaponization depends on social engineering rather than remote reachability. This is no public exploit identified at time of analysis, with a very low EPSS score of 0.06% and CISA SSVC rating exploitation as 'none', indicating no observed activity despite the 'total' technical impact.

Remote code execution in Microsoft Windows DNS lets an unauthenticated attacker corrupt heap memory over the network and run arbitrary code on affected Windows 11 (22H3 through 26H1) and Windows Server 2022/2025 systems. The flaw is a CWE-122 heap-based buffer overflow rated CVSS 9.8, reported by Microsoft with a patch available; there is no public exploit identified at time of analysis, and the EPSS score is very low (0.07%), so this is a high-severity but not-yet-exploited issue. CISA SSVC flags it as automatable with total technical impact, meaning successful exploitation fully compromises the host.

Remote code execution in the Windows Netlogon service (across Windows Server 2012 through 2025) allows an unauthenticated attacker to run arbitrary code over the network by triggering a stack-based buffer overflow (CWE-121). With a CVSS 3.1 vector of AV:N/AC:L/PR:N/UI:N and total technical impact, this is a critical, pre-authentication server-side flaw. Microsoft has released patches; publicly available exploit code exists, though EPSS remains low (0.09%) and there is no confirmed active exploitation at time of analysis.

Local privilege escalation in the Windows Common Log File System (CLFS) driver lets an already-authenticated low-privileged user corrupt heap memory to gain SYSTEM-level control across a broad range of Windows client and server releases (Windows 10 1607 through Windows 11 26H1, Server 2012 through Server 2025). Exploitation is CVSS 7.8 with total technical impact per CISA SSVC, but SSVC records no observed exploitation and EPSS is very low (0.04%), and no public exploit was identified at time of analysis. A vendor patch is available from Microsoft (MSRC).

Local privilege escalation in the Microsoft Windows TCP/IP networking stack allows an authorized (low-privileged) attacker to run code with SYSTEM-level rights by triggering a stack-based buffer overflow (CWE-121). The flaw affects a broad range of Windows 10, Windows 11, and Windows Server releases and carries a CVSS 7.8 with total technical impact per CISA SSVC. There is no public exploit identified at time of analysis, EPSS is very low (0.06%, 19th percentile), and it is not listed in CISA KEV, indicating no observed exploitation to date.

Local privilege escalation in Windows Cryptographic Services lets an authenticated low-privileged user corrupt heap memory (CWE-122) to gain SYSTEM-level control across supported Windows 10, Windows 11, and Windows Server builds. There is no public exploit identified at time of analysis and EPSS is very low (0.04%), but SSVC rates the technical impact as total, and Microsoft has released patches. Because it requires prior local access, it is a post-compromise escalation primitive rather than an initial-access threat.

Local code execution in Microsoft Office (2016, 2019, LTSC 2021/2024, 365 Apps for Enterprise, Office for Android, and Office LTSC for Mac 2021/2024) stems from a heap-based buffer overflow that lets an attacker run arbitrary code with the victim's privileges. The flaw was reported by Microsoft, a vendor patch is available, and there is no public exploit identified at time of analysis; EPSS is very low at 0.04% and CISA SSVC records exploitation as none. Impact is total (full confidentiality, integrity, and availability loss) but exploitation is not automatable and, per typical Office file-parsing bugs, hinges on processing attacker-supplied content.

Information disclosure in Microsoft Excel (and the broader Office family - Office 2019, Office LTSC 2021/2024, Office for Mac, Microsoft 365 Apps for Enterprise, and Office Online Server) allows an attacker to read memory beyond an allocated buffer when a victim opens a crafted spreadsheet, potentially leaking sensitive in-process data. Exploitation is local and requires user interaction (opening the malicious file); there is no public exploit identified at time of analysis and CISA SSVC scores exploitation as 'none'. EPSS is very low (0.06%, 18th percentile), indicating negligible observed exploitation activity, though the technical impact is rated 'total'.

Local code execution in the Windows Graphics Device Interface (GDI) component affects a broad range of Windows client and server releases from Windows Server 2012 through Windows 11 25H2/26H1 and Server 2025. An attacker who convinces a user to open a maliciously crafted file or content triggers a heap-based buffer overflow (CWE-122) in GDI, running arbitrary code in the victim's context with full confidentiality, integrity, and availability impact. There is no public exploit identified at time of analysis, EPSS is very low (0.06%), and CISA SSVC records no known exploitation, so this is a patch-on-cycle item rather than an emergency.

Local privilege escalation in the Windows Kernel affects a broad range of Windows Server releases (2012 through 2025, including Server Core installations), where a heap-based buffer overflow (CWE-122) lets an already-authenticated local user corrupt kernel heap memory to gain SYSTEM-level privileges. Microsoft has released patches and rates it CVSS 7.8; there is no public exploit identified at time of analysis, and CISA's SSVC framework marks exploitation as none but technical impact as total. EPSS is very low (0.04%, 13th percentile), consistent with the local-only attack vector that requires prior code execution on the host.

Local privilege escalation in Windows Storage Spaces Controller enables authenticated users with low-level access to gain SYSTEM-level privileges by exploiting an integer overflow that leads to memory corruption. Affects Windows 10 (1607 through 22H2), Windows 11 (all versions through 26H1), and Windows Server 2012 R2. Microsoft has released security updates through their March 2026 Patch Tuesday. No active exploitation confirmed in CISA KEV at time of analysis, though the combination of low attack complexity (AC:L) and no user interaction requirement (UI:N) makes post-compromise exploitation straightforward for attackers who have already obtained initial access.