Remote Code Execution

Arbitrary file upload leading to remote code execution in vsDesk v14.0101 lets an authenticated administrator abuse the "Import via CSV" component, which relies solely on client-side file validation and performs no server-side extension or content checks. Because the check is enforced only in the browser, an admin can trivially submit a malicious file (e.g. a web shell) and have it execute in the context of the web application. No public exploit has been identified at time of analysis, though the flaw was reported by Kaspersky and a vendor patch exists in versions 14.0402 and later.

Local privilege escalation in Parallels RAS Client 21.0.26296 allows an attacker holding low-privileged code execution to reach SYSTEM-level authority by invoking an exposed dangerous function in the RAS RDP Backend Service (CWE-749). The CVSS 7.8 (High) rating reflects full confidentiality, integrity, and availability impact once exploited, with low attack complexity and no user interaction required beyond an initial foothold. No public exploit code and no CISA KEV confirmation have been identified at time of analysis, though ZDI's coordinated disclosure (ZDI-26-556) may accelerate POC development.

Local privilege escalation in Parallels RAS Client 21.0.26296 allows low-privileged local attackers to gain SYSTEM-level code execution by invoking an exposed dangerous function within the RAS RDP Backend Service. The root cause is CWE-749, where a privileged service function is accessible without proper access control to lower-privileged callers. Discovered and reported by Zero Day Initiative (ZDI-26-555 / ZDI-CAN-28885), no public exploit or CISA KEV listing has been identified at time of analysis.

Local privilege escalation in Parallels RAS Client 21.0.26296 allows a low-privileged local attacker to escalate to SYSTEM-level execution by invoking an exposed dangerous function within the RAS RDP Backend Service. The flaw (CWE-749) stems from the service exposing an unsafe method that can be abused without administrative rights, enabling full system compromise. No public exploit or CISA KEV listing has been identified at time of analysis, though the vulnerability was coordinated through Zero Day Initiative (ZDI-CAN-29220).

Remote code execution in Adminer 5.4.2 allows authenticated high-privilege users to execute arbitrary code in the context of the web server by exploiting an incorrect function return value check in the multi_query method (CWE-253). The CVSS base score of 7.2 (High) reflects full confidentiality, integrity, and availability impact once authentication is satisfied. No public exploit code or CISA KEV listing has been identified at time of analysis, placing this in the category of a serious but not yet confirmed actively-exploited vulnerability.

Remote code execution in Hugging Face PyTorch Image Models (timm) version 1.0.24 is triggered when a user loads a crafted model checkpoint file, exploiting unsafe deserialization of untrusted data. The vulnerability, discovered by ZDI (ZDI-CAN-27987) and tracked as ZDI-26-523, allows an attacker who can deliver a malicious checkpoint to achieve full code execution in the context of the victim's process with no special system privileges required. No public exploit has been identified at time of analysis and the vulnerability is not listed in the CISA KEV catalog, but the attack surface is practically significant in ML/AI workflows where downloading pretrained checkpoints from public sources is routine.

Remote code execution in GIMP 3.2.2 is achievable when a user opens a crafted APNG file, triggering an integer overflow before buffer allocation in the APNG parser (CWE-190). Disclosed by Zero Day Initiative as ZDI-CAN-29401/ZDI-26-462 and tracked as EUVD-2026-63458, the flaw yields full C/I/A compromise within the GIMP process. No active exploitation is confirmed (not listed in CISA KEV), but a fix commit is available on GNOME GitLab; no officially tagged patched release has been independently confirmed at time of analysis.

Remote code execution in GIMP 3.2.2 is achievable via a specially crafted TIF image file that triggers an integer overflow in the application's TIFF parser, causing an undersized heap allocation and subsequent memory corruption. An attacker who convinces a user to open a malicious file or visit an attacker-controlled page that delivers such a file can execute arbitrary code with the privileges of the victim's user account. No public exploit identified at time of analysis, though the ZDI origin (ZDI-26-461, formerly ZDI-CAN-29405) represents a technically verified, researcher-confirmed vulnerability with well-characterized root cause.

Heap-based buffer overflow in GIMP's TIF file parser enables remote code execution when a user opens a crafted TIFF image, affecting GIMP 3.2.2. The flaw stems from missing length validation before copying attacker-controlled data into a heap buffer (CWE-122), granting full code execution in the context of the GIMP process. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, but a fix commit is available on the GNOME GitLab repository.

Remote code execution is possible in GIMP 3.2.2 through a maliciously crafted SGI image file, exploiting an integer overflow in the application's SGI file parser. An unauthenticated remote attacker can deliver the file via email or web and, upon the victim opening it, execute arbitrary code within the GIMP process context with the privileges of the logged-in user. No active exploitation has been confirmed (not in CISA KEV), though ZDI's coordinated public disclosure via ZDI-26-459 lowers the barrier to weaponization; an upstream patch commit exists but a formally tagged fixed release has not been independently confirmed.

Remote code execution in GIMP 3.2.2 is achievable by an attacker who can convince a target user to open a specially crafted TIF file, triggering an integer overflow during buffer allocation in the TIFF parser that leads to heap corruption and arbitrary code execution in the context of the current user process. Disclosed by the Zero Day Initiative under ZDI-26-458 (ZDI-CAN-29406), the flaw is rooted in missing validation of user-supplied size data before heap allocation. No public exploit has been identified at time of analysis and the vulnerability does not appear in the CISA KEV catalog; however, an upstream fix commit is available in the GIMP GitLab repository.

Remote code execution via maliciously crafted TIF files affects GIMP 3.2.2, allowing an attacker to execute arbitrary code in the context of the running GIMP process with full user-level privileges. The root cause is a CWE-190 integer overflow in the TIFF file parser where attacker-supplied image metadata bypasses size validation before a heap allocation, enabling memory corruption and code execution. Reported by Zero Day Initiative as ZDI-CAN-29403 and tracked under ENISA EUVD-2026-63453; no public exploit code or CISA KEV listing has been identified at time of analysis.

Stack-based buffer overflow in GIMP 3.2.2's TIF file parser enables remote attackers to execute arbitrary code in the context of the current user process. Exploitation requires the target to open a specially crafted TIF image file, making this a socially-engineered attack delivered via malicious webpage or email attachment. Reported by the Zero Day Initiative (ZDI-26-456/ZDI-CAN-29399), a fix commit has been pushed to the upstream GNOME GitLab repository, though no independently confirmed patched release version is available at time of analysis.

Heap-based buffer overflow in GIMP's TIF file parser (CWE-122) enables remote code execution on affected installations when a user opens a crafted TIFF image. Confirmed affected version is GIMP 3.2.2 per EUVD-2026-63451, with the flaw originating from missing length validation before copying attacker-controlled data to a heap buffer. Discovered and reported by Zero Day Initiative (ZDI-26-455 / ZDI-CAN-29398); no public exploit or CISA KEV listing has been identified at time of analysis, though an upstream patch commit exists on GNOME GitLab.

Remote code execution in GIMP 3.2.2 is triggered when a victim opens a specially crafted PSD file, exploiting an integer overflow in the PSD parser that occurs before buffer allocation. Tracked by Zero Day Initiative as ZDI-CAN-29395 and rated CVSS 7.8, the flaw allows an unauthenticated remote attacker to execute arbitrary code within the GIMP process context after inducing the target to open a malicious file. No public exploit identified at time of analysis, and no active exploitation has been confirmed via CISA KEV.

Remote code execution in GIMP 3.2.2 is possible when a user opens a specially crafted HDR image file, with the underlying flaw residing in the GEGL image processing library that GIMP depends on. The integer overflow in HDR buffer size computation (CWE-190) produces an undersized heap allocation that an attacker can leverage to execute arbitrary code in the context of the victim's GIMP process. No public exploit code has been identified at time of analysis, and CISA KEV listing has not been confirmed; the ZDI advisory (ZDI-26-453) assigns this a High severity rating of CVSS 7.8.

Remote code execution in GStreamer's rtpsbcdepay plugin is achieved when a user processes a crafted RTP stream containing malformed SBC audio payload, triggering a use-after-free that corrupts heap memory and redirects execution to attacker-controlled code within the affected process. The flaw exists in all GStreamer installations where the rtpsbcdepay element is exercised, covering a broad surface area including Linux media players, VoIP clients, and Bluetooth audio gateways. No public exploit has been identified at time of analysis, but coordinated disclosure by ZDI (ZDI-CAN-29787) confirms technical reproduction, and a vendor security advisory (SA-2026-0051) has been published.

Heap-based buffer overflow in GStreamer's PNG file parsing allows remote code execution in the context of the affected process. Affects GStreamer installations where a user can be induced to open or process a maliciously crafted PNG file - via a web page or file download. The flaw stems from missing length validation before copying attacker-controlled data into a heap buffer (CWE-122). No public exploit or CISA KEV listing is identified at time of analysis; however, ZDI disclosed the issue under ZDI-26-466 following coordinated disclosure, and GStreamer has issued security advisory sa-2026-0052.

Stack-based buffer overflow in GStreamer's OGG file parsing component allows remote attackers to execute arbitrary code in the context of the current process. Affected installations of GStreamer fail to validate the length of user-supplied data before copying it to a stack-based buffer during OGG container parsing, enabling full code execution (C:H/I:H/A:H). No public exploit identified at time of analysis and the vulnerability is not listed in CISA KEV, though it was discovered and disclosed by the Zero Day Initiative (ZDI-CAN-29584), which typically indicates a reliable, well-researched finding.

Heap-based buffer overflow in GStreamer's MRF file parser enables remote code execution when a user opens a crafted media file or visits a page that triggers parsing. The root cause is absent length validation before copying attacker-supplied data into a heap buffer (CWE-122), granting full confidentiality, integrity, and availability impact within the target process. Reported by ZDI as ZDI-CAN-29608 and addressed in GStreamer security advisory SA-2026-0050; no public exploit code or CISA KEV listing is confirmed at time of analysis.

Remote code execution via malicious MRF media files affects GStreamer across all versions tracked under CPE cpe:2.3:a:gstreamer:gstreamer:*:*:*:*:*:*:*:*. The MRF file parser fails to validate user-supplied input bounds, allowing a heap out-of-bounds write (CWE-787) that corrupts memory and redirects execution to attacker-controlled code within the victim process. Exploitation requires user interaction - opening a crafted file or visiting a page that triggers GStreamer parsing - and no public exploit or CISA KEV listing has been identified at time of analysis, though ZDI coordinated disclosure (ZDI-CAN-29510) and an upstream vendor advisory (sa-2026-0050) are both present.

Remote code execution is possible in OriginLab Origin Viewer through a memory corruption flaw triggered during OGW file parsing. An attacker can exploit this by enticing a target user to open a maliciously crafted OGW file or visit a page that delivers one, executing arbitrary code in the context of the current user process. No public exploit or CISA KEV listing has been identified at time of analysis, but the vulnerability was discovered and reported by Zero Day Initiative (ZDI-CAN-29338), indicating structured third-party research.

Remote code execution in OriginLab Origin Viewer 9.9.5 is achievable by tricking a user into opening a specially crafted OPJ project file, triggering an out-of-bounds write in the file parser that corrupts memory and redirects execution to attacker-controlled code. The vulnerability was discovered and reported by Zero Day Initiative (ZDI-CAN-29336) and carries a CVSS 7.8 score with full confidentiality, integrity, and availability impact scoped to the user process. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.

Remote code execution in OriginLab OriginPro allows attackers to execute arbitrary code within the victim's process context by supplying a crafted OGG file. The root cause is a CWE-119 memory corruption condition in the OGG file parser, where user-supplied data is not properly validated before use, enabling a buffer overflow. Exploitation requires user interaction - the victim must open a malicious file or visit a page that triggers OriginPro's parser - and no public exploit or CISA KEV listing has been identified at time of analysis.

Remote code execution in OriginLab OriginPro 2026 SR1 is triggered when a victim opens a specially crafted OGW workspace file, exploiting a memory corruption flaw in the file parser. The vulnerability, reported by Zero Day Initiative (ZDI-26-550/ZDI-CAN-29334), allows an attacker to execute arbitrary code in the context of the current user process without requiring any privileges on the target system. No active exploitation has been confirmed in CISA KEV at time of analysis, and EPSS data was not provided, but the ZDI public advisory and vendor CVE page are both live.

Out-of-bounds write in OriginPro's OGG file parsing component enables arbitrary code execution in the context of the current user's process when a crafted OGG file is opened. Affected installations include OriginPro 2026 SR1, as confirmed by ZDI (ZDI-CAN-29333 / ZDI-26-549) and EUVD-2026-63438. No active exploitation (CISA KEV) or public exploit code has been identified at time of analysis, though user interaction is the sole barrier to exploitation once a malicious file is delivered.

Out-of-bounds write in OriginPro's OPJ project file parser enables remote attackers to execute arbitrary code when a user opens a specially crafted OPJ file. The flaw, disclosed by Zero Day Initiative as ZDI-CAN-29332, results from insufficient validation of user-supplied data during file parsing - allowing a write past the end of an allocated data structure and full compromise of the target process. No public exploit code and no active exploitation (CISA KEV) has been identified at time of analysis, but ZDI coordinated disclosure typically reduces the time-to-exploit development once advisories publish.

Remote code execution is achievable in OriginLab OriginPro through a maliciously crafted OPJU project file, exploiting an out-of-bounds write (CWE-787) in the application's file parser. OriginPro 2026 SR1 is confirmed affected per EUVD-2026-63436, with the CPE string suggesting broader version coverage may apply. No public exploit code has been identified at time of analysis and the vulnerability is absent from CISA KEV; however, ZDI discovery (ZDI-CAN-29331) indicates coordinated research disclosure, and the low attack complexity once the file is delivered makes this a meaningful risk to research and scientific computing environments.

Arbitrary code execution in aeon 1.3.0 is triggered when a user loads a maliciously crafted CSV dataset file via the `load_time_series_segmentation_benchmark` or `load_human_activity_segmentation_datasets` functions, both of which passed CSV column values directly to Python's `eval()` built-in without validation. An attacker who convinces a data scientist or researcher to open a crafted dataset file can execute arbitrary Python code with the privileges of the running process. No public exploit has been identified at time of analysis, but the upstream fix commit is public and the vulnerability class is trivially replicable given the use of bare `eval()`.

Remote code execution in aeon 1.3.0 is possible when a user loads a maliciously crafted CSV dataset via the `load_human_activity_segmentation_datasets` or `load_time_series_segmentation_benchmark` functions, which pass unvalidated column values directly to Python's `eval()`. An attacker who can deliver a malicious file or dataset URL to a target data scientist can execute arbitrary Python code in the victim's process with their full privileges. No public exploit has been identified at time of analysis, though ZDI (ZDI-CAN-29160) holds technical details; the upstream fix replacing `eval()` with `ast.literal_eval()` is available as a commit but a tagged patched release has not been independently confirmed.

Remote code execution in Aeon 1.3.0 is triggered when a user loads a maliciously crafted dataset file via the load_rehab_pile_dataset function, which called numpy's np.load() with allow_pickle=True - enabling full Python pickle deserialization of attacker-controlled content. Reported by Zero Day Initiative (ZDI-CAN-28749 / ZDI-26-468) and tracked as EUVD-2026-63433, the vulnerability carries CVSS 7.8 with full confidentiality, integrity, and availability impact limited by local attack vector and required user interaction. No public exploit has been identified at time of analysis, and an upstream patch commit is available but a tagged release version has not been independently confirmed.

Command injection in the Sony XAV-9500ES car audio receiver firmware 3.02.00 allows a local attacker with low-privileged code execution to escalate to root via the device's crash dump handler. The handler passes user-controlled input directly to an OS system call without sanitization (CWE-78), enabling arbitrary command execution at the highest privilege level. Disclosed by ZDI as ZDI-26-477 (ZDI-CAN-29061); no public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.

Remote code execution in the Sony XAV-9500ES automotive multimedia head unit is achievable by a network-adjacent attacker who can induce a victim to pair a malicious Bluetooth device. The root cause is a heap-based buffer overflow (CWE-122) in the AVRCP_Br_Response_Parser function, which fails to validate the length of attacker-controlled data before copying it into a heap allocation. Successful exploitation yields arbitrary code execution at the device level; no public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV.

Heap-based buffer overflow in the Sony XAV-9500ES car multimedia receiver's Bluetooth L2CAP SDU reassembly function enables network-adjacent attackers to execute arbitrary code on the device. The flaw in `l2_reassemble_sdu` stems from missing length validation before copying attacker-controlled data to a heap buffer, granting full code execution in the device context once a malicious Bluetooth device has been paired by the victim. No public exploit or CISA KEV listing has been identified at time of analysis, but the ZDI advisory (ZDI-26-474) and a Sony firmware update advisory are both publicly available.

Remote code execution in Sony XAV-9500ES car media receivers is achievable via a classic buffer overflow in the device's RTSP server, exploitable by unauthenticated network-adjacent attackers without user interaction. Sending a crafted RTSP SETUP packet with an oversized field overflows a fixed-length buffer, corrupting memory and enabling arbitrary code execution in the device's context. Discovered and reported by Zero Day Initiative (ZDI-CAN-29042 / ZDI-26-472), a Sony vendor advisory and firmware update are available for affected firmware version 3.02.00; no public exploit code and no CISA KEV listing have been identified at time of analysis.

Remote code execution in Heimdall Data Database Proxy enables authenticated high-privilege attackers to run arbitrary code as root via a directory traversal flaw in the uploadJar method. The vulnerability, tracked as ZDI-CAN-28603 and published by Zero Day Initiative as ZDI-26-479, stems from the absence of proper path validation on user-supplied input before use in file operations, allowing arbitrary JAR placement on the underlying filesystem. No public exploit code and no CISA KEV listing are identified at time of analysis; exploitation is gated behind administrative authentication.

Local privilege escalation in Kenwood DNR1007XR network video recorder devices allows a low-privileged local attacker to achieve root-level code execution by exploiting command injection in the JKGenService service. The flaw (CWE-78) exists because user-supplied input is passed without sanitization to a system call, enabling shell metacharacter injection. No public exploit has been identified at time of analysis, and the device is not listed in CISA KEV, but successful exploitation yields full system compromise on the affected hardware.

Unauthenticated remote code execution in OSNEXUS QuantaStor lets network-based attackers run arbitrary code as root by abusing an insecurely configured Kapacitor service that exposes functionality with no authentication check. ZDI (ZDI-26-480, ZDI-CAN-30036) rates it CVSS 9.8; no public exploit identified at time of analysis, and it is not currently listed in CISA KEV.

Remote code execution via OS command injection in NoMachine's web service allows authenticated remote attackers to execute arbitrary commands as the service account. The flaw, tracked by Zero Day Initiative as ZDI-CAN-30634 (ZDI-26-483), exists within the getstat command handler of the web service listening on TCP port 4000 by default, where user-supplied input is passed unsanitized to a system call. No public exploit code has been identified at time of analysis, and the vulnerability does not appear in CISA KEV, though the CVSS score of 8.8 and full C/I/A impact make this a genuine remediation priority for any organization using NoMachine for remote access.

Local arbitrary code execution is possible in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 through a TOCTOU race condition (CWE-367), where a low-privileged local attacker can manipulate a resource between its check and its use by a privileged process. The CVSS 7.0 score reflects high confidentiality, integrity, and availability impact, though the high attack complexity (AC:H) indicates the timing window must be won reliably. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog; IBM has released a patch via its support advisory.

Remote code execution in ATutor 2.2.4 is achievable by any authenticated instructor through a path traversal flaw in the ZIP extraction functionality. An attacker uploads a crafted ZIP archive containing a malicious .phtml file at a directory-traversing path, causing the file to be written into the web root and executed with web server process privileges. No patch exists and none is forthcoming - ATutor is end-of-life - meaning affected deployments face a permanent, unmitigated RCE exposure; no public exploit code has been identified at time of analysis.

Unrestricted file upload in the ATutor Gameme module allows any authenticated user to achieve remote code execution on the web server. The module stores uploaded files in a web-accessible directory before validating their content or type, meaning a malicious server-executable script (e.g., PHP webshell) can be uploaded and immediately retrieved via HTTP to trigger execution as the web server process user. ATutor 2.2.4 is confirmed vulnerable; the product is end-of-life with no patch available or planned.

Arbitrary code execution in @cgauge/yaml (all versions ≤ 0.27.0) is achieved by embedding a custom `!js` YAML tag in a document supplied to the parser; the library's tag handler unconditionally passes the tag's string value to `eval()`, granting attackers the full authority of the Node.js runtime - including filesystem access, environment variable exfiltration, network calls, and subprocess spawning. No safe-mode parsing option or opt-out mechanism exists in the library, meaning every call site that parses attacker-controlled YAML is unconditionally vulnerable. A public proof-of-concept exploit is available via GitHub Gist, and no vendor-released patch has been identified at time of analysis.

Code injection in the Query Wrangler WordPress plugin (versions <= 1.5.57) lets an authenticated low-privilege user reach remote code execution on the host. Because the CVSS vector requires only PR:L (subscriber-level access) with a scope change and full CIA impact, any site allowing self-registration is exposed to complete server compromise by its lowest-tier accounts. There is no public exploit identified at time of analysis, but the 9.9 base score and Patchstack attribution mark it as a high-priority patch item.

Code execution in n8n's Git node (all 1.x releases before 1.123.69, all 2.x releases before 2.33.4 and 2.34.1) allows an authenticated attacker who can also plant files on the n8n host to run arbitrary OS commands as the n8n process user. The Git node passes repository-local git configuration values directly to execution without neutralization, satisfying CWE-78 (OS Command Injection); triggering any Git node operation against a repository whose config has been poisoned fires the injected command automatically. No public exploit has been identified at time of analysis, but the high impact triad (VC:H/VI:H/VA:H) and confirmed patch availability make immediate upgrading the correct response.

Prototype pollution in n8n's JavaScript task runner sandbox allows an authenticated user with Code node access to escape VM isolation and execute arbitrary OS commands within the runner container. Affected versions span the v1.x branch before 1.123.69 and the v2.x branch before 2.33.4 and 2.34.1. The corruption is process-wide, meaning a single malicious execution can poison the prototype chain for all subsequent tenant Code node runs on the same shared runner; on v1.x instances without task runner isolation, the attack surface escalates to the main n8n process itself. No public exploit has been identified at time of analysis and CISA KEV does not list this CVE.

Expression injection in n8n's workflow editor allows an authenticated member to store a malicious payload in a resource-locator field that executes as JavaScript in any other user's browser session when they open the affected node. The root cause is that the editor splices the field's stored value directly into the node type's URL template without sanitizing expression syntax, enabling cross-user script execution within authenticated sessions. No public exploit or CISA KEV listing has been identified at time of analysis, but the CVSS 4.0 score of 8.4 reflects high confidentiality and integrity impact on the vulnerable system.

Remote code execution in n8n workflow automation platform (versions before 2.33.4 and 2.34.x before 2.34.1) arises from a path traversal flaw in the @n8n/workflow-sdk MCP node-schema loader. An authenticated user holding global:member privileges can supply a crafted node type string containing path-traversal sequences, causing the loader to resolve and execute an arbitrary file on the server filesystem as a Node.js module within the n8n main process. No public exploit has been identified at time of analysis and the vulnerability is not in the CISA KEV catalog, but the low privilege requirement and straightforward exploitability make this a high-priority patch for all self-hosted n8n deployments.

Zip-slip path traversal in Frauscher FDS 102 enables a high-privileged remote attacker to overwrite arbitrary files on the server and achieve full system compromise. By uploading a specially crafted ZIP archive containing entries with directory traversal sequences (e.g., ../../etc/cron.d/backdoor), an authenticated attacker can escape the intended extraction directory and plant executable content in sensitive filesystem locations. No public exploit code or active exploitation has been identified at time of analysis, but the direct path from file write to code execution makes this a critical post-authentication escalation risk in industrial environments.

Remote code execution is achievable on the Frauscher FDS 102 field data server when a high-privileged attacker uploads a PHP webshell and retrieves it directly via /uploads/<filename>.php, bypassing file type validation entirely (CWE-434). All versions appear affected per the wildcard CPE string reported by CERTVDE in advisory VDE-2026-078. Full system compromise - including loss of confidentiality, integrity, and availability - is the confirmed worst-case impact, with particular significance in railway operational technology environments where the FDS 102 manages sensor and axle-counting infrastructure. No public exploit code and no CISA KEV listing have been identified at time of analysis.

Remote code execution in the Depicter Popup & Slider Builder WordPress plugin (all versions before 4.8.0) is achievable by authenticated editor-level users who exploit the plugin's import feature to upload arbitrary PHP files to web-accessible directories. The plugin performs no file type validation and does not remove malformed or rejected uploads, allowing a PHP webshell to persist and be directly executed via HTTP request. A publicly available POC from WPScan exists; however, SSVC data indicates no confirmed exploitation to date and the attack is not automatable due to the mandatory editor-privilege requirement.

Local File Inclusion in Events Made Easy WordPress plugin (all versions through 3.2.5) allows contributor-level authenticated attackers to inject path-traversal payloads into the eme_single_event_page_template function, causing the server to include and execute arbitrary PHP files. The attack is persistent and passive: once a malicious event is saved, the payload fires automatically for any visitor who loads the affected single-event page, requiring no further attacker interaction post-submission. If the environment permits PHP file uploads, this escalates to full remote code execution; even without upload capability, existing PHP files can be included to bypass access controls or exfiltrate sensitive data. No public exploit identified at time of analysis.

Stack buffer overflow in GNU binutils 2.46.1 and earlier allows arbitrary code execution when a victim opens a crafted PE (Portable Executable) file using any binutils tool such as objdump or readelf. The out-of-bounds stack write (CWE-787) can corrupt return addresses, enabling attacker-controlled code execution in the victim's user context. No public exploit or CISA KEV listing has been identified at time of analysis, but the CVSS 7.8 High rating reflects full confidentiality, integrity, and availability impact if successfully exploited.

Arbitrary file read, write, and Python code execution in Agno's PythonTools (agno.tools.python) exposes any file accessible to the agent process via path traversal sequences injected into the file_name argument of read_file, save_to_file, or run_python_file. The root cause is use of Path.joinpath() without resolving or validating the resulting path against the intended base_dir boundary, enabling escape via sequences such as '../../../../../../etc/passwd'. No public exploit has been identified at time of analysis, but the attack is trivially constructible and can be delivered through direct tool invocation or prompt injection embedded in agent-processed content, giving any untrusted input source a path to OS-level code execution within the agent process.

Unauthenticated remote code execution in InternLM LMDeploy (versions 0.9.2 through 0.15.x) allows a remote attacker to execute arbitrary code inside an inference engine process when disaggregated (P2P) serving is enabled. The disaggregation peer-connector deserializes attacker-influenced ZMQ messages with Python pickle before any type validation, and the /distserve/p2p_initialize and /distserve/p2p_connect endpoints require no authentication in the default configuration (api_keys=None). Reported by VulnCheck with a vendor advisory and a public patch; no public exploit or CISA KEV listing identified at time of analysis, though the code path and fix are publicly documented on GitHub.

Arbitrary code execution in Splunk AI Toolkit below 6.0.0 is achievable by any user holding the Splunk 'power' role, through loading a crafted model file that embeds malicious pickle payloads inside sparse matrix data. The toolkit's model codec deserializes this data without sanitizing or restricting the embedded pickle content, granting the attacker code execution as the Splunk server process. No public exploit or CISA KEV listing has been identified at time of analysis, but the RCE impact with a low-privilege network vector makes this a high-priority patch target for any Splunk deployment running the AI or Machine Learning Toolkit.

Arbitrary code execution in Splunk SOAR (On-premises) versions below 8.6.0 is reachable by any authenticated user regardless of role assignment, via a crafted file path submitted to the REST API. The REST API endpoint neither enforces role-based access control nor restricts the user-supplied path to the intended temporary directory, enabling path traversal (CWE-22) that culminates in code execution on the SOAR server. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog; however, the low privilege barrier - any valid account, zero roles required - meaningfully elevates real-world risk in environments where SOAR accounts are broadly provisioned.

Remote code execution in Splunk SOAR versions below 8.6.0 allows unauthenticated remote attackers to execute arbitrary code on the SOAR host by exploiting the Automation Broker's blind trust of client-supplied IP address headers. The Automation Broker accepts a forged source-IP header as proof that a notification endpoint request originates from the local system (CWE-290), bypassing all authentication. Successful exploitation grants full confidentiality, integrity, and availability impact on the SOAR host; no public exploit is identified at time of analysis, but the vendor has released a patch in version 8.6.0.

Authenticated low-privilege code injection in Splunk Enterprise allows OS command execution on the host system as the Splunk process account. Affected versions span four active release lines (9.4.x, 10.0.x, 10.2.x, 10.4.x), and the root cause is a missing capability check: Splunk Web accepts Splunk Web Manager XML configuration writes without enforcing the edit_manager_xml permission, meaning any authenticated user can plant attacker-controlled content that executes when the Manager page is rendered. No active exploitation is confirmed in CISA KEV, and no public exploit code has been identified at time of analysis, but the CVSS score of 8.8 (High) and straightforward exploitation path make this a high-priority patching target for Splunk deployments.

Remote code execution in Splunk Enterprise allows any low-privileged authenticated user to execute arbitrary code by exploiting a missing authorization check in the Federated Search dispatch flow. The vulnerability stems from the platform accepting caller-controlled bundle selection without verifying the fsh_manage capability, meaning any user with basic login access can escalate to full RCE. All four active version branches (9.4.x, 10.0.x, 10.2.x, 10.4.x) are affected below their respective patch thresholds; no public exploit or CISA KEV listing has been identified at time of analysis.

Remote code execution in Splunk Enterprise allows any authenticated low-privileged user - one without the 'admin' or 'power' role - to inject and execute arbitrary code on the Splunk platform instance via the Splunk Web Manager Configuration REST API endpoint. The root cause is a missing permission check on the REST API path governing manager configuration writes, meaning Splunk evaluates attacker-supplied configuration values without verifying the caller holds the required role. Exploitation yields full confidentiality, integrity, and availability impact on the Splunk instance; no public exploit has been identified at time of analysis.

Remote code execution in Splunk Enterprise allows any authenticated low-privilege user - one who does not hold the 'admin' or 'power' role - to execute arbitrary code by submitting crafted XML content to the Splunk Web Manager Configuration endpoint. The vulnerability combines two weaknesses: server-side evaluation of manager XML expressions without sufficient input restrictions (CWE-94), and a missing capability check on the configuration route that should gate such access. No public exploit has been identified at time of analysis, but the low attack complexity and low privilege requirement make this a high-priority remediation target across Splunk Enterprise 9.4.x, 10.0.x, 10.2.x, and 10.4.x branches.

Remote code execution in Splunk Enterprise allows any authenticated low-privilege user (without admin or power roles) to upload a malicious knowledge bundle via the REST API and force distributed search to execute it across search peers, achieving full C/I/A compromise. The root cause is a missing authorization check - the REST API endpoint for knowledge bundle uploads does not enforce the required edit_dist_peer capability, and distributed search blindly honors caller-supplied bundle selections. No public exploit or CISA KEV listing has been identified at time of analysis, but the low authentication bar (any valid Splunk account suffices) and network-accessible attack surface make this a high-priority patching target in enterprise environments.

Supply chain code injection in Red Hat Multicluster Engine for Kubernetes (mce-operator-bundle) enables arbitrary code execution during the software build process. The build pipeline fetches and executes scripts from a remote repository without commit pinning or cryptographic signature verification, meaning any actor with write access to that upstream repository can inject malicious payloads that execute at build time. The consequence extends beyond the build system itself (CVSS S:C) to the distributed artifacts, potentially delivering compromised software to all downstream consumers of the operator bundle. No public exploit code exists and no CISA KEV listing is present at time of analysis.

Remote code execution in IBM AIX 7.2/7.3 and PowerVM VIOS 4.1 lets an unauthenticated network attacker run arbitrary code by supplying malicious pointers that the OS fails to validate (CWE-843 type confusion). The flaw carries a critical CVSS 9.8 and was disclosed by IBM PSIRT with no user interaction required, but there is no public exploit identified at time of analysis and it is not listed in CISA KEV. Because AIX/VIOS underpins production IBM Power server estates, a working exploit would give attackers full compromise of the affected operating system.

Remote code execution in IBM AIX 7.2 and 7.3, and in the IBM PowerVM VIOS 4.1 virtualization stack, stems from an integer overflow (CWE-190) that a network-based attacker can trigger without authentication or user interaction. The CVSS 3.1 base score of 9.8 (AV:N/AC:L/PR:N/UI:N) reflects unauthenticated remote exploitation with full confidentiality, integrity, and availability impact. There is no public exploit identified at time of analysis, and the CVE is not listed in CISA KEV; no EPSS score was supplied in the input.

Remote code execution in IBM AIX 7.2/7.3 and IBM PowerVM VIOS 4.1 stems from a stack-based buffer overflow that a remote attacker can trigger without authentication, per IBM PSIRT (CVE-2026-16913). With a CVSS 3.1 base of 9.8 (AV:N/AC:L/PR:N/UI:N) and full CIA impact, successful exploitation yields arbitrary code execution on the affected UNIX operating system or virtualization I/O server. No public exploit has been identified at time of analysis and the CVE is not listed in CISA KEV, but the network-reachable, unauthenticated profile makes this a high-priority patch.

Stack-based buffer overflow in IBM AIX 7.2 and 7.3, and IBM PowerVM VIOS 4.1 allows remote authenticated attackers to execute arbitrary code on affected systems. The flaw (CWE-121) is reachable over the network with low attack complexity and requires only low-privilege credentials, yielding complete confidentiality, integrity, and availability impact. No public exploit code or CISA KEV listing has been identified at time of analysis, but the 8.8 CVSS score and confirmed RCE potential make patching urgent for organizations running IBM POWER infrastructure.

Remote code execution in IBM AIX 7.2, 7.3, and IBM PowerVM VIOS 4.1 is enabled by an off-by-one wrap-around error in bounds checking, reachable from an adjacent network without authentication. An attacker positioned on the same network segment can trigger the flaw to achieve full compromise of the affected system - confidentiality, integrity, and availability are all rated High. No public exploit or CISA KEV listing has been identified at time of analysis, but the combination of no-auth adjacency and RCE impact makes this a high-priority patch target in any environment running these IBM platforms.

Out-of-bounds write in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 lets an unauthenticated adjacent-network attacker corrupt memory to achieve arbitrary code execution or crash the affected service (denial of service). The CVSS 3.1 base score is 9.6 (Critical) with a changed scope, reflecting potential impact beyond the vulnerable component on IBM Power hardware. No public exploit identified at time of analysis, and the flaw is not listed in CISA KEV; EPSS data was not provided.

Out-of-bounds write in IBM AIX 7.2, 7.3 and PowerVM VIOS 4.1 enables an unauthenticated attacker positioned on an adjacent network segment to execute arbitrary code with full confidentiality, integrity, and availability impact. The CWE-787 class flaw requires no privileges and no user interaction, lowering the exploitation bar substantially once network adjacency is achieved. No public exploit code or CISA KEV listing has been identified at time of analysis, but the combination of zero-prerequisite exploitation and complete system compromise warrants urgent patching in affected enterprise environments.

Remote code execution in IBM AIX 7.2/7.3 and PowerVM VIOS 4.1 stems from a stack-based buffer overflow that a network-based attacker can trigger without authentication or user interaction, per the CVSS 9.8 vector. Successful exploitation yields full compromise (high confidentiality, integrity, and availability impact) of Unix systems that frequently underpin enterprise and mission-critical workloads. No public exploit identified at time of analysis, and the CVE is not currently listed in CISA KEV.

Remote code execution in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 allows an unauthenticated remote attacker to run arbitrary code by triggering a stack-based buffer overflow, per the vendor-assigned CVSS 3.1 vector of AV:N/AC:L/PR:N/UI:N. IBM (the reporting party) has published a fix, and no public exploit identified at time of analysis. EPSS and KEV signals were not provided, so the 9.8 CVSS score is currently the strongest available severity indicator.

Stack-based buffer overflow in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 enables remote authenticated attackers to execute arbitrary code, achieving full compromise of confidentiality, integrity, and availability. The CVSS 8.8 score reflects low-complexity network exploitation requiring only low-privilege authentication (PR:L), making it accessible to any credentialed user on the system. No public exploit identified at time of analysis, but a vendor-released patch is available from IBM.

Remote code execution in IBM PowerVM Hypervisor partition firmware exposes Power Systems environments during network boot operations. An unauthenticated attacker positioned on the same adjacent network as a partition actively performing a network boot can send a malformed packet that triggers a CWE-787 out-of-bounds write, executing arbitrary code within the partition firmware and compromising everything the partition subsequently loads. Impact is scoped to the actively booting partition - other partitions and the managed system are explicitly unaffected. No public exploit or CISA KEV listing exists at time of analysis; EPSS is notably low at 0.19% (9th percentile), consistent with the narrow exploitation window.

Remote code execution in IBM AIX 7.2/7.3 and IBM PowerVM VIOS 4.1 stems from a stack-based buffer overflow (CWE-121) that a network attacker can trigger without authentication or user interaction. Because the flaw carries a CVSS 9.8 with an AV:N/AC:L/PR:N/UI:N vector, a successful attack yields full compromise of confidentiality, integrity, and availability on affected enterprise UNIX hosts and virtualization I/O servers. There is no public exploit identified at time of analysis, and IBM (the reporter) has released a fix.

Local arbitrary code execution in IBM AIX 7.2, 7.3 and PowerVM VIOS 4.1 stems from improperly scrubbed environment variables (CWE-426: Untrusted Search Path), allowing a low-privileged local user to inject malicious values such as PATH or LD_PRELOAD that are subsequently consumed by a privileged process. With a CVSS score of 7.8 (HIGH) and full confidentiality, integrity, and availability impact, successful exploitation yields arbitrary code execution at an elevated privilege level. No public exploit or CISA KEV listing has been identified at time of analysis, though a vendor patch is available via IBM support.

Command injection in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 enables an unauthenticated attacker with adjacent network access to execute arbitrary OS commands, achieving full compromise of confidentiality, integrity, and availability. The adjacent-network attack vector (AV:A) limits exposure to attackers already positioned on the same local network or VLAN as the affected system, which is a meaningful constraint in typical enterprise deployments of these platforms. No public exploit code and no active exploitation via CISA KEV have been identified at time of analysis; IBM has released a patch via its support portal.

Remote code execution in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 lets a remote attacker overflow a stack buffer (CWE-787 out-of-bounds write) and run arbitrary code on the affected Power-based host. The flaw was reported by IBM, carries a critical 9.8 CVSS rating with a network, no-privilege, no-interaction vector, and a vendor patch is available; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.

Remote code execution in IBM AIX 7.2/7.3 and PowerVM VIOS 4.1 stems from a stack buffer overflow (CWE-787) that a network-based attacker can trigger without authentication or user interaction, per the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N). IBM has published a fix, and no public exploit has been identified at time of analysis, though the 9.8 base score reflects full compromise of confidentiality, integrity, and availability. The exact vulnerable service/daemon is not disclosed in the available data, which limits precise attack-surface scoping.

Remote code execution in IBM AIX 7.2/7.3 and PowerVM VIOS 4.1 is achievable by an unauthenticated attacker on the same network segment via command injection triggered by crafted IPv6 Router Advertisement messages. The vulnerability (CWE-269, Improper Privilege Management) implies the RA processing subsystem executes injected commands with elevated OS-level privileges, enabling full confidentiality, integrity, and availability compromise of the affected host. No public exploit has been identified at time of analysis; IBM has released a patch per advisory https://www.ibm.com/support/pages/node/7283858.

Heap buffer overflow in IBM AIX 7.2, 7.3 and IBM PowerVM VIOS 4.1 enables unauthenticated adjacent-network attackers to execute arbitrary code on affected systems. The CWE-787 out-of-bounds write flaw carries a CVSS score of 8.8 and yields full confidentiality, integrity, and availability compromise upon successful exploitation. No public exploit code or CISA KEV listing has been identified at time of analysis; however, a vendor-supplied patch is available via IBM support advisory node/7283858.

Remote code execution in IBM AIX 7.2/7.3 and IBM PowerVM VIOS 4.1 allows a remote attacker to run arbitrary code by triggering a heap buffer overflow (CWE-787 out-of-bounds write) in an affected network-facing component. The CVSS 9.8 vector (AV:N/AC:L/PR:N/UI:N) indicates unauthenticated, low-complexity network exploitation with full confidentiality, integrity, and availability impact. IBM has published a fix; no public exploit identified at time of analysis and no CISA KEV listing, so this is currently a high-severity but not confirmed-exploited issue.

Stack buffer overflow in IBM AIX 7.2, 7.3 and PowerVM VIOS 4.1 enables unauthenticated remote code execution by any attacker with adjacent network access. The flaw (CWE-787, Out-of-bounds Write) corrupts stack memory during processing of a crafted network payload, allowing an attacker to overwrite return addresses and redirect execution without requiring credentials or user interaction. No public exploit has been identified at time of analysis and IBM has released a patch, but the AV:A/PR:N/AC:L vector makes this a high-priority fix for any organization running IBM Power Systems infrastructure.

Remote code execution in IBM PowerVM Hypervisor firmware versions FW950 through FW1120 allows an attacker with authenticated service-level access to the Flexible Service Processor (FSP) to execute arbitrary code in the host firmware runtime and gain full control of the managed Power system. An integer overflow (CWE-190) in the service processor mailbox interface is the root cause, with CVSS scope change (S:C) reflecting that exploitation breaks out from the FSP boundary into the broader host firmware and managed-system context. No public exploit or CISA KEV listing exists at time of analysis; however, the combination of complete C/I/A impact and scope change makes this a high-priority patch target for any organization running affected IBM Power hardware.

Remote code execution in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 allows a remote attacker to run arbitrary code by triggering an out-of-bounds write (CWE-787) in an affected component. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N) indicates the flaw is reachable over the network by unauthenticated attackers with low complexity, yielding full compromise of confidentiality, integrity, and availability. IBM has released a fix; there is no public exploit identified at time of analysis and the CVE is not listed in CISA KEV.

Remote unauthenticated memory corruption in RDK-B WebUI (build rdkb-2025q4-kirkstone.04.10.26) arises from a heap-based buffer overflow in the multipart/form-data parser in jst_post.c, letting an attacker send a single crafted POST request to corrupt heap memory. Confirmed impact is denial of service via crashing the WebUI service, with potential remote code execution on the broadband gateway if the overflow is weaponized. No public exploit identified at time of analysis and the issue is not in CISA KEV; EPSS is low (0.29%, 21st percentile) despite the 9.8 CVSS.

Remote code execution via server-side template injection (SSTI) in document-merge-service affects all versions before 9.1.0, exploitable by authenticated users with access to upload XLSX templates. The xltpl library processes XLSX templates through a non-sandboxed Jinja2 environment, allowing an attacker to embed Jinja2 expressions that execute arbitrary code server-side as the document-merge-server user (UID 901). No active exploitation (KEV) has been confirmed, but Jinja2 SSTI techniques are well-documented and HackTricks references are cited in the advisory, indicating the attack pattern is publicly known.

Unauthenticated remote code execution in ICEcoder 8.1 allows any network-reachable attacker to run arbitrary OS commands as the web-server user by exploiting a three-weakness chain in the terminal endpoint: an authentication bypass triggered by supplying a password parameter, a CSRF skip triggered by any non-empty csrf value, and unsanitized command passthrough directly into PHP's proc_open(). The attack requires a single crafted HTTP POST request and no prior credentials. A public proof-of-concept appears available via a GitHub Gist reference in the VulnCheck advisory. No active exploitation is confirmed by CISA KEV at the time of this analysis.

Remote code execution in IBM Power Systems Firmware (FW1120.00, FW1110.00-FW1110.30, FW1060.00-FW1060.80, FW950.00-FW950.H2) lets an unauthenticated attacker with adjacent-network access to the ASMI web interface send a malformed request that overflows a stack buffer on the Flexible Service Processor (FSP), yielding arbitrary code execution and full control of the managed system. Because the FSP is the service processor beneath the OS, compromise crosses a scope boundary (CVSS S:C) and breaks confidentiality, integrity, and availability of the whole platform. No public exploit identified at time of analysis; IBM has released a fix and reported the issue itself.