Remote Code Execution

Arbitrary code execution in IBM DataPower Gateway is possible when a user with existing local access to the appliance supplies crafted oversized input to a component that performs improper bounds checking, allowing an out-of-bounds write and, potentially, execution of arbitrary code in the appliance's process context. Affected release trains are 10.5.0.0 through 10.5.0.22, 10.6.0.0 through 10.6.0.10, 10.6.1 through 10.6.6, and 11.0.0.0 through 11.0.0.2; IBM has published a vendor fix, and no public exploit code was identified at time of analysis. Note that the vendor-assigned CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, score 9.8) characterizes this as remotely exploitable without privileges, which is inconsistent with the description's requirement for a local user and with the independent assessment of AV:L/AC:L/PR:L/UI:N - the local-access prerequisite is the practical limiter on real-world risk, while the impact if triggered remains full confidentiality, integrity, and availability loss.

Stack-based buffer overflow in IBM DataPower Gateway firmware tracks 10.5.0.0 through 10.5.0.22, 10.6.0.0 through 10.6.0.10, 10.6.1 through 10.6.6, and 11.0.0.0 through 11.0.0.2 allows an authenticated attacker holding administrative-level privileges to execute arbitrary code on the gateway. Exploitation is network reachable but gated by high attack complexity (AC:H), meaning the attacker depends on conditions they cannot fully control, such as a specific memory layout or parsing state, so a single deterministic trigger is not guaranteed; the assessed vector is CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H. There is no public exploit identified at time of analysis and the issue is not reported as confirmed actively exploited (CISA KEV); IBM has released patched builds via its support advisory.

Local privilege escalation in GlavSoft TightVNC Server for Windows before 2.8.88 allows an authenticated local user to execute arbitrary code with SYSTEM privileges by planting a malicious screenhooks32.dll or screenhooks64.dll where the TightVNC service will load it. DynamicLibrary::init() and ThemeLib call LoadLibrary() with bare file names and no LOAD_LIBRARY_SEARCH_* flags, so the service follows the default DLL search order and picks up an attacker-controlled copy from a writable directory that sits ahead of the legitimate file, such as an installation directory left with weak ACLs. Exploitation is constrained: it requires a pre-existing local session on the affected host plus a writable directory earlier in the search order, so it cannot be triggered remotely or unauthenticated; no public exploit identified at time of analysis.

Out-of-bounds write in IBM DataPower Gateway lets a remote, unauthenticated attacker corrupt memory and potentially execute arbitrary code on affected gateway builds (10.5.0.0 through 10.5.0.22, 10.6.0.0 through 10.6.0.10, 10.6.1 through 10.6.6, and 11.0.0.0 through 11.0.0.2), as reflected in the CVSS v3.1 vector AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H and a base score of 8.1. The PR:N/UI:N components mean no credentials or user interaction are required, so any network-reachable instance on an affected build is exposed, though the AC:H rating indicates exploitation depends on satisfying a non-trivial condition - most likely a specific input state, parsing path, or memory layout - to escalate the write beyond a crash into reliable code execution. Vendor patch data indicates a fix is available from IBM, and no public exploit code or confirmed active exploitation was identified at time of analysis; the EPSS score was not provided in the underlying intelligence, so no probabilistic exploitation estimate can be quoted.

Unauthenticated remote code execution affects IBM DataPower Gateway across multiple release streams - 10.5.0.0 through 10.5.0.22, 10.6.0.0 through 10.6.0.10, 10.6.1 through 10.6.6, and 11.0.0.0 through 11.0.0.2 - stemming from an out-of-bounds write (CWE-787) that corrupts memory and can be leveraged to run attacker-controlled code. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) confirms the flaw is reachable over the network with no authentication and no user interaction, making any internet- or partner-facing DataPower instance running an unpatched build a high-priority target. Exploitation status: no public exploit identified at time of analysis, and the issue is not listed in CISA KEV; patch available per vendor advisory (IBM support page node/7289775), with the specific fixed firmware builds published there.

Unauthenticated path traversal in the Ollama `/api/pull` endpoint lets a remote attacker write an arbitrary file outside the model store by submitting a crafted path-traversal sequence in the layer digest field, because the `digestToPath` function does not adequately validate digests before constructing a filesystem path. When the Ollama process can write to `/usr/lib/ollama` (described as the default in most Ollama Docker images) and the server or container is subsequently restarted, the planted binary is loaded and executed, yielding remote code execution as root; the same file-write primitive is available without authentication to anyone who can reach the API. The issue is fixed in Ollama 0.35.0, no public exploit code has been identified at time of analysis, CISA's SSVC assessment records exploitation as 'none', and no EPSS score was supplied in the source data. Real-world risk is high but conditional: exploitation of the full RCE chain depends on write access to `/usr/lib/ollama` and a restart, so deployments not using the default Docker image, running Ollama as a non-privileged user without write access to that directory, or not exposing the API to untrusted networks face substantially reduced exposure.

Remote, unauthenticated code execution is possible in IBM DataPower Gateway versions 10.5.0.0 through 10.5.0.22, 10.6.0.0 through 10.6.0.10, 10.6.1 through 10.6.6, and 11.0.0.0 through 11.0.0.2, because an out-of-bounds write in the RFC2047 encoded-word parser can corrupt memory and be leveraged to run arbitrary code. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, base 9.8) indicates the flaw is network-reachable with low complexity, requires no credentials and no user interaction, and carries full confidentiality, integrity, and availability impact, though exploitation depends on a reachable service or flow that passes attacker-controlled data through MIME encoded-word decoding. According to available intelligence there is no confirmed active exploitation (not listed in CISA KEV) and no public exploit code identified at time of analysis; the primary source is IBM's advisory at https://www.ibm.com/support/pages/node/7289775.

Heap-based buffer overflow in hMailServer 6.0.0 through 6.3.3 on Windows lets a local interactive user - with no hMailServer account - crash the mail server service and potentially execute code in its LocalSystem security context by passing an over-long hexadecimal string to the unauthenticated COM method Utilities.BlowfishDecrypt, which copies input of arbitrary length into a fixed 255-byte heap buffer. Because exploitation requires an existing local login (CVSS AV:L/PR:L) and the only confirmed outcome is a service crash, this is an access-gated local privilege-escalation/denial-of-service issue rather than a remotely wormable emergency; no public exploit identified at time of analysis. Vendor fix is available in hMailServer 6.3.4, which contains the reference commit 135a1908ff820ed587d5f180f98c53bd010d8931.

Local privilege escalation in hMailServer 6.0.0 through 6.3.5 on Windows allows an authenticated local user-one with an interactive logon but no hMailServer credentials-to abuse COM objects to read and write arbitrary files as the service account and send mail as any sender. The service registers its COM classes without DCOM launch or access permissions and calls CoInitializeSecurity with a null security descriptor, so any user logged on at the console or over Remote Desktop can activate hMailServer.Message, Attachments, and hMailServer.FetchAccount objects. If the service runs as LocalSystem (the default), arbitrary file write can lead to code execution as SYSTEM; no public exploit identified at time of analysis.

Local privilege escalation in Progressive Robot hMailServer 6.3.4 and 6.3.5 on Linux allows an attacker who already has code execution as the unprivileged hmailserver service account to run arbitrary code as root via the live-update apply helper (hmailserver-update). The vulnerability requires the live-update path unit to be active, which is the default for the project's .deb and .rpm packages and applies to AppImage installations run under that unit, but does not affect non-Linux builds. No public exploit code has been identified at time of analysis, and the vendor has released version 6.3.6 to address the issue.

Argument injection in WP Toolkit for cPanel allows local, low-privilege users with a valid hosting account to execute arbitrary code as other accounts on the same server. The vulnerability requires a multi-tenant deployment where untrusted local accounts coexist with WP Toolkit, as it is not remotely exploitable and needs no victim interaction. No public exploit code has been identified, but its high impact makes it a mid-to-high priority for shared and reseller hosting providers to patch promptly.

Path traversal in Brocade Active Support Connectivity Gateway (ASCG) before 3.5.0 lets an unauthenticated attacker write arbitrary files to restricted host locations by embedding traversal sequences in entries of a support-bundle archive that ASCG ingests from remote endpoints, with the potential for follow-on remote code execution if a written path is later executed or loaded. The attack is not internet-facing: exploitation is scored AV:A (adjacent network) with the CVSS 4.0 AT:P precondition, meaning the attacker must already control or be able to man-in-the-middle support bundles originating from a compromised or spoofed ingesting endpoint. No public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV, so the practical risk is a moderate, conditional one that depends on an attacker holding a management-network position and a compromised ingestion source rather than an urgent, broadly exploitable issue.

Authenticated code injection in Brocade ASCG before 3.5.0 allows network-adjacent attackers with low-privilege accounts to execute arbitrary code on the server by submitting crafted configuration form data that is evaluated before validation. The vendor CVSS 4.0 base score is 8.6 (High), and no public exploit identified at time of analysis. Exploitation requires a valid account and network adjacency, not anonymous Internet access.

Unrestricted file upload in the Super Forms - Drag & Drop Form Builder WordPress plugin (all versions up to and including 6.3.316) lets an attacker write attacker-controlled file types to the server, which can be turned into remote code execution. Exploitation is a two-step chain: an authenticated Subscriber-level user poisons the _super_elements post meta with a crafted extensions string through the super_save_form AJAX handler, which lacks capability and nonce checks, and then the super_upload_files endpoint - which requires no authentication at all - applies that string verbatim as its allowed MIME-type map and accepts an executable file. Rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), with the practical barrier being acquisition of a low-privileged account, which is trivial on sites with open registration; no public exploit identified at time of analysis.

Stack-based buffer overflow in the SNMP daemon of Brocade Fabric OS (all versions before 10.0.1) lets a remote, unauthenticated attacker crash or potentially execute code on affected switches by sending a specially crafted SNMPv3 packet. The flaw sits in an internal statistics handler that copies the attacker-supplied SNMPv3 context name into a fixed-size stack buffer without validating its length, producing memory corruption that the vendor says is reachable under default configuration. Per the assessed vector (AV:A/PR:N/UI:N, C/H/I/A:H), the attacker must be on an adjacent network segment with reachability to the switch's SNMP service (UDP/161) - a materially limiting factor, since switches with SNMP isolated on a dedicated management VLAN are much harder to hit - and no authentication or user interaction is required; no public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited.

Authenticated attackers with access to the adjacent management network can exploit stack-based buffer overflows in the REST API management component of Brocade Fabric OS versions prior to 10.0.1. By sending crafted API requests with oversized array counts or string lengths, an attacker can cause memory corruption, leading to a denial of service (daemon crash) or potentially arbitrary code execution within the management process. There is no public exploit identified at time of analysis, but the vulnerability is high severity (CVSS 8.6) and requires only low-privileged REST API credentials and network adjacency.

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.

Arbitrary code execution on the Vault host is achievable in HashiCorp Vault and Vault Enterprise when a privileged operator restores a crafted Integrated Storage (Raft) snapshot in a deployment configured with Shamir seals and an external plugin directory, because stored plugin catalog entries are not consistently verified to reference binaries inside that configured directory (CWE-22 path traversal). The attacker must already hold the high privileges needed to restore a Raft snapshot (CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:H/A:H), and exploitation also depends on the non-default Shamir-seal-plus-external-plugin-directory configuration, so this is a genuinely serious but condition-gated vulnerability rather than a mass-exploitation threat; clusters using auto-unseal or without an external plugin directory are not affected by this path. No public exploit identified at time of analysis, and vendor-released fixes are available in Vault Community Edition 2.1.2 and Vault Enterprise 2.1.2, 1.21.12, 1.20.17, and 1.19.23.

Remote code execution and denial of service in Cisco NX-OS Software are possible when the SRv6 OAM (NGOAM) and SRv6 features are both enabled, due to a stack-based buffer overflow (CWE-121) from improper input validation of IP traffic. An unauthenticated, remote attacker with network reachability to an IP interface can send crafted packets to execute arbitrary code with root privileges or cause a reload, resulting in a DoS condition. Exploitation requires the non-default configuration of both NGOAM and SRv6 features; no public exploit was identified at time of analysis, and no CISA KEV listing exists.

Remote code execution with root privileges and denial-of-service in Cisco NX-OS Software can be triggered by unauthenticated network attackers when the NGOAM (VXLAN OAM) feature is enabled. Crafted IP packets sent to a device IP interface exploit improper input validation (stack buffer overflow, CWE-121), allowing arbitrary code execution or process crashes that reload the device. No public exploit identified at time of analysis; the non-default NGOAM configuration requirement limits exposure, but this remains a high-priority vulnerability per our independent assessment.

Remote code execution in Cisco License On-Prem (formerly Cisco Smart Software Manager On-Prem) lets a network-positioned attacker who holds only low-privilege credentials inject and execute code on the appliance, resulting in complete loss of confidentiality, integrity, and availability (CVSS 3.1 base 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The flaw is one of multiple internally discovered code-injection weaknesses (CWE-94) that Cisco addressed in a bundled hardening release for the product, so the specific vulnerable endpoint is not individually itemized in the advisory. There is confirmed actively exploited status neither reported nor any public exploit identified at time of analysis, but the low-complexity, no-user-interaction profile and requirement for only an ordinary authenticated account make rapid patching of internet- or partner-reachable instances important; exploitation status is best described as no public exploit identified at time of analysis.

Unauthenticated remote attackers with IP reachability to an affected Cisco NX-OS device can achieve arbitrary code execution with root privileges - or force a process crash and device reload - by sending crafted packets to the VXLAN Operation, Administration, and Maintenance (NGOAM) feature. The flaw is a stack-based buffer overflow (CWE-121) triggered by insufficient validation of IP traffic, and it is fully unauthenticated and requires no user interaction per the CVSS vector (AV:N/AC:L/PR:N/UI:N), yielding a 9.8 base score. Exploitation is gated by configuration: NGOAM is not part of a default NX-OS base image and must be explicitly enabled, so only VXLAN deployments that have turned the feature on and that expose an IP interface to the attacker are exposed; no public exploit code or confirmed active exploitation was identified at time of analysis, but the high EPSS-relevant severity and pre-auth RCE impact warrant priority patching on any NGOAM-enabled fabric.

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.

Unauthenticated, remote code execution with root privileges and denial of service in Cisco NX-OS Software on Nexus 3000 Series and Nexus 9000 Series switches, rated CVSS 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). A crafted MPLS echo-request packet sent to an IP address on an affected device is processed without proper validation, letting an attacker execute arbitrary code as root and crash critical processes, which can force a device reload. The decisive exposure prerequisite is that the MPLS OAM feature must be enabled and reachable, and MPLS OAM is not on by default in most deployments; there is no public exploit identified at time of analysis and no KEV listing is indicated by the provided intelligence.

Python code injection in PraisonAI's deploy tooling (all versions up to and including 4.6.77) lets a high-privileged actor who controls the `agents_file` value break out of an f-string and execute arbitrary code on the host running the deploy command. The flaw is triggered at build/deploy time: the unsanitized value is interpolated into generated server or Dockerfile source in `deploy/api.py` and `deploy/docker.py`, written to disk, and then launched via `subprocess.Popen(['python', server_file])`, so the primary realistic exposure is CI/CD pipelines or shared build environments where `agents_file` originates from externally influenced configuration. The vendor advisory includes a proof-of-concept demonstrating the string-breakout payload and a fix is available in 4.6.78; no CISA KEV entry or other confirmation of active exploitation was present in the source data, and this is not a remotely reachable flaw in a default running service - exploitation requires the attacker to already be positioned to set or tamper with deploy-time input and for someone to invoke the deploy command.

Unauthenticated remote code execution in LMCache through 0.5.5 allows network-reachable attackers to execute arbitrary Python and operating-system commands as the LMCache process by posting scripts to the /run_script endpoint; the endpoint's existing __import__ guard is bypassed via the injected FastAPI app object, which exposes real builtins (CWE-306, CVSS 9.3 v4.0 / 3.1 AV:N/AC:L/PR:N/UI:N). No public exploit code or confirmed in-the-wild activity has been identified at time of analysis, though the vulnerability details and vendor advisory are public. The primary limiting factor is deployment exposure: exploitation requires the internal API HTTP server to be enabled and bound to a network-accessible interface rather than restricted to localhost or a trusted management network.

Authenticated remote code execution in the @backstage/plugin-techdocs-node package shipped with the Backstage developer portal framework allows a user who can register or influence an SCM-backed documentation source to execute arbitrary code on the TechDocs backend host. The flaw (CWE-502, CVSS 8.8, vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) arises because mapping-style markdown_extensions entries in a committed mkdocs.yml were not sanitized, letting an attacker name Python callables such as subprocess:Popen or os:system that MkDocs then imports and instantiates during documentation generation. Exploitation requires a valid account and an instance that performs server-side TechDocs generation of attacker-controlled sources, so risk is highest where generation runs with backend credentials, filesystem access, or internal network reachability; no public exploit code has been identified at time of analysis and there is no confirmed active exploitation (CISA KEV).

Remote code execution on TechDocs build hosts affects Backstage deployments running the @backstage/plugin-techdocs-node mkdocs generator prior to 1.14.6 (and 1.15.x prior to 1.15.4). An authenticated user holding the privilege to register or update catalog entities can commit a crafted mkdocs.yml whose markdown_extensions entries point at dangerous Python callables such as subprocess:Popen, os:system, or plantuml_markdown's plantuml_cmd, which mkdocs instantiates and executes while building the docs; the flaw requires authentication and an entity-registration permission rather than anonymous access, and deployments that publish pre-built docs or build in isolated disposable runners have a much smaller blast radius. The upstream fix, which extends MkDocs configuration sanitization to cover nested configuration keys, hyphenated extension names, and theme options, is available in vendor-released versions 1.14.6 and 1.15.4, and no public exploit code tied to this CVE was identified at time of analysis beyond the payload fixtures included in the upstream fix commit.

Post-authentication OS command injection in SonicWall SMA1000 firmware (12.5.0-02952 and 12.4.3-03526 platform-hotfixes and older) allows an attacker with administrator credentials to execute arbitrary OS commands, leading to remote code execution. The independent assessment rates this as a moderate priority due to the requirement for valid administrator credentials and undisclosed 'specific conditions'; no public exploit code has been identified at time of analysis. The vendor CVSS vector (AV:L) differs from the assessed network vector, and exploitability may be further limited by configuration-specific factors.

Remote code execution in SonicWall SMA1000 (Appliance Management Console) can be triggered by an authenticated administrator who uploads a crafted archive containing path traversal sequences, allowing files to be written outside the intended extraction directory and leading to code execution. The vulnerability is a classic Zip Slip (CWE-22) issue with a CVSS 3.1 score of 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), meaning an attacker must already hold high/administrative privileges on the AMC-a significant precondition that sharply limits the pool of realistic attackers to compromised or malicious administrators. No public exploit code or active exploitation has been identified at time of analysis (SSVC exploitation: none), so this is a conditional high-severity risk rather than a mass-exploitation emergency.

Authenticated attackers holding BugTracker.NET administrator privileges can achieve server-side code execution by first reconfiguring the application so that attachments are stored in a web-accessible directory, then uploading an .aspx file that the attachment feature fails to filter by extension. Because the uploaded file lands in a location the web server serves and ASP.NET/IIS will process executable handlers there, requesting its URL runs arbitrary code under the web service account. Exploitation is heavily gated: it requires PR:H administrator access and a non-default storage configuration (reflected as AT:P in the CVSS 4.0 vector), and no public exploit code has been identified at time of analysis; the signals consistently describe this as a low real-world priority issue despite a high CVSS 4.0 base score of 7.5.

Unauthenticated code injection in the upgrade script shipped with Movable Type allows a remote attacker to execute an arbitrary Perl script or run an SQL query against the affected installation once the upgrade handler is reachable over the network. The flaw affects Movable Type, Movable Type Premium, and their Cloud Editions (Six Apart), and carries a critical severity rating (vendor CVSS 9.4; our assessment scores availability impact as High rather than Low, yielding CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Per the CVSS vector (AV:N/AC:L/PR:N/UI:N) no authentication or user interaction is required, but the practical prerequisite is exposure of the installation/upgrade endpoint: sites that remove, restrict, or firewall the upgrade script after installation are substantially less reachable, while sites leaving it publicly accessible are directly exploitable. No public exploit code and no confirmed active exploitation were identified at time of analysis, so the immediate risk is driven by mass internet exposure of the endpoint rather than by observed attacks.

A stack-based buffer overflow in Zephyr's Bluetooth Mesh On-Demand Private Proxy solicitation handler lets any BLE device within radio range overwrite a target node's stack with attacker-controlled bytes by sending a non-connectable advertisement carrying an oversized mesh Proxy Solicitation. Exploitation requires no pairing, bonding, provisioning, or key material because the vulnerable copy happens before decryption, but it is limited to nodes built with CONFIG_BT_MESH_OD_PRIV_PROXY_SRV that are currently eligible to be solicited (GATT Proxy disabled, On-Demand Private Proxy enabled) and physically within BLE range (CVSS 8.8, AV:A/PR:N/C:H/I:H/A:H, unauthenticated). Impact ranges from a reliable remote denial of service to plausible remote code execution; no public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, and a vendor fix is available.

Unauthenticated remote code execution in Manacle Multi-Tenant ERP allows attackers to execute arbitrary code or manipulate application data through unsafe deserialization of user-controlled input (CWE-502). The vulnerability (CVE-2026-107104) is rated critical with a CVSS 4.0 score of 9.3 and requires no privileges or user interaction to exploit (PR:N/UI:N). No public exploit or active exploitation is known at time of analysis, but the high impact to confidentiality and integrity, combined with network reachability, makes this a high-priority risk.

Unauthenticated PHP object injection in the String Locator WordPress plugin (versions before 2.6.8) lets an attacker store a crafted serialized PHP object in a database row via the plugin's database editor, with no authentication required (PR:N per the assessed vector). The payload only fires when a site administrator subsequently opens and saves that row in the editor, which is the UI:R precondition, and it escalates to remote code execution, arbitrary file deletion, or sensitive data disclosure only if a suitable POP gadget chain exists in another installed plugin or component, which is why our independent assessment rates attack complexity as High (AC:H) despite the raw CVSS 8.8 vector using AC:L. Publicly available exploit code exists, but the two gating conditions (an admin save action plus a usable gadget chain) meaningfully reduce real-world exploitability, and no CISA KEV listing confirms active exploitation.

Authenticated users holding the WordPress Editor role on sites running the WP Coder plugin (versions 4.0 up to but not including 4.5.2) can save and execute arbitrary PHP code on the server, resulting in full site compromise. The flaw is a privilege-boundary failure: the plugin gates its PHP code-execution feature on a content capability that the Editor role holds by default rather than restricting it to administrators, so no plugin misconfiguration is needed. Exploitation requires an existing Editor-level (or higher) account - it is not remote-unauthenticated - but publicly available exploit code exists, and the vendor has released WP Coder 4.5.2 to fix it. No confirmed active exploitation (CISA KEV) has been reported, so risk is concentrated on sites that hand Editor access to semi-trusted contributors.

Heap memory corruption in the X.Org X server (prior to 21.1.25) and Xwayland (prior to 24.1.14) arises from a cluster of flaws disclosed in the October 2026 X.Org security advisory, for which CVE-2026-93524 serves as the coordinating identifier. An authenticated local X client that can already open and authenticate to the display socket can trigger double-free, use-after-free, numeric-truncation and heap buffer overflow conditions across the XKB, Present, XInput, GLX and XFixes extensions, causing server crashes and - where heap layout protections are defeated - potentially arbitrary code execution. The assessed vector is CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H; no public exploit code, EPSS score or CISA KEV listing was present in the source data, so no public exploit is identified at time of analysis, and the advisory text does not state the specific trigger conditions for CVE-2026-93524 itself.

Multiple memory-safety defects in X.Org X server prior to xorg-server-21.1.25 and Xwayland prior to xwayland-24.1.14 let an authenticated X client corrupt server heap and stack memory through crafted XKB, Present, XInput2, GLX and XFixes protocol requests, causing crashes or potentially arbitrary code execution inside the X server process. The flaws include a double free in XKB SetGeometry TextDoodad handling, use-after-frees in the Present cross-window notify path and in XInput passive grabs after XIRemoveMaster, heap overflows in GLX RenderLarge and XkbResizeKeyType, an XFixes pointer-barrier event buffer overflow, and an incomplete-fix out-of-bounds write in the XKB ChangeKeycodeRange path. Exploitation requires a connection already authorized to the X server (typically a local user session, an X11-forwarded session, or a multi-seat/shared-display host); no public exploit code and no confirmed in-the-wild exploitation have been identified at time of analysis, and the assessed vector is CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. Pure-Wayland deployments that do not run Xwayland are not exposed.

Heap buffer overflow in X.Org X Server versions prior to 21.1.25 and in Xwayland prior to 24.1.14 stems from an integer truncation inside XkbResizeKeyType(), where the computed key-symbol count is stored in an unsigned short and wraps for sufficiently large nTotal values, yielding an undersized allocation that subsequent writes overflow. The X.Org advisory of October 2026 states the trigger is an X client sending crafted XKB requests that resize a key type with a large nTotal; because no CVSS vector was supplied, authentication requirements are not confirmed from available data, and the advisory's own phrasing describes the actor as an authenticated X client. No CVSS score, EPSS estimate, CISA KEV listing, or public exploit code was available at time of analysis, so no public exploit identified at time of analysis; the vendor assesses the impact as heap corruption that can lead to arbitrary code execution or denial of service. This CVE is one of seven flaws disclosed together in the same X.Org security advisory.

Heap-based buffer overflow in X.Org X server and Xwayland GLX RenderLarge request handling allows an authenticated local X client to write past the allocated heap buffer, potentially achieving arbitrary code execution or causing denial of service. Affected versions are xorg-server prior to 21.1.25 and Xwayland prior to 24.1.14; the attacker must already be able to open an X display with GLX available, which by default means local Unix-socket access rather than remote unauthenticated access. No public exploit identified at time of analysis.

Buffer overflow in X.Org X Server's XFixes extension (and Xwayland) allows an authenticated local X client to trigger a stack or heap overflow by creating more than 100 pointer barriers and generating pointer motion events, potentially leading to arbitrary code execution or denial of service. The flaw, tracked as CVE-2026-93519, affects X.Org X server versions prior to 21.1.25 and Xwayland versions prior to 24.1.14. No public exploit code or active exploitation has been identified at time of analysis; independent assessment assigns a CVSS 3.1 vector of AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H.

A use-after-free in the XInput2 passive grab handling of X.Org X server builds prior to xorg-server-21.1.25 and Xwayland prior to xwayland-24.1.14 allows an authenticated client that can add and remove XI2 master devices to crash the server or potentially achieve arbitrary code execution. The attacker creates a passive grab whose modifierDevice points at a master device, then calls XIRemoveMaster to free that device; the grab retains a dangling DeviceIntPtr that later input processing dereferences, corrupting the heap. Reaching the vulnerable code requires a valid client connection to the X server or Xwayland (typically local, since modern X servers do not listen on TCP by default) and the XI2 extension, which is enabled by default; no public exploit code and no CISA KEV entry have been identified at time of analysis.

Heap-based buffer overflow in X.Org X server and Xwayland's glamor acceleration backend (glamor_upload_boxes) allows an authenticated local X client to cause memory corruption, potentially leading to arbitrary code execution or denial of service. The flaw occurs when a 24-bit drawable is used with a 32-bit pixmap and crafted dimensions trigger an integer overflow in size calculation, affecting X.Org X server versions prior to 21.1.25 and Xwayland versions prior to 24.1.14. No public exploit code or active exploitation has been identified at time of analysis, but the vulnerability requires a local authenticated connection and glamor hardware acceleration to be enabled.

Use-after-free in the Present extension of X.Org X server before 21.1.25 and Xwayland before 24.1.14 lets an authenticated X client crash the display server and potentially expose limited process memory. An attacker with the ability to open an X display connection creates cross-window Present notify entries pointing at a separate target window and then destroys that window, so the freed per-window notify list is traversed after present_clear_window_notifies() releases the window's private data without unlinking the entries; both the Present and SYNC extensions must be enabled, which they are by default. The issue is a local, low-privilege, user-interaction-free memory-safety bug (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:H), and no CISA KEV listing, EPSS score, or public exploit code was identified at time of analysis.

Heap out-of-bounds write in the X.Org X server (versions prior to xorg-server-21.1.25) and Xwayland (versions prior to xwayland-24.1.14) allows an authenticated X client to corrupt heap memory by issuing an XkbChangeKeycodeRange request that sets a keycode range where MAP_LENGTH exceeds max_key_code+1, leaving XkbAllocNames under-allocated while the subsequent memset writes MAP_LENGTH bytes. The flaw is an incomplete fix of an earlier XKB keycode-range change (commit a3171732d) and is scored locally as CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, meaning the attacker must already hold an authorized X connection - a local session, a compromised GUI application on the same display, or a forwarded X session - rather than merely reaching the host over the network. No CVSS vector, EPSS score, KEV listing, or public exploit code is present in the supplied data, so this analysis rests solely on the X.Org advisory text and no public exploit has been identified at time of analysis; the same October 7, 2026 advisory bundles six further memory-safety issues (CVE-2026-88812, -93515, -93516, -93517, -93518, -93519) fixed in the same releases.

Heap buffer overflow in the glamor acceleration path of the X.Org X server (and Xwayland) allows an authenticated local X client to corrupt the server's heap, with the potential for code execution or a server crash, although reliable exploitation is assessed as high-complexity. The flaw is addressed in the October 2026 X.Org security release, which fixes a bundle of XKB, Present, XInput, GLX and XFixes issues in xorg-server 21.1.25 and xwayland 24.1.14. No public exploit code and no CISA KEV entry were identified at time of analysis; no CVSS vector or EPSS score was supplied for this CVE, and the input itself does not contain a CVE-2026-93523 advisory entry, so the mapping of this identifier to the glamor size-calculation overflow is inferred from an associated upstream commit rather than confirmed by vendor text.

A double free in the X.Org X server's XKB SetGeometry request handler (CVE-2026-88812) lets an authenticated X client that is already able to connect to the target display corrupt heap memory by sending a crafted XkbSetGeometry request containing a malformed TextDoodad entry, with outcomes ranging from a server crash to potential arbitrary code execution. Only builds of xorg-server prior to 21.1.25 and Xwayland prior to 24.1.14 are affected, and the XKB extension required for the trigger is standard and enabled by default. The assessed vector is CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, meaning exploitation presupposes an existing local/same-session X connection rather than remote or unauthenticated access, and no public exploit code, EPSS score, or CISA KEV entry appears in the supplied data, so reliable code execution additionally depends on defeating heap allocator hardening.

A stack-based buffer overflow in ASUS router firmware modules lets an attacker who already holds administrative credentials on the device and is connected to the same local or Wi-Fi network segment execute arbitrary code by uploading a crafted configuration file that exceeds an expected buffer size. The flaw is rated CVSS 4.0 9.3 (Critical) and assessed as CVSS 3.1 AV:A/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, because successful exploitation yields full compromise of confidentiality, integrity and availability of the router, although the adjacent-network (AV:A) and high-privilege (PR:H) requirements exclude anonymous Internet-wide attack. No public exploit code has been identified at time of analysis, the issue is not listed in CISA KEV, and no EPSS score was supplied; vendor guidance is available through the ASUS Security Advisory.

Remote code execution affects IBM Langflow OSS versions 1.0.0 through 1.12.2, where improper access control lets an attacker with a valid low-privilege account execute arbitrary code on the server. The flaw is network-reachable with low attack complexity and no user interaction (CVSS 3.1: AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8), but it is gated by the requirement to hold an authenticated account, so exposure is greatest where the platform offers open self-service registration, uses shared credentials, or is internet-facing without network restrictions. No public exploit code has been identified and the issue is not listed as confirmed actively exploited (CISA KEV) at time of analysis; exploitation status and patch availability should be re-checked against the IBM advisory.

Authenticated remote code execution affects IBM Langflow OSS 1.0.0 through 1.12.2, where improper control of code generation lets any account with at least low privileges (CVSS PR:L, AV:N, UI:N) cause attacker-supplied code to run server-side on the Langflow host, yielding high confidentiality, integrity, and availability impact (CVSS 8.8). Exploitation is not possible against a default install without valid credentials, and no public exploit code or confirmed active exploitation was identified at time of analysis. The practical exposure therefore concentrates on internet-reachable or multi-tenant instances that permit self-registration or host untrusted users; isolated, single-tenant, network-restricted deployments with trusted operators carry substantially lower risk.

Authenticated code injection in IBM Langflow OSS 1.0.0 through 1.12.2 lets any remote user holding a valid low-privileged account execute arbitrary code on the hosting server, with high impact to confidentiality, integrity, and availability (CVSS 8.8, PR:L, no user interaction required). The attack surface is the code path where special elements used in code are not properly neutralized (CWE-94), so deployments that allow untrusted or self-registered accounts to author and run flows are the most exposed, while instances with closed registration and no internet exposure are materially less at risk. No public exploit code has been identified at time of analysis, EPSS is only 0.58% (46th percentile), and CISA SSVC rates exploitation as 'none', making this a serious-but-not-emergency issue; a vendor patch is available per IBM's advisory.

Authenticated remote code execution in IBM Langflow OSS 1.0.0 through 1.12.2 allows a low-privileged user to run arbitrary code because the platform improperly controls generation of executable code (CWE-94). Exploitation requires only a valid account on the instance (CVSS PR:L, AV:N, AC:L, UI:N), so an attacker who holds or obtains any credential able to create, import, or execute a flow/component that reaches the vulnerable code-generation path can achieve full confidentiality, integrity, and availability impact on the host. No public exploit code was identified at time of analysis, CISA's SSVC assessment records exploitation as "none", and EPSS is 0.58% (46th percentile), placing this as a genuinely serious but not emergency-tier issue whose real-world risk scales with how exposed the Langflow instance is and how freely low-privilege accounts are provisioned.

Remote code execution in IBM Langflow OSS versions 1.0.0 through 1.12.2 allows an authenticated attacker with flow-authoring privileges to inject and execute arbitrary code through Langflow's code-generation mechanism (CWE-94). The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) rates this as high severity (8.8), requiring network reachability, low privileges, and no user interaction; however, in typical deployments where flow creation or modification is broadly granted, the practical barrier may be lower than the PR:L metric implies. No public exploit code or CISA KEV entry has been identified at time of analysis, and EPSS is 0.61% (48th percentile); IBM has released a vendor patch.

Remote code execution can result in IBM Langflow OSS 1.0.0 through 1.12.2 through a dependency confusion weakness, where the product resolves an expected dependency from a public package registry instead of the intended trusted source. The CVSS vector (AV:N/AC:L/PR:N/UI:N) indicates an unauthenticated remote attacker with no user interaction required, and the unpatched severity is rated 9.8; however, our independent assessment lowers the attack complexity to AC:H because successful exploitation depends on the attacker knowing or guessing the exact dependency name and on the victim's resolver preferring an attacker-published public package over the legitimate one, typically during an install, build, or import event rather than against a running service. There is no confirmed active exploitation (CISA KEV does not list this CVE), SSVC records Exploitation: none and Automatable: no, no public exploit code has been identified at time of analysis, and EPSS is only 0.68% (51st percentile), so the practical near-term risk is materially lower than the 9.8 headline suggests. A vendor patch is available per the IBM advisory.

Unauthenticated remote code execution in IBM Langflow OSS 1.0.0 through 1.12.2 lets any attacker who can reach the service execute arbitrary operating system commands on the underlying host. Rated CVSS 3.1 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), the flaw requires no credentials, no user interaction, and no non-default configuration, so a default Langflow deployment exposed beyond localhost is directly exploitable. There is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV); IBM has published a vendor advisory with a fix, and practical risk is concentrated in self-hosted developer instances that are bound to reachable interfaces rather than being restricted to localhost or placed behind authentication and firewalling.

Remote code execution in IBM Langflow OSS 1.0.0 through 1.12.2 lets a remote attacker who already holds a valid low-privilege session execute arbitrary code on the host by sending a crafted request that bypasses improper input validation. The flaw is network-reachable, low complexity, and requires no user interaction (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8), so the authentication requirement is the main barrier; deployments with open or self-service sign-up, internet exposure, or multi-tenant use carry the highest risk. No public exploit code was identified at time of analysis and the issue is not confirmed as actively exploited (no CISA KEV listing); the vendor has released a fix.

Authenticated remote code execution in IBM Langflow OSS 1.0.0 through 1.12.2 lets any holder of valid credentials - even a low-privileged one - submit or edit a flow that reaches the server-side code-generation and execution path, resulting in arbitrary OS command execution on the Langflow backend. IBM scores it 8.1 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N) and classifies the root cause as CWE-94 code injection; no public exploit code has been identified at time of analysis and there is no CISA KEV listing, so active exploitation is not confirmed. The decisive risk factor is deployment posture: internet-exposed or multi-tenant instances running with authentication disabled, default or shared credentials, or open self-registration collapse the PR:L barrier and behave like unauthenticated RCE targets.

Authenticated remote code execution in IBM Langflow OSS 1.0.0 through 1.12.2 lets any user who can log in to the instance run arbitrary code on the host, because the platform fails to properly constrain attacker-supplied input before it reaches a code-execution path. The flaw carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning low-complexity, network-reachable exploitation that requires only a low-privileged account but yields full confidentiality, integrity, and availability impact - no user interaction and no elevated privileges are needed. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation, but IBM has published a vendor advisory with a fix, so the practical exposure is greatest for organizations that expose Langflow to untrusted networks or provision accounts broadly.

Remote code execution in IBM Langflow OSS versions 1.0.0 through 1.12.2 allows an authenticated attacker to run arbitrary operating-system commands by supplying crafted input to a component that fails to neutralize special elements before passing them to an OS command or code-evaluation path (CWE-94). Per the assessed CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), exploitation requires a valid low-privilege authenticated session on the Langflow instance, needs no victim interaction, and yields full confidentiality, integrity, and availability impact on the affected host. No public exploit code was identified at time of analysis, and the issue is not confirmed as actively exploited (CISA KEV); the practical risk is concentrated on network-exposed Langflow servers that use weak, shared, or default credentials, since a compromised or low-privilege account is the only prerequisite.

Authenticated remote code execution affects IBM Langflow OSS versions 1.0.0 through 1.12.2, where an incomplete blocklist in the built-in code security scanner can be bypassed to execute arbitrary code on the server. Exploitation requires a valid low-privilege account (CVSS PR:L) and the ability to submit code evaluated by the scanner; unauthenticated attackers are not sufficient. No public exploit code has been identified at time of analysis and there is no CISA KEV listing, though the high CVSS base score of 8.8 and the multi-tenant exposure of typical Langflow deployments make the risk significant where untrusted users can register or be provisioned.

Remote code execution in IBM Langflow OSS 1.0.0 through 1.12.2 lets an authenticated attacker escape the application's code execution sandbox and run arbitrary commands on the host. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N) confirms network reachability and a low-privileged authenticated session as the only precondition, with no user interaction required. No public exploit code has been identified at time of analysis and there is no CISA KEV entry, but the low complexity and high impact make this a genuine prioritization concern for internet-exposed or multi-tenant deployments.

Remote code execution in IBM Langflow OSS 1.0.0 through 1.12.2 allows attackers to execute arbitrary code via improper control of code generation (CWE-94). The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, base 9.8) indicates remote, unauthenticated, low-complexity exploitation with full confidentiality, integrity, and availability impact, though the independent assessment notes the pre-auth condition is not independently confirmed by the description. A vendor patch is available, and no public exploit code has been identified at time of analysis; risk is highest for internet-exposed instances within the affected version range.

Deserialization of untrusted data in NVIDIA Model-Optimizer (CVSS 3.1 base score 7.8) allows an attacker who supplies a crafted model artifact to achieve code execution, data tampering, denial of service, and information disclosure on the machine that loads it. The assessed vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) shows the severity comes from full loss of confidentiality and integrity once the payload runs, but the attacker must first get the victim to open or deserialize the malicious artifact in a local processing environment, so there is no remote, zero-interaction path. No public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV, so this is a credible but priority-setting issue for ML/AI pipelines that ingest third-party models rather than an emergency remote-exploitation case.

Arbitrary code execution in Backstage TechDocs documentation builds allows an authenticated user with write access to a repository registered in the Backstage catalog to run commands on the build host by embedding malicious keys in the repository's mkdocs.yml. Both TechDocs build modes configured locally or in a container (techdocs.generator.runIn set to 'local' or 'docker') are vulnerable because the affected @backstage/plugin-techdocs-node package (prior to 1.14.6, and 1.15.0 through 1.15.3) failed to sanitize nested markdown_extensions and theme configuration values before invoking MkDocs. Exploitation is access-gated rather than anonymous: CVSS 3.1 scores this 8.8 with a PR:L vector, EPSS is low at 0.26% (16th percentile), CISA SSVC rates exploitation as none and automatable as no, and no public exploit code has been identified at time of analysis.

Arbitrary code execution on the TechDocs backend host is achievable through a sanitizer bypass in the @backstage/plugin-techdocs-node package prior to versions 1.14.6 and 1.15.4, where crafted MkDocs configuration keys (notably extra_templates) evade the allowlist filter originally added to fix CVE-2026-25153. Exploitation is not anonymous: an attacker must hold write/commit access to a repository onboarded into a TechDocs-enabled Backstage instance (PR:L, authenticated), and must defeat an existing hardened sanitizer (AC:H), after which the malicious configuration executes automatically during documentation generation with no further user interaction (UI:N) and can compromise confidentiality, integrity, and availability of the backend host and, per the S:C scope change, potentially beyond it. No public exploit code has been identified at time of analysis, CISA KEV does not list this issue, SSVC rates exploitation as none and automatable as no, and EPSS is low at 0.27% (18th percentile), making this a genuine but conditional priority rather than a drive-by critical. This is a genuine but conditional priority, not a drive-by critical.

Arbitrary code execution in AWS Bedrock AgentCore Starter Toolkit before 0.3.14 allows an authenticated same-account actor to inject malicious Python code into generated agent source by importing a crafted Bedrock Agent configuration, which executes when the victim runs or deploys the agent. Exploitation requires the victim to import and then run or deploy the agent, and the actor must have valid same-account credentials. No public exploit identified at time of analysis; remediation requires upgrading to 0.3.14 and re-importing any previously affected agents because the generated source persists.

Authenticated remote code execution in HPE Networking ClearPass Policy Manager allows an attacker who already holds high-privilege administrative access to the management interface to run arbitrary commands on the underlying operating system, potentially leading to full host compromise. The flaw is remotely reachable (AV:N), requires no user interaction (UI:N) and has low attack complexity (AC:L), but its severity is bounded by the CVSS PR:H prerequisite - only administrator-level accounts can trigger it, so exploitation realistically depends on credential compromise, insider access, or chaining from a separate authentication or privilege-escalation weakness. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing); with a base score of 7.2, this is assessed as a moderate-priority issue rather than a top-tier emergency, though the confidentiality, integrity and availability impact on a successful hit is high.

Buffer overflow in the HPE Aruba ClearPass Policy Manager OnGuard agent lets an authenticated local user execute arbitrary code with elevated privileges or crash the agent, disrupting endpoint posture enforcement. Exploitation requires an existing low-privileged session on the endpoint where the agent is installed and running and cannot be triggered remotely, since the attack vector is local (AV:L, PR:L) while the privilege gain is High across confidentiality, integrity, and availability. HPE has published a vendor advisory, but no public exploit code has been identified at time of analysis; at CVSS 7.8 this is a credible but not emergency-level priority, most relevant to hosts where unprivileged local users and the OnGuard agent coexist.

Missing integrity verification in the HPE Networking ClearPass Policy Manager client agent allows remote unauthenticated attackers to introduce untrusted code that the agent then executes on the enrolled client system, giving full code execution on that endpoint. Only systems running the vulnerable client agent (for example OnGuard deployments) are exposed; the ClearPass server itself is not the target of this flaw, and organizations that do not deploy the agent are unaffected. The input CVSS of 9.8 reflects the worst case, but the authoritative independent assessment scores it AV:N/AC:H, because the attacker must first be able to supply or substitute the code the agent consumes - typically a man-in-the-middle position on the agent's communication or update channel, or control of a source the agent implicitly trusts. There is no evidence of confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis, so the practical risk is conditional on the attacker obtaining that network positioning or trusted-source access.

Authenticated path traversal in the ClearPass Policy Manager command line interface allows a low-privileged remote user to escape the intended file path context and execute arbitrary code with elevated privileges on the underlying operating system. The flaw is rated CVSS 3.1 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning it is network-reachable, low complexity, requires only valid low-privilege CLI credentials and no user interaction, and yields full confidentiality, integrity, and availability impact. Exploitation prerequisites are non-trivial: the attacker must already hold valid authenticated access to the ClearPass CLI, so exposure is bounded by how broadly low-privilege appliance accounts are provisioned and by how tightly management-plane access is restricted; no public exploit code was identified at time of analysis and there is no confirmed active exploitation (CISA KEV).

Unauthenticated remote code execution is the exposure created by a format string flaw in a service interface of HPE Networking ClearPass Policy Manager: an attacker who can reach the vulnerable interface can supply crafted input that corrupts process memory and, on successful exploitation, execute arbitrary code in the context of the affected service, with high confidentiality, integrity and availability impact (CVSS 3.1 9.8, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). No public exploit code or confirmed active exploitation is identified at the time of analysis, and the report originates from HPE's own security-alert address, but the absence of authentication, user interaction or attack complexity means exploitation is straightforward for any attacker with network reachability to the interface. The practical limiting factor is exposure: ClearPass management and service interfaces are normally confined to segmented management networks, so internet-facing or user-network-reachable deployments carry the greatest immediate risk.

Missing integrity verification in the HPE ClearPass Policy Manager OnGuard agent allows an unauthenticated, remote attacker to execute arbitrary code with the agent's elevated privileges on managed endpoints. In practice, exploitation requires the attacker to intercept, modify, or impersonate the data/update channel the agent trusts (e.g., adversary-in-the-middle or rogue server), meaning the vendor's low-complexity rating (CVSS 9.8) is tempered by this positioning requirement. No public exploit code has been identified at time of analysis, and there is no indication of active exploitation (not in CISA KEV).

Unauthenticated remote code execution in the web interface of HPE Networking ClearPass Policy Manager allows an attacker who can reach that interface over the network to run arbitrary code on the appliance. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) confirms no authentication, no user interaction, and low attack complexity, with full confidentiality, integrity, and availability impact - a genuine high-priority vulnerability rather than a high-CVSS-but-low-risk artifact. No public exploit identified at time of analysis; the practical limiting factor is network exposure of the ClearPass web interface, so deployments reachable from the internet or broad internal networks are at direct risk while those restricted to isolated management networks or behind VPN/firewall controls are substantially less exposed.

Memory corruption flaws in HPE Aruba Networking AOS-S switch firmware allow an unauthenticated attacker who is positioned on the same Layer-2/adjacent network segment to corrupt memory and potentially execute arbitrary code on the switch (CVSS 9.6, AV:A/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H). Exploitation requires network adjacency - a directly connected device, a compromised host on the same VLAN/broadcast domain, or an attacker already inside the local network - but within that position no credentials and no user interaction are needed, and attack complexity is low, so default-configured, unpatched switches are exposed by sending crafted traffic to the vulnerable handler. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, and the primary exposure limiter is physical/logical access to the switch segment rather than remote internet reachability.

Unauthenticated remote code execution affects the AOS-S switch firmware line from HPE Aruba, where a buffer overflow in a network-facing interface can be triggered by a remote attacker without credentials, user interaction, or a privileged network position (CVSS 9.8, AV:N/AC:L/PR:N/UI:N, full confidentiality, integrity, and availability impact). The practical barrier to exploitation is reachability of the specific affected interface on the switch rather than any authentication control, so switches whose management or service interfaces are exposed beyond a segmented management network carry the highest risk. No public exploit code and no confirmed active exploitation were identified at time of analysis, but the advisory does not name the vulnerable service, port, protocol, or the affected and fixed firmware versions, so defenders must confirm exposure against HPE bulletin hpesbnw05156en_us.

Code execution in Handlebars.js versions 4.0.0 through 4.7.9 occurs when an application hands an attacker-controllable, pre-parsed AST object - rather than a template string - to Handlebars.compile() or Handlebars.precompile(); the compiler writes JavaScript expressions carried in unchecked AST fields straight into the generated code, which then executes in the server process wherever the compiled output runs. The flaw is an incomplete fix: the AST validation added in 4.7.9 for CVE-2026-33937 covered only PathExpression, NumberLiteral and BooleanLiteral values, leaving fields such as Program.blockParams.length, a non-PathExpression parameter depth, a non-string StringLiteral.value and a non-string PathExpression.original unvalidated. The published CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:H (9.8) and treats this as trivially remote and unauthenticated, but that materially overstates real-world exposure: the vulnerable path is a non-default application design pattern that the vendor explicitly warns against, so applications that compile only template strings - the standard, documented usage - are completely unaffected, and no public exploit code has been identified at time of analysis. Vendor-released patch: 4.7.10.

Memory corruption in the wired-uplink network endpoints of Arista Wi-Fi access points lets an unauthenticated attacker who already sits on the same Layer-2 segment as the AP's wired uplink crash the sensor service and, under specific preconditions, potentially achieve remote code execution. No authentication or user interaction is required, but the vulnerability is scored adjacent-network (AV:A) with an explicit attack precondition (AT:P in the CVSS 4.0 vector), so the dependable outcome is a denial-of-service crash of the sensor service while full code execution is condition-dependent; no public exploit code has been identified at time of analysis. Because exploitation demands Layer-2 adjacency to the uplink segment, segmentation of management/uplink VLANs is the single most effective exposure reducer.

Unauthenticated adjacent-network attackers can crash or potentially execute arbitrary code on Arista Wi-Fi access points when the packet-capture service is running in an uncommon non-default streaming mode. The flaw is a stack-based buffer overflow (CWE-121) triggered by a crafted packet to the capture service; no authentication or user interaction is required, but the attacker must have Layer-2/adjacent access and the target must already have the non-default streaming mode enabled, so default-configured devices are not exposed. No public exploit code was identified at time of analysis, and this is a conditional priority rather than a drop-everything emergency because exploitation depends on that deliberately enabled configuration.

Unauthenticated attackers within radio-frequency (RF) proximity can crash the WIPS sensor service on affected Arista access points or potentially achieve remote code execution by sending a crafted frame. The vulnerability, an out-of-bounds write (CWE-787), affects APs with Wireless Intrusion Prevention System (WIPS) enabled and requires no wireless association, authentication, or user interaction. No public exploit has been identified at time of analysis; the CVSS 4.0 score is 8.7, and while not a mass-internet-exploitation emergency, it is an operational-priority issue for Arista wireless environments because successful exploitation disables WIPS monitoring and may allow code execution on the AP.

Unauthenticated, network-adjacent attackers can crash - and potentially execute arbitrary code on - Arista Wi-Fi access points by sending a crafted packet to the wireless gateway service, provided the captive portal or application firewall feature is enabled on at least one SSID. The flaw is a stack-based buffer overflow (CWE-121) rated 9.4 under CVSS 4.0 (AV:A/AC:L/PR:N/UI:N with all impact metrics High and scope change), and because the wireless gateway service restarts automatically after a crash, an attacker can retry indefinitely. No public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited (not listed in CISA KEV); exposure is limited to devices where a vulnerable feature is actually enabled and to attackers within wireless range or on an adjacent network segment.

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.

Attacker-controlled pointer dereference in AMD's ROCm Communication Collectives Library (RCCL) can escalate to remote code execution when a compromised peer rank - or a network-adjacent attacker on the collective fabric - participates in a multi-GPU or multi-node distributed workload. The defect (CWE-822, untrusted pointer dereference) affects RCCL running on AMD Instinct MI200/MI300/MI350-class accelerators and carries a CVSS 4.0 base score of 7.7 (vector AV:N/AC:H/AT:N/PR:L/UI:N, High confidentiality/integrity/availability), mapping to an assessed CVSS 3.1 of AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H. Exploitation is not confirmed as active (CVE is not in CISA KEV) and no public exploit code has been identified at time of analysis; the attack requires a pre-existing foothold as a peer rank inside the collective group rather than anonymous internet access, so this is a moderate-priority issue for distributed AMD GPU deployments rather than an internet-wide emergency.

Heap-based buffer overflow in GIMP's DirectDraw Surface (DDS) loader allows attackers to corrupt memory and potentially execute arbitrary code by convincing a user to open a crafted .dds image. The flaw affects GIMP as shipped in Red Hat Enterprise Linux 6, 7, 8, 9, and 10, and requires local file access plus user interaction (opening the malicious file) with no authentication required per the CVSS vector (PR:N). No public exploit code has been identified at time of analysis, and exploitation is limited to the privileges of the user running GIMP.

Server-side request forgery in GitHub Enterprise Server 3.20, 3.21, and 3.22 lets an authenticated repository contributor with push permission cause the appliance to issue requests to attacker-controlled internal hosts, which can be chained to remote code execution on the appliance. The flaw sits in the secret scanning validator for GCP service account credentials, which trusts the token endpoint embedded in a committed credential and sends a request to it without restricting the destination, and it additionally requires GitHub Advanced Security with secret scanning validity checks enabled, a non-default configuration. No public exploit identified at time of analysis; vendor-released patches are 3.20.9, 3.21.7, and 3.22.2, and the issue was reported through the GitHub Bug Bounty program.

WeasyPrint releases prior to 70.0 hand attacker-controlled bytes - from HTML img URLs, CSS image values, SVG image references, and data URIs - to Pillow's generic image dispatcher, which does not exclude Encapsulated PostScript, so on any host with Ghostscript installed Pillow's EpsImagePlugin shells out to that interpreter and runs the attacker's PostScript. This produces interpreter-permitted effects, demonstrated by the fix commit's dangerous.eps sample writing /tmp/test-marker.txt, and escalates to remote code execution when the installed Ghostscript has a usable -dSAFER sandbox bypass; hosts without Ghostscript never reach the rasterization path and are not exploitable. No public exploit code and no CISA KEV entry were identified at time of analysis, and the vendor-released patch is WeasyPrint 70.0; the published CVSS is 8.8 while our own assessment rates attack complexity as High with no privileges and no user interaction required.

Code injection in the Hydra configuration framework (all releases prior to 1.3.6 and 1.4.0.dev9) lets an attacker who controls the application's Hydra logging configuration name an arbitrary importable class or factory that Hydra will then import and invoke with the application's own privileges. Hydra routes logging settings to Python's logging.config.dictConfig() without applying its own target policy, so the handler 'class' values and the formatter, filter, handler, queue and listener factories are resolved and called directly - this bypasses the _target_whitelist_ protection that otherwise guards instantiate(), meaning even hardened deployments are exposed. The assessed vector is CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H (7.8): a local, unprivileged attacker must plant malicious logging configuration (a config file, an override, or a shared/untrusted config source) and the victim must then run the Hydra application, yielding high confidentiality, integrity and availability impact; no public exploit code has been identified at time of analysis and the flaw is not in CISA KEV, but exploitation only requires that the victim execute the tampered configuration.

Code execution with the hosting application's privileges is possible in Hydra 1.3.4 through versions before 1.3.7 (and before 1.4.0.dev10) when an attacker controls multiple sibling target entries in a configuration that the application passes to instantiate(). One sibling resolves hydra._internal.target_policy.UNCONTROLLED_EXECUTION_TARGETS.discard to delete a denied target from Hydra's process-global blocklist, and a later sibling - processed in insertion order against the same mutated policy - invokes the now-permitted callable; the mutation persists for the life of the process. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, 8.5) indicates no privileges are required and only passive user interaction, and no public exploit identified at time of analysis (not in CISA KEV, no POC referenced); exploitation is limited to deployments that feed untrusted configuration content to instantiate(), and a narrow execution whitelist supplied by trusted Python code is not bypassed by the reported direct mutation path.

Use-after-free in Google Chrome's CSS handling affects builds prior to 155.0.8059.39 and allows a remote, unauthenticated attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page. The flaw scores CVSS 3.1 base 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), yet Google assigned it Chromium severity Low because the resulting code execution is confined to the browser sandbox and requires user interaction - full host compromise would require chaining a separate sandbox-escape bug. No public exploit identified at time of analysis, and a vendor patch is available.

Code execution outside the Chrome sandbox is possible in Google Chrome desktop builds prior to 155.0.8059.39, where a use-after-free in the network component (CVE-2026-106234, CWE-416) can be triggered by a crafted Chrome extension that a remote, unauthenticated attacker convinces a victim to install. The UI:R prerequisite - social engineering the user into installing the extension - is the primary limiting factor, which is why the vendor assigned a Chromium security severity of Low even though the assessed CVSS is 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H) and technical impact is rated total in the CISA SSVC framework; the high CVSS and the Low vendor severity are sharply conflicting signals. No public exploit identified at time of analysis (SSVC exploitation: none), and a vendor patch is available.

Type confusion in the V8 JavaScript engine of Google Chrome before 155.0.8059.39 allows a remote attacker to execute arbitrary code inside the renderer sandbox when a victim renders a crafted HTML page, requiring user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, 8.8). Signals conflict and must be weighed carefully: the numeric severity is high, yet Google's own Chromium security severity for this issue is 'Low' and CISA's SSVC assessment records no exploitation and a non-automatable attack path, with no public exploit identified at time of analysis. A vendor-released patch exists in Chrome 155.0.8059.39, so fully updated installations are not exposed.