Remote Code Execution

Local privilege escalation in AMD Power Design Manager (PDM) Software Installer for Windows enables a low-privileged local user to exploit incorrectly configured directory permissions, potentially resulting in arbitrary code execution at an elevated privilege level. The vulnerability is confirmed by AMD PSIRT via security bulletin AMD-SB-8016, and a patched version (2026.1) has been released. No public exploit code and no CISA KEV listing have been identified at time of analysis.

DLL hijacking in AMD Power Design Manager (PDM) enables a local, low-privileged attacker to escalate privileges during the software's uninstallation process, ultimately achieving arbitrary code execution at a higher privilege level. The vulnerability stems from CWE-427 (Uncontrolled Search Path Element), where the PDM uninstaller resolves DLL dependencies from directories writable by unprivileged users. AMD PSIRT confirmed the issue and released an Un-Installer patch at version 2026.1 via Security Bulletin AMD-SB-8016; no public exploit code or CISA KEV listing has been identified at time of analysis.

Binary hijacking is possible on Windows machines running AMD Vitis Unified due to weak filesystem permissions on the installation directory. A low-privileged local user can write arbitrary executables into paths traversed by higher-privileged processes, causing those processes to load attacker-controlled code when triggered by an interactive user. The CVSS 4.0 score of 1.0 reflects significant limiting prerequisites: local access, low-privilege credentials, specific attack preconditions, and required user interaction are all mandatory for exploitation. No public exploit has been identified at time of analysis.

DLL injection via uncontrolled search paths in AMD Vitis™ Unified Installer on Windows allows a local attacker to plant a malicious DLL within the application's installation search paths, potentially achieving arbitrary code execution when a user launches Vitis components. All Windows installations prior to the confirmed patched release 2026.1 are affected, as documented in AMD security bulletin AMD-SB-8015. No public exploit code has been identified at time of analysis and no CISA KEV listing exists, but the attack pattern aligns with well-understood Windows DLL search-order hijacking techniques commonly exploited in developer-toolchain targeting.

Privilege escalation in AMD Vitis Unified on Windows enables a low-privileged local user to plant malicious code in the installation directory due to misconfigured filesystem permissions, potentially leading to arbitrary code execution under a more privileged context. Affected installations are the Vitis Unified Installer for FPGAs and Adaptive SoCs on Windows, patched in release 2026.1. No public exploit code and no active exploitation have been identified at time of analysis; CISA SSVC rates exploitation as none and the attack as non-automatable.

Uncontrolled search path in AMD's Vitis Embedded Single File Download (SFD) installer for Windows enables local privilege escalation to arbitrary code execution. The vulnerability affects local Windows installations and requires a low-privileged user to plant a malicious binary or DLL in a directory included in the application's search path. No public exploit code or active exploitation has been identified at time of analysis; AMD has released a fix in patch version 2026.1 per AMD Security Bulletin AMD-SB-8015.

Local privilege escalation in Intel PROSet/Wireless WiFi Software for Windows allows unprivileged local code execution by exploiting improper authentication within the device driver layer. An attacker with only local access and no required privileges can bypass authentication checks in the Ring-2 driver tier, ultimately achieving code execution that results in high confidentiality impact on the broader host system alongside low integrity and availability impacts. No public exploit has been identified at time of analysis, and this CVE is not listed in the CISA KEV catalog.

Local privilege escalation and code execution in Intel PROSet/Wireless WiFi Software for Windows arises from an information disclosure flaw (CWE-200) within the Ring 2 device driver layer, exploitable by an unprivileged local user without authentication or user interaction. The vulnerable system itself suffers only low confidentiality impact, but a scope change into the driver subsystem produces high subsequent-system confidentiality impact alongside low integrity and availability impacts - consistent with a privilege escalation chain from user space into driver-controlled memory. No public exploit has been identified at time of analysis and the vulnerability has not been listed in the CISA KEV catalog.

Remote code execution in Fooocus (lllyasviel/Fooocus) versions 2.5.5 and earlier allows an attacker who can reach the web UI to run arbitrary Python by supplying crafted image metadata that the server passes to eval(). Anyone able to load or import an image whose embedded generation metadata contains malicious Python expressions can achieve full code execution on the host. There is no public exploit identified at time of analysis and it is not listed in CISA KEV, but an upstream fix pull request (PR #4207) and a GitHub Security Lab advisory (GHSL-2024-196) both confirm the flaw.

Cross-user module cache poisoning in n8n's JavaScript task runner allows an authenticated Code-node user to inject malicious logic into a shared module cache, silently altering other users' workflow executions on the same instance and compromising their data confidentiality, workflow integrity, or execution availability. Affects all multi-user n8n deployments on versions before 1.123.67 (1.x), 2.31.5 (2.31.x), and 2.32.1 (2.32.x) where the JS task runner is active and built-in or external module access is enabled. No public exploit has been identified at time of analysis, and the vulnerability is not listed in CISA KEV; despite the 'RCE' tag applied by the reporting source, the vendor advisory explicitly confirms this is a cross-user isolation break and not a sandbox escape or remote code execution.

Unauthenticated arbitrary file write in AVideo's aVideoEncoderChunk.json.php endpoint allows remote attackers to write up to 4 GB of arbitrary content to the server filesystem via HTTP PUT requests, requiring no credentials of any kind. All AVideo versions (cpe:2.3:a:wwbn:avideo:*:*:*:*:*:*:*:*) with this endpoint network-exposed are affected, as confirmed by the patch commit diff which shows authentication gating was entirely absent prior to the fix. Exploitation can cause denial of service via disk exhaustion, corrupt the video encoding pipeline, or - when chained with a local file inclusion vulnerability - escalate to remote code execution; no public exploit has been identified at time of analysis.

Concurrent access to an unprotected singleton context structure in Zephyr RTOS's UpdateHub OTA subsystem enables two independent callers - the background autohandler and user-triggered update operations - to race through prepare_fds(), producing an out-of-bounds write that corrupts adjacent struct members and disables the firmware-update path. Affected are embedded systems running Zephyr with the UpdateHub subsystem enabled, particularly those built with CONFIG_USERSPACE where unprivileged userspace threads can invoke update syscalls and actively compete with the workqueue handler. No public exploit has been identified at time of analysis, the CVSS base score is 2.5, and the vendor commit confirms no demonstrated path to code execution - impact is limited to availability of the OTA update mechanism.

CyberChef's client-side pretty-recipe parser freezes victim browser tabs via a crafted URL fragment containing large numbers of unmatched quote characters, triggering catastrophic backtracking in a synchronous global regular expression. Any user of CyberChef prior to 11.3.0 who opens a malicious #recipe= URL - whether shared in phishing, chat, or embedded in a page - is subject to a temporary denial-of-service condition. No code execution, data exfiltration, or privilege escalation is possible; impact is confined to browser tab availability. No public exploit identified at time of analysis, and this vulnerability is not listed in CISA KEV.

Code injection in the Feast operator within Red Hat OpenShift AI (RHOAI) allows an authenticated, high-privileged tenant to embed malicious code into their feature repository, which an automated operator process then executes under elevated Kubernetes RBAC permissions. Successful exploitation yields credential theft and full cluster administrative control, representing a critical privilege escalation pathway despite the moderate vendor CVSS score of 5.5. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA Known Exploited Vulnerabilities catalog.

Heap buffer overflow in GNU Emacs for Android's TrueType font parser (sfnt_read_name_table() in src/sfnt.c) enables potential code execution when a 32-bit Emacs process loads a crafted font file. The root cause is a CWE-190 integer overflow that wraps a 32-bit allocation size calculation, producing an undersized heap buffer that a subsequent read() call overflows. Delivery is possible through multiple standard Emacs workflows - email rendering, EWW web browsing, or documents with custom font faces - requiring only passive user interaction, with no authentication required from the attacker. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, though a patch commit is confirmed upstream.

Heap buffer overflow via integer wraparound in GNU Emacs for Android's TrueType font parser allows an attacker to corrupt heap memory and potentially achieve code execution by delivering a crafted font file through email, the built-in EWW browser, or documents using custom typefaces. The flaw is confined to 32-bit builds where an unguarded addition in sfnt_read_cmap_format_12() wraps around when computing an xmalloc allocation size, producing a fatally undersized heap buffer. No public exploit has been identified at time of analysis and this vulnerability is not listed in CISA KEV; however, CERT-PL reported the issue and an upstream patch commit is available.

Improper TLS certificate validation in Ecovacs Robotics DEEBOT PRO M1 and K1VAC robot vacuums exposes both devices to man-in-the-middle interception and manipulation of all outbound wget communications. Because certificate verification is disabled, a network-positioned attacker can impersonate any remote server the device contacts, injecting malicious content the device will accept and act upon. Per the vendor description, successful exploitation may result in arbitrary code execution with administrative privileges on the device; no public exploit has been identified at time of analysis.

Server-Side Request Forgery in NLTK 3.9.4 and the develop branch enables network-level probing of RFC 6598 shared-address-space hosts (100.64.0.0/10) by exploiting an incomplete block-list in the `validate_network_url()` guard function. The function correctly rejects private and loopback ranges but omits the shared address space defined by RFC 6598, which Python's `ipaddress` module does not classify as either `is_private` or `is_global`, allowing crafted URLs to pass the filter unchallenged. Impact is confined to confidentiality - internal infrastructure reachable through shared carrier-grade NAT space may be probed - and no code execution is achievable through this path; no public exploit or CISA KEV listing has been identified at time of analysis.

Authorization bypass in the kata-agent's ttRPC API allows an untrusted host to invoke two mem-agent methods unconditionally, circumventing the OPA/Rego-based AgentPolicy that forms the security boundary in Confidential Containers (CoCo) deployments. Affected are kata-containers versions prior to 4.0.0 when the mem-agent feature is explicitly enabled (disabled by default). The untrusted host can force in-guest memory operations - swap, aggressive eviction, or compaction - causing attacker-controlled availability and performance degradation of the confidential workload; the description explicitly rules out memory disclosure and code execution. No public exploit or CISA KEV listing has been identified at time of analysis, but the bypass is architecturally significant because it violates the CoCo threat model's fundamental assumption that the host is untrusted.

Unauthenticated remote attackers can trigger operator-configured scheduled jobs in Grav CMS when the scheduler-webhook plugin is installed and misconfigured, due to a compound-conditional short-circuit (CWE-303) that skips token validation entirely when no webhookToken is set. The primitive is job-triggering rather than attacker-controlled command injection: RCE is only achievable when an administrator has separately configured a scheduled job that shells out, a condition the attacker cannot influence. No public exploit has been identified at time of analysis, and the vendor-released fix is available in Grav v2.0.9.

JEXL expression sandbox bypass in Sonatype Nexus Repository 3's Content Selector feature allows authenticated users holding the nexus:selectors:create permission to traverse Java object properties outside the intended sandbox scope, disclosing internal JVM metadata such as class and classloader names. The vendor description explicitly confirms this does not permit method invocation, object construction, or code execution - making the 'RCE' intelligence tag a misclassification. Fixed in version 3.95.0; no public exploit or active exploitation has been identified at time of analysis.

Heap out-of-bounds write in RadiAnt DICOM Viewer is triggered when processing JPEG-compressed pixel data embedded in a crafted DICOM file, potentially enabling arbitrary code execution on the victim's workstation. Reported to CISA ICS-CERT as a medical device advisory (ICSMA-26-218-01), the vulnerability requires no privileges and only passive user interaction - consistent with file-preview or file-open workflows common in clinical imaging environments. The provided CVSS 4.0 score of 5.3 rates impact as availability-only (VA:L), which conflicts materially with the described RCE potential; this discrepancy is significant and should be independently verified. No public exploit code or CISA KEV listing has been confirmed at time of analysis.

Shortcode injection in the Ninja Forms WordPress plugin (versions before 3.14.10) allows unauthenticated network attackers to execute arbitrary WordPress shortcodes registered on a target site by supplying crafted query-string parameters that are processed without sanitization as form field default values. Exploitation is constrained by a non-default site configuration requirement - a form must be configured with query-string pre-population and embedded on a public page - which the CVSS AC:H rating reflects. No public exploit code or CISA KEV listing has been identified at time of analysis; the vendor-supplied patch (3.14.10) is available.

Shortcode allowlist bypass in the Easy Appointments WordPress plugin (≤ 3.12.26) allows authenticated contributors to execute arbitrary registered shortcodes by exploiting a validation flaw in a block-rendering action. The plugin checks only the first tag of a supplied string against an approved shortcode list, but renders the entire string - meaning a contributor can prepend an allowed tag and append any registered shortcode to bypass the restriction entirely. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis, and the vendor-assigned CVSS score of 2.7 (Low) reflects constrained scope, though real-world impact depends on the registered shortcode ecosystem of the targeted site.

Stored Vue template injection in CTI-Transmute ≤ 1.5.0 allows an unauthenticated attacker to execute arbitrary JavaScript in the browser of any user who views a compromised public conversion detail page. The attack bypasses Jinja2 HTML escaping because server-rendered values are injected into DOM regions subsequently compiled by Vue's runtime engine, which interprets the attacker-controlled `[[ ... ]]` expressions as live template code. The application's nonce-based CSP provides no protection because Vue's runtime compiler requires the `unsafe-eval` exception, permitting Function constructor escalation; no public exploit code beyond the proof-of-concept payload technique described in the advisory has been identified at time of analysis, and this CVE is not listed in CISA KEV.

CSS injection in the Mermaid JavaScript diagramming library (npm) allows sibling CSS combinators (`~` and `+`) to escape the diagram's SVG container and apply attacker-controlled styles to adjacent DOM elements on the host page. Affected are applications using Mermaid below v11.16.1 or below v10.9.8 that render user-supplied diagram source and where the SVG element has sibling nodes in the DOM - a non-default condition. An attacker supplying malicious diagram content can perform UI redressing, hide legitimate page content, or create phishing-style visual overlays; the vendor explicitly confirms JavaScript execution is not possible via this vector. No public exploit tool is identified at time of analysis, though a working proof-of-concept payload is embedded in the GitHub security advisory.

Prototype pollution in Mermaid's architecture-beta diagram renderer (mermaid@11.5.0 through 11.16.0) allows an untrusted diagram author to write the string 'horizontal' or 'vertical' directly onto Object.prototype by supplying '__proto__' as a valid group parent identifier. All JavaScript code sharing the same runtime realm that reads or enumerates the injected property name may observe corrupted option defaults, bypassed truthiness checks, or denial-of-service conditions in the embedding application. A public proof-of-concept is included in the advisory; direct remote code execution is not achievable because the injectable value is constrained to those two strings, ruling out function or object injection.

Path traversal in rclone v1.51.0-v1.74.4 allows an attacker who controls a remote source (confirmed with S3) to create or overwrite files outside the configured local destination directory when the victim uses a non-default local encoding that omits Dot (such as --local-encoding Slash, None, or Raw). The localPath() function in backend/local/local.go failed to validate that the constructed filesystem path remained within the configured root after encoding conversion, enabling crafted remote object names containing .. components to resolve to arbitrary filesystem locations with the permissions of the rclone process. A detailed proof of concept is publicly available in GHSA-7p4m-qxvv-g567; no CISA KEV listing was present at time of analysis, and a Windows-specific backslash traversal variant is additionally confirmed.

Remote command injection in livebook-dev Livebook's deployment setup command generator allows an authenticated high-privilege attacker to poison Docker and Fly.io setup commands displayed in the web interface, causing arbitrary shell code to execute on the machine of any user who copies and runs the generated command. Affected versions span 0.13.0 through 0.18.6 and 0.19.0 through 0.19.8. No public exploit has been identified at time of analysis, though the CVSS 4.0 score of 4.9 reflects the high privileges required and the indirect execution path through a secondary user's action.

Code injection in Electron's DevTools API permits arbitrary script execution in the DevTools context via an unsanitized `mode` parameter supplied to `webContents.openDevTools()`. Unsandboxed Electron applications where untrusted input reaches the `mode` argument - or where untrusted content embedded in a `<webview>` element can invoke `openDevTools()` - are exposed to full Node.js-level code execution on the host operating system. No public exploit has been identified at time of analysis, but Electron's own GitHub Security Advisory (GHSA-4f78-qhmw-8j8m) confirms the flaw and vendor-released patches are available across all active release tracks.

Out-of-bounds memory read in Electron's offscreen rendering pipeline allows a compromised GPU process to cause the browser/main process to read beyond a shared memory mapping boundary when producing `paint` event images, disclosing process memory or crashing the application. Exploitation requires two independent preconditions: the host application must enable `webPreferences.offscreen` (non-default) and an attacker must have already achieved code execution in the GPU process via a separate vulnerability. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Argument injection in xidown, a desktop GUI wrapper for yt-dlp and ffmpeg, allows any string beginning with '-' supplied as a URL to be interpreted by yt-dlp as a CLI option rather than a link target, because the application never inserts a '--' end-of-options separator before appending user input to subprocess invocations in scanner.py and downloader.py. All versions under cpe:2.3:a:indravoyager:xidown are affected across every call site. While full code execution via yt-dlp's --exec flag was not demonstrated during testing, the injection primitive is confirmed and unmitigated, placing the theoretical impact ceiling - arbitrary shell command execution - substantially above what the CVSS 4.4 score conveys. No public exploit has been identified and this CVE is not listed in the CISA KEV catalog.

Privilege escalation to SYSTEM in NetKids iMark, a parental control product by Integrated Systems Technologies, Inc. (Japan), allows an authenticated local attacker to execute arbitrary code at the highest privilege level by exploiting an uncontrolled DLL search path. The JPCERT advisory (JVN#28045338) documents two related weaknesses: DLL hijacking via improper search path handling (CWE-427) and a secondary unquoted service path issue, both enabling privilege escalation on affected Windows hosts. No public exploit code or CISA KEV listing has been identified at time of analysis.

The terminal file-preview feature in Open WebUI 0.9.0 through 0.10.2 allows an authenticated attacker with access to a configured terminal server to execute arbitrary scripts in the application's own browser origin by exploiting a hardcoded iframe sandbox misconfiguration, enabling full session token theft and account takeover. The `serveUrl` iframe branch unconditionally combined `allow-same-origin` with `allow-scripts` for HTML files served from the application's own domain, completely negating iframe sandbox isolation regardless of user settings. In the highest-impact scenario, if the victim holds admin privileges or `workspace.functions`, the account takeover extends to server-side code execution on the Open WebUI host. No public exploit has been identified at time of analysis, and this CVE is not listed in the CISA KEV catalog; a vendor patch is available in version 0.11.0.

Code injection in VibeSurf's Python Validation Handler enables remote unauthenticated attackers to inject and execute arbitrary Python code by manipulating the /code endpoint. All versions up to commit cd6e519d507cdd4d63061300bf60fb176e1f57e0 are confirmed affected per EUVD-2026-52704. No patch is available - the vendor did not respond to disclosure - and a public proof-of-concept exists (CVSS 4.0 E:P, corroborated by an asciinema recording in the references), making exploitation accessible to low-skilled attackers.

Unrestricted file upload in the Chat Widget WordPress plugin before 1.8.2 allows any network-reachable user to submit arbitrary files to the plugin's public response endpoint, bypassing all validation of type, extension, content, and size. Uploaded files are stored in the WordPress uploads directory under bare UUIDs - stripping the original extension - which explicitly prevents code execution or stored XSS despite the CWE-434 classification. Real-world impact is bounded to disk exhaustion and abuse of the hosting environment to serve attacker-controlled static content, conditional on the channel's response storage or mail-forwarding feature being configured. No public exploit identified via CISA KEV; however, a proof-of-concept is publicly available per WPScan, and EPSS at 0.16% (6th percentile) signals minimal observed exploitation activity.

Off-by-one memory corruption in popt's poptStuffArgs function allows a local low-privileged attacker to overwrite adjacent memory and potentially execute arbitrary code within any host application that unsafely processes the corrupted argument data. All supported Red Hat Enterprise Linux releases (6 through 10), Red Hat Hardened Images, and OpenShift Container Platform 4 ship the affected library. No public exploit code has been identified and no CISA KEV listing exists; exploitation requires high-complexity triggering conditions, making this a routine patch priority rather than an emergency response item.

Cross-site scripting in Soliton Systems MailZen Management Portal versions 2.62 and 2.63 allows a network-accessible, unauthenticated attacker to inject malicious JavaScript into user-controlled fields (Role Name, First Name, Last Name, Username) that is subsequently rendered to authenticated users - most likely administrators reviewing account data. Exploitation yields client-side arbitrary JavaScript execution in the victim's browser context, enabling session hijacking, credential theft, or unauthorized administrative actions. No active exploitation is recorded in CISA KEV, and EPSS indicates a 0.19% probability of near-term exploitation; however, a public researcher writeup exists on GitHub (FahadAljuaid), meaningfully raising practical risk.

Code injection (CWE-94) in Microsoft Edge (Chromium-based) enables network-based spoofing attacks against users who interact with attacker-controlled content. An unauthorized remote attacker can exploit improper code generation controls to inject and execute code within the browser's execution context, crossing security scope boundaries (S:C) to spoof content or interfaces presented to the victim. No public exploit has been identified at time of analysis (E:U temporal metric), and Microsoft has released an official fix via the MSRC update guide.

Missing authorization in Apache NiFi's Parameter Context update REST API allows an authenticated user with write access to a Parameter Context to alter parameter values that affect referencing components the user is not authorized to access. In deployments where parameter values contain executable scripting content, this privilege boundary bypass can trigger code execution during automatic component validation on stopped processors without the attacker needing to start those components. No public exploit has been identified; exploitation is bounded to deployments using component-level authorization policies and is confirmed fixed in Apache NiFi 2.11.0 per NIFI-16148.

PHP Object Injection in Clearfy Cache WordPress plugin (versions before 2.4.3) exposes administrator-authenticated users to potential remote code execution through unrestricted deserialization during settings import. The plugin's import handler passes attacker-controlled serialized data to PHP's unserialize() without class whitelisting, enabling object injection. A publicly available POC exists via WPScan, though RCE is conditional on a suitable gadget chain being present in the WordPress environment; EPSS is low (0.21%, 12th percentile) and no CISA KEV listing has been issued, indicating no confirmed widespread exploitation.

PHP object injection via unsafe deserialization in the ChamaWP WordPress plugin (versions before 1.0.13) enables unauthenticated network attackers to achieve remote code execution, contingent on the presence of a suitable gadget chain within the broader WordPress installation. The CVSS vector (PR:N, UI:N) confirms no authentication or user interaction is required, though the AC:H rating reflects the dependency on exploitable gadget chains from co-installed plugins or libraries. A public proof-of-concept exists per WPScan, with EPSS at 0.22% (13th percentile), indicating low current automated exploitation activity despite code availability - this suggests targeted rather than widespread opportunistic exploitation at time of analysis.

Heap-based out-of-bounds write in GIMP's PAA (Paint Shop Pro Array) file format plugin allows a remote attacker to potentially execute arbitrary code on a victim's system by tricking the user into opening a specially crafted PAA image. The flaw resides in the decode_lzss() decompression function, which writes data beyond the bounds of the allocated heap buffer, enabling heap metadata corruption. No public exploit or CISA KEV listing exists at time of analysis, but the RCE-tagged impact and buffer-write primitive make this a higher-severity risk than the CVSS 5.5 score suggests; the CVSS impact metrics reflect only availability (A:H) while the description and tags indicate arbitrary code execution potential - a notable discrepancy to investigate.

PHP object injection in the Event Booking Manager for WooCommerce WordPress plugin (all versions before 5.3.7) allows authenticated contributors to deserialize attacker-controlled PHP objects through event content fields. Exploitation to achieve remote code execution, arbitrary file deletion, or sensitive data retrieval depends entirely on the presence of a usable POP (Property-Oriented Programming) chain from a co-installed plugin or theme - none exists within this plugin itself. A publicly available exploit exists per WPScan (EUVD-2026-51948), and this CVE represents an incomplete remediation of prior object-injection advisories affecting the same plugin.

HTTP/2 streamed upload requests in axios 1.13.0-1.17.x bypass the configured maxBodyLength limit, allowing applications that proxy attacker-controlled streams to an upstream HTTP/2 service to transmit outbound data of arbitrary size. The flaw is constrained to upload-forwarding architectures that explicitly configure a finite maxBodyLength, use the Node.js HTTP adapter with httpVersion: 2, and accept streamed request bodies - conditions common in reverse-proxy and file-upload relay patterns. Impact is limited to resource exhaustion and policy bypass (excess egress costs, upstream quota consumption, limited availability); no public exploit has been identified and the CVE is not listed in CISA KEV.

Local file inclusion in the GetPaid WordPress plugin (versions ≤ 2.8.56) enables authenticated administrators to include and execute arbitrary PHP files on the server by supplying a crafted element type value to the getpaid_payment_form_element function. The root cause (CWE-98) is twofold: the element type string was used unsanitized to construct a PHP template file path, and the bare extract($element) call without EXTR_SKIP allowed attacker-controlled array keys to overwrite internal variables including the path already resolved. No public exploit code or active exploitation (CISA KEV listing) has been identified at time of analysis; real-world risk is substantially constrained by the administrator-level access and PHP file upload prerequisites.

Zip Slip path traversal in the Kirki WordPress plugin (all versions through 6.0.13) enables authenticated attackers with custom-level access or above to write arbitrary files anywhere on the server, leading to remote code execution. The root cause is the plugin's app installation and update workflows - install_app, update_app, and get_kirki_template_from_zip - which fetch a user-supplied external ZIP URL via an unsanitized app src parameter and extract its contents without validating entry names for path-traversal sequences. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the write-to-RCE escalation path is mechanically straightforward once the authentication bar is cleared.

Remote code execution in Advantech ADAM-3600 EdgeLink industrial edge gateways allows an authenticated attacker to overflow a fixed-size stack buffer in the device's file-upload functionality and execute arbitrary code on the controller. The flaw affects all versions listed in the CSA advisory (AL-2026-097) and, given the device's role in OT/SCADA data acquisition, a successful exploit yields full control of an industrial edge node. No public exploit has been identified at time of analysis, and high attack complexity plus a high-privilege requirement temper the network-facing CVSS 4.0 base score of 7.5.

Code injection in Amazon's @aws-amplify/codegen-ui-react before 2.20.6 lets a remote authenticated Amplify Studio user embed attacker-controlled code into generated React components by supplying crafted component or theme schema values (CWE-94). The malicious code executes wherever the generated artifacts run - end-user browsers, developer machines, CI/CD pipelines, and server-side rendering contexts - giving broad code-execution reach. This is a bypass of the input validation added for CVE-2025-4318, which proved insufficient in coverage and effectiveness; no public exploit has been identified at time of analysis, though a vendor patch (v2.20.6) is available.

Script injection in Spring Tools for Eclipse's New Spring Starter Project wizard allows arbitrary JavaScript execution inside the IDE's embedded SWT browser when a developer hovers over dependency checkboxes rendered from a compromised or attacker-controlled Initializr endpoint. Affected are all versions through 5.2.0, per the vendor (VMware/Spring) advisory. Despite the 'RCE' tag in associated intelligence, the vendor explicitly bounds the impact to in-IDE UI spoofing and outbound network beaconing - not host-level code execution. No public exploit code and no CISA KEV listing have been identified at time of analysis.

Cleartext credential storage in Spring Tools for Eclipse 5.2.0 and earlier exposes the Spring Boot DevTools remote secret (`spring.devtools.remote.secret`) in Eclipse `.launch` XML configuration files, which Eclipse persists to either workspace metadata or - critically - directly into the project tree when marked as a shared configuration. The exposed secret is the sole credential protecting the DevTools remote restart/reload endpoint, which accepts and executes arbitrary class bytes, converting a credential-disclosure flaw into a remote code execution primitive against the associated Spring Boot application. No public exploit has been identified at time of analysis, but the attack technique is mechanically straightforward once the secret is retrieved from a committed VCS file or accessible workspace backup.

sqlite 3.41 has a use-after-free vulnerability in the memory buffer processing logic. Remote attackers can exploit this flaw via specially crafted input to cause arbitrary code execution, sensitive information leakage, or service denial.

Heap-based buffer overflow in Autel MaxiCharger AC Elite Home EV chargers enables arbitrary code execution by physically present, unauthenticated attackers via malformed USB packets. The device's USB packet handler copies attacker-controlled data into a fixed-length heap buffer without validating input length, allowing full control of device execution context. Reported by Zero Day Initiative (ZDI-CAN-29048 / ZDI-26-436); no public exploit code identified at time of analysis and not listed in CISA KEV.

Stack-based buffer overflow in the NFC card response handler of Autel MaxiCharger AC Elite Home EV chargers enables arbitrary code execution by a physically present attacker. The device's NFC interface fails to enforce bounds on a fixed-length stack buffer when processing card responses, allowing a maliciously crafted NFC card to overwrite stack memory and redirect execution flow to attacker-controlled code. No authentication is required to trigger the flaw - proximity to the device and a crafted NFC card are the sole prerequisites. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.

Arbitrary code execution in Autel MaxiCharger AC Elite Home EV chargers is possible for physically present attackers who supply a crafted, unsigned or improperly signed firmware update image to the device. The flaw (CWE-347) stems from the absence of cryptographic signature validation during the software update process - tagged as a JWT attack vector - meaning the update mechanism accepts attacker-controlled images without verifying their authenticity. No public exploit has been identified at time of analysis, and exploitation requires physical proximity, but a successful attack achieves full code execution in the device context with high confidentiality, integrity, and availability impact.

Path traversal in pip (CWE-36) allows a malicious package index to write downloaded wheel files to arbitrary filesystem locations outside the intended download directory. The root cause is pip's `Link.filename` property double-decoding percent-encoded URL path segments, letting an attacker embed encoded path separators that survive initial URL parsing but resolve during the second `urllib.parse.unquote()` call. Practical impact is most material for `pip download --only-binary` workflows pointed at untrusted indexes; no public exploit or active exploitation has been identified at time of analysis.

Unsafe tar extraction in Penelope Shell Handler (pip package penelope-shell-handler, versions prior to 0.19.3) enables a malicious or compromised remote session to write arbitrary files on the penetration tester's (operator's) machine by returning a crafted tar archive containing path-traversal entries such as `../`. The vulnerability is exclusively triggered by the Unix `download` command path and can be chained to operator-side code execution by overwriting `~/.penelope/peneloperc`, which Penelope `exec()`s on startup and on `reload`. A fully working proof-of-concept is included in the GitHub Security Advisory, demonstrating the complete file-write-to-RCE chain. No public record of active exploitation (CISA KEV) has been identified at time of analysis.

SQL injection in the Advocate Office Management System 1.0 (a SourceCodester PHP application) lets remote unauthenticated attackers inject arbitrary SQL through the 'id' GET parameter of control/activate_case.php. Publicly available exploit code exists (SSVC exploitation status: poc), with confirmed error-based and time-based blind techniques enabling full database extraction; the 'remote code execution' framing in the report is not substantiated by the provided sqlmap payloads. EPSS is low (0.16%, 6th percentile) and the flaw is not on CISA KEV, so no active exploitation is confirmed.

HTTP response splitting in Rouille 0.4.0 to 3.6.2 allows remote attackers to inject arbitrary response headers. By embedding carriage return or line feed bytes into percent-decoded query parameters or Cookie header values, attackers can perform cache poisoning, session fixation, and override security policies like CSP or CORS. No active exploitation is confirmed, but proof-of-concept code may exist.

Remote unauthenticated denial of service in gopacket <= 1.6.0 via a single crafted sFlow UDP datagram that triggers an unbounded memory allocation of up to 16 GiB, causing the parsing process to be OOM-killed. Affected services include any network telemetry collector or application that uses gopacket’s sFlow decoder without additional validation. A proof-of-concept exploit exists and can crash the process with just a 104-byte packet.

Remote denial-of-service in the gopacket library's Diameter AVP decoder allows unauthenticated attackers to trigger a ~4 GiB memory allocation per crafted packet, causing OOM kill after two messages under memory constraints. The flaw affects gopacket ≤1.6.0 (latest before fix), and publicly available exploit code demonstrates end-to-end exploitation against a collector with a 256 MB memory cap. No active exploitation is currently reported.

Command injection in Ericsson Packet Core Controller (PCC) prior to version 1.38 allows authenticated high-privilege attackers with adjacent network access to execute arbitrary code as root. The vulnerability stems from improper sanitization of special elements (CWE-78) in OS command execution. No public exploit or active exploitation reported.

Integer overflow in the print_string_ptr() function of the cJSON library on 32-bit platforms causes a heap buffer overflow when processing crafted JSON strings with approximately 858,993,460 control characters. Applications using cJSON_PrintBuffered() with a pre-allocated buffer are vulnerable, potentially leading to remote code execution, information disclosure, or denial of service. No public exploit or active exploitation has been identified at the time of analysis.

SQL injection in EasyAppointments <=1.5.1 allows unauthenticated attackers to extract and modify database contents via the order_by parameter of /customers/search. Under certain MySQL configurations, the flaw can escalate to remote code execution by writing a PHP webshell using INTO OUTFILE. Public exploit code exists, though no active exploitation has been reported to CISA KEV.

Local code injection in NLTK versions prior to 3.9.3 allows an attacker with low privileges who can invoke the collocations module via the command line to execute arbitrary Python code. A publicly available proof-of-concept exploit demonstrates passing a crafted argument to the BigramAssocMeasures.eval() call, enabling arbitrary code execution including OS commands. The vulnerability has been patched in NLTK 3.9.3.

Persistent code execution via path traversal in BlenderMCP through version 0 (before commit 30a3308) allows attackers performing MITM or prompt injection to overwrite arbitrary files, such as .bashrc, by injecting traversal sequences into API response include keys. Public exploit code exists, but no active exploitation has been confirmed by CISA KEV.

Limited code execution risk in Apache OpenNLP through crafted model archives or untrusted format names permits arbitrary class instantiation without prior validation. The flaw exists in three code paths (GeneratorFactory, StreamFactoryRegistry, and StringInterners) that use Class.forName() on attacker-supplied data. Exploitation is contingent on the presence of a class with hazardous static initializers or no-arg constructors on the classpath; no active exploitation has been reported.

Remote code execution in Cal.com's cal.diy product before 5.9.9 allows an unauthenticated attacker to run arbitrary code on the server by sending a crafted React Server Components (RSC) request. The flaw stems from a bundled vulnerable Next.js version (upstream CVE-2025-55182) that unsafely deserializes attacker-controlled input in the React flight protocol. Rated CVSS 4.0 10.0 (critical) with no authentication or user interaction required; no public exploit identified at time of analysis, though the underlying Next.js class of bug is well documented via the GHSA advisory.

Symlink following in HuggingFace Datasets through version 5.00 allows local low-privileged attackers to redirect archive extraction to arbitrary filesystem locations by pre-planting symlinks at predictable output paths in the shared cache directory. When a higher-privileged user or automated service subsequently triggers Extractor.extract(), the library writes archive contents through the attacker-controlled symlink, enabling overwrite of sensitive system files and potential privilege escalation or code execution. A publicly available exploit exists and an upstream fix is available via commit ad2d853, though no confirmed tagged release version has been independently verified.

Uncontrolled resource consumption in dompdf's BMP image processing pipeline allows any unauthenticated attacker who can submit HTML to a dompdf-powered endpoint to exhaust server memory and stall PHP-FPM worker pools with a 169-byte HTTP request. The library trusts attacker-controlled BMP header dimensions without bounding width × height, causing PHP's GD extension to allocate a full native pixel canvas - bypassing PHP's memory_limit entirely because GD allocates through its own native allocator. A publicly available, verified proof-of-concept demonstrates ~12× memory amplification (34 MB control vs ~412 MB attack peak RSS) from identically-sized requests, making this a high-impact, low-effort denial-of-service primitive. No active exploitation confirmed in CISA KEV at time of analysis.

Dompdf's chroot filesystem restriction is bypassed by embedding SVG content as a base64-encoded data-URI, enabling any external user who controls HTML input to read arbitrary image files from the server filesystem and exfiltrate them via the rendered PDF output. The attack exploits a two-stage validation gap: dompdf's data:// protocol handler applies no chroot rules, and the downstream php-svg-lib dependency - invoked with allowExternalReferences forced to true - calls file_get_contents() with zero chroot awareness. A complete working proof-of-concept is published in the GitHub security advisory (GHSA-cx96-42px-69fm); no public exploit identified beyond the advisory PoC, and no active exploitation confirmed at time of analysis.

Heap-based buffer overflow in GNU diffutils' diff3 tool, triggered by signed integer overflows in internal line-mapping arithmetic, enables crash and potential code execution when diff3 processes crafted diff output. Affected is the diff3 binary across diffutils versions tracked under CPE cpe:2.3:a:gnu:diffutils:*:*:*:*:*:*:*:*, where an attacker controlling the diff program invoked by diff3 (e.g., via the --diff-program option pointing to a malicious script) can induce miscalculated memory allocations followed by out-of-bounds writes. No public exploit identified at time of analysis and no CISA KEV listing; a fix is available via upstream commits reported by CERT-PL.

Arbitrary shortcode injection in the Contact Form 7 - Dynamic Text Extension WordPress plugin (all versions ≤ 5.0.6) allows unauthenticated remote attackers to execute any registered WordPress shortcode on the target site by submitting crafted form input that bypasses input validation before reaching the native do_shortcode() function. The blast radius depends on what shortcodes are registered by other installed plugins, making high-privilege shortcodes the real threat multiplier. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog; however, a partial patch shipped in 5.0.4 was insufficient, leaving sites on all sub-5.0.7 versions exposed.

We are tasked with synthesizing a comprehensive analysis for CVE-2025-50329 from multiple intelligence sources. The output must be a single JSON object with specific fields. We must use all data provided: description, CVSS, EPSS, tags, SSVC, CPE, references, etc. And follow precision rules. Let's review the input data: - CVE ID: CVE-2025-50329 - Description: "An issue in ConeXware, Inc Power Archiver v.22.00.11 and before allows a remote attacker to escalate privileges and execute arbitrary code via the powerarc.exe." - CVSS: 9.8, vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H - CWE: CWE-693 (Protection Mechanism Failure) - EPSS: 0.36% (percentile 28%) - low - Tags: RCE, N A (maybe "N/A"?) - SSVC: Exploitation: none, Automatable: yes, Technical Impact: total - CPE: cpe:2.3:a:n/a:n/a:*:*:*:*:*:*:*:* - this is weird, maybe placeholder. - Affected versions EUVD: ["n/a n/a"] - References: - https://www.powerarchiver.com/ (vendor site) - https://github.com/OV-0-VO/Public-references/blob/main/CVE-2025-50329.md (a GitHub reference, likely a PoC/advisory) - https://github.com/OV-0-VO/Public-references/commit/20437207859288ad1502fed2caebc38be27a3450 (commit diff) - Source code evidence from GitHub: shows a diff in CVE-2025-50329.md. The diff shows a fix: "When extracting files from an archive that bears Mark-of-the-Web, PowerArchiver" - the original line had a trailing space? Actually the diff shows a line change on line 15+4: the original had a space at end? It's unclear. But the important part is the description in the diff context: "When extracting files from an archive that bears Mark-of-the-Web, PowerArchiver" - suggests the vulnerability is related to Mark-of-the-Web handling during extraction, leading to code execution? The commit just removed a trailing space, but the file content itself might have more info. We can view the GitHub file to see the full description. But we only have this diff snippet. We'll infer from the CVE description and tags. Additional info: The CVE description mentions "escalate privileges and execute arbitrary code via the powerarc.exe". No explicit mention of authentication, but CVSS says PR:N so unauthenticated. No mention of KEV, so no active exploitation. No POC tag? Tags include "RCE, N A" - maybe "N A" means "not applicable"? Possibly "no auth"? Not sure. The GitHub repo "Public-references" could contain a proof-of-concept or at least a reference. Given that there's a GitHub reference, likely a public PoC exists. The SSVC says exploitation=none, but automatable=yes, which could mean it's easy to automate. EPSS is 0.36% (low) suggests low likelihood of exploitation in the wild right now. However, the CVSS is critical 9.8, so there is a tension: high CVSS, low EPSS. No KEV listing. We need to construct the JSON. Let's break down each field: product_name: "Power Archiver" (from ConeXware, Inc Power Archiver version 22.00.11 and before). So simply "Power Archiver". summary: Must be original synthesis, not copying description. Start with impact verb and product. So: "Remote code execution in Power Archiver 22.00.11 and earlier allows unauthenticated attackers to escalate privileges and execute arbitrary code via the powerarc.exe executable." Mention EPSS low, no KEV, PoC possibly available? The references suggest a GitHub advisory with details, so likely PoC. Should mention "publicly available exploit code exists" if we infer that. But precision rule: "If POC=YES but no KEV: 'publicly available exploit code exists'". We don't have explicit POC=YES, but the GitHub reference likely is a PoC repo. The commit message doesn't reveal exploit code, just a diff of the markdown file. But the file itself might contain PoC. Since it's from a repository named "Public-references" and the CVE ID is in the title, it's reasonable that the public reference includes exploit details. However, we must be careful: we only have the diff snippet, which just shows a change to the markdown file. The full file might describe the vulnerability and maybe a PoC. But we can't be certain there's a functional exploit. The SSVC says "Exploitation: none", meaning no evidence of exploitation. So I'll assume no active exploitation, but there might be a public technical write-up with possibly PoC details. The precision rule for "publicly available exploit code exists" would be if POC=YES. The input doesn't explicitly say POC=YES. I'll instead say "A technical write-up is publicly available; no exploit code has been confirmed" or something. But the instruction says: "If POC=YES but no KEV: 'publicly available exploit code exists'". Since POC flag isn't given, I'll use "no public exploit identified at time of analysis" as per rule: "If neither: 'no public exploit identified at time of analysis'". That would be conservative. However, the GitHub reference might be a PoC; the file name "CVE-2025-50329.md" could contain steps to reproduce. But the diff only shows a line about Mark-of-the-Web extraction. It's not a functional exploit. So I'll stick with "no public exploit identified at time of analysis". But we can note the existence of a technical write-up. The summary can mention "A proof-of-concept may be available" but the precision rule forbids speculation. I'll avoid claiming exploit code exists. So summary: "Remote code execution in Power Archiver 22.00.11 and earlier allows remote attackers to escalate privileges and execute arbitrary code. The flaw is reachable over the network without authentication. EPSS predicts low exploitation probability, but the vulnerability is easily automatable and has total technical impact." I'll incorporate that. technical_context: Underlying technology: Power Archiver is a file compression utility. The vulnerability likely stems from improper handling of Mark-of-the-Web when extracting archive files, leading to a protection mechanism failure (CWE-693) that allows arbitrary code execution. The CPE string is cpe:2.3:a:n/a:n/a, which seems generic, so we'll note that specific product CPE is missing but the affected product is Power Archiver versions up to 22.00.11. The exact root cause: When extracting files from archives that bear Mark-of-the-Web, PowerArchiver fails to apply proper security restrictions, allowing unsigned code to execute with elevated privileges. The attack vector is through the powerarc.exe executable. Since it's a remote attack (AV:N), the method likely involves sending a malicious archive to a user or a server that processes archives with PowerArchiver, leading to code execution. So educational: Mark-of-the-Web is a Windows mechanism that flags files downloaded from the internet; bypassing it can lead to arbitrary code execution. risk_assessment: Use all signals. CVSS 9.8: network, low complexity, no privileges, no user interaction, scope unchanged, high impact. EPSS 0.36% (28th percentile) suggests low likelihood of exploitation in the wild currently. No KEV listing, so not actively exploited. SSVC: exploitation none, automatable yes, technical impact total. The low EPSS despite high CVSS indicates that while theoretically critical, real-world exploitation is not widespread, perhaps due to limited deployment footprint or other factors. The SSVC automatable=yes with exploitation=none suggests that it could be exploited automatically if motivated attackers target it. The missing CPE data (n/a) indicates no precise product matching, which may affect vulnerability scanners' ability to detect it. POC status unknown. The risk assessment should contrast CVSS with EPSS and mention that it's a critical-severity but not actively exploited, so prioritize based on asset exposure. I'll state that the vulnerability is severe but currently low-risk due to no known exploitation; organizations should still patch. affected_products: Write paragraph listing product, version, and advisory. From description: "ConeXware, Inc Power Archiver v.22.00.11 and before". So version 22.00.11 and earlier. The CVE references include vendor site powerarchiver.com and a GitHub advisory. I'll link to the GitHub advisory as the reference. So: "Power Archiver by ConeXware, Inc, version 22.00.11 and all prior versions are affected. The vendor advisory or confirmation is available at the GitHub reference: https://github.com/OV-0-VO/Public-references/blob/main/CVE-2025-50329.md. The CPE identifier is reportedly cpe:2.3:a:n/a:n/a, which does not precisely identify the product, but the vendor's website is https://www.powerarchiver.com." That should work. remediation: Start with primary fix: upgrade to a version later than 22.00.11, but the specific fixed version is not provided in the data. I'll check references: no mention of a patch version. The vendor site may have updates, but not given. So I'll state "Vendor-released patch: exact fix version not confirmed in the advisory; update to the latest version of Power Archiver beyond 22.00.11 as provided by ConeXware." If no patch, suggest workarounds: Disable automatic extraction of archives from the internet, ensure Mark-of-the-Web protections are enforced, or avoid opening untrusted archives. Since the vulnerability involves Mark-of-the-Web bypass, ensuring Windows security settings are enabled and not using PowerArchiver for untrusted archives could mitigate. Actionable: "Until a patched version is applied, users should avoid extracting archives from untrusted sources with PowerArchiver, and ensure that the 'Unblock' option is not used for files flagged with Mark-of-the-Web." Or use alternative extraction tools. I'll write: "Upgrade to the latest version of Power Archiver (beyond 22.00.11) as soon as a fix is available. In the interim, disable automatic extraction when downloading archives, avoid opening archives from untrusted sources with PowerArchiver, and consider using Windows built-in extraction tools that enforce Mark-of-the-Web properly. Monitor the vendor's website for an official advisory." I can cite the GitHub advisory as a reference for details. But the GitHub reference is not an official advisory, it's a public reference. The vendor website powerarchiver.com is the official source. I'll say: "No official patch version specified; refer to the vendor's website (https://www.powerarchiver.com) for updated versions." I'll note that the GitHub reference contains technical details. So remediation paragraph: "Upgrade Power Archiver to a patched version beyond 22.00.11 once released by ConeXware. As no fixed version number is confirmed in the vulnerability disclosure, consult the vendor's website for the latest update. For immediate mitigation, cease using Power Archiver to extract files from untrusted archives, particularly those bearing the Mark-of-the-Web, and rely on Windows' built-in extraction tools or other archivers that enforce security markings. Alternatively, block PowerArchiver's network access if feasible, but note this may impair legitimate functionality." exploit_scenario: "An attacker crafts a malicious archive file containing executable content and sends it to a victim, perhaps via email or a download link. When the victim extracts the archive using a vulnerable version of PowerArchiver, the Mark-of-the-Web is ignored, allowing the executable to run with elevated privileges, leading to code execution and system compromise." That's a realistic scenario. No PoC confirmed, but the description implies. exploitation_conditions: The CVE description says "via the powerarc.exe". The diff snippet mentions "extracting files from an archive that bears Mark-of-the-Web". So the condition is: user must extract a specially crafted archive using PowerArchiver on a Windows system where Mark-of-the-Web is present. No authentication required. So specific conditions: "Victim must extract a malicious archive file using Power Archiver 22.00.11 or earlier on a Windows system where the archive carries the Mark-of-the-Web. No authentication or special configuration is required." The limiting factor: requires user interaction (UI:N, but actually the user must open the archive). Wait, CVSS says UI:N, which means no user interaction is required. That seems contradictory to the extraction process. Possibly the attack can be triggered automatically when PowerArchiver processes an archive without user interaction, e.g., as a service? The description just says "via the powerarc.exe" — maybe it's a network-accessible service

Remote code execution in ZipGenius 6.3.2.3116 and earlier allows attackers to trick users into opening malicious ZIP files, leading to arbitrary code execution with user privileges. No active exploitation or CISA KEV listing exists; EPSS indicates low exploitation probability, but the CVSS base score of 8.8 reflects potential total system compromise.

Remote code execution in NCH ExpressZip v11.29 allows attackers to execute arbitrary code by convincing a user to open a crafted archive file. The vulnerability is a protection mechanism failure (CWE-693) with no authentication required and user interaction needed. No active exploitation or public exploit is confirmed at this time.

Remote code execution in CoffeeZip v4.8.0.0 allows attackers to achieve full system compromise via a crafted archive file. The flaw requires user interaction, with no authentication needed, and has a CVSS score of 8.8 but low EPSS (0.22%) and no evidence of active exploitation.

Remote code execution in OneCommander v3.96.0.0 allows attackers to execute arbitrary code via the main executable component when a user interacts with malicious content. The vulnerability (CWE-693) has a high CVSS score but low EPSS exploitation probability and no known active exploitation. A public GitHub reference exists, suggesting disclosure of technical details, though exploit availability is unconfirmed.

Remote code execution in Franco Corbelli ZPAQFRANZ v.61.3 and earlier allows an attacker to bypass the Mark-of-the-Web (MotW) protection mechanism, potentially leading to arbitrary code execution with the user's privileges. The vulnerability requires user interaction, such as extracting a malicious ZPAQ archive, and no credentials are needed. Exploitation has not been confirmed in the wild, and EPSS estimates a low 0.35% probability, though public proof-of-concept details may exist.

Local file inclusion in Gitea's restore-repo CLI command allows operator-level attackers to exfiltrate arbitrary server-side files by embedding file:// URIs in release attachment DownloadURL fields within a crafted restore archive. Affected across all releases through v1.22.x (and unpatched master builds), with a fixed version available at 1.27.0. A working proof-of-concept was published by the reporting researchers; no active exploitation has been confirmed by CISA KEV, but successful exploitation yields direct access to high-value secrets including database credentials, SSH private keys, TLS certificates, and cloud provider tokens stored on the Gitea host.

Improper deserialization of untrusted data in NVIDIA Transformers4Rec (all versions per CPE wildcard) exposes systems running the library to code execution, data tampering, and information disclosure via a local attack path. The official CVSS vector assigns C:N/I:N/A:L - a score of 4.3 - which is materially inconsistent with the vendor's own description of potential remote code execution and data tampering; this discrepancy warrants independent verification with NVIDIA's product security team. No public exploit code has been identified at time of analysis, and KEV status is not confirmed.

Heap use-after-free in the SyncTeX parser shipped with TeX Live and embedded by GNOME Evince allows crash or potential arbitrary code execution when a user opens a malformed .synctex or .synctex.gz file. The flaw stems from a NULL parent pointer condition in _synctex_post_process_ref() that bypasses node detachment, causing recursive freeing of live tree nodes and leaving dangling pointers later accessed during document parsing. Exploitation requires local file access and active user interaction (UI:A per CVSS 4.0), no public exploit has been confirmed, but a detailed researcher blog post by the discoverer (Fatih Çelik) is publicly available and the RCE tag suggests demonstrated impact potential.

Unrestricted file upload in Windu CMS version 4.1 enables authenticated low-privilege attackers to upload arbitrary PHP files and achieve remote code execution on the host server. The application performs no validation of uploaded file types, allowing a webshell to be placed and subsequently invoked via HTTP. No public exploit code has been identified at the time of analysis, and no KEV listing exists, but the attack path is trivial once credentials are obtained.

Shortcode injection in the Reviews Feed WordPress plugin before 2.6.5 allows unauthenticated network attackers to execute arbitrary WordPress shortcodes on any site page that renders the affected feed. The attack is indirect: an adversary plants a shortcode payload inside a review on a connected third-party review platform (e.g., a Google Business profile linked to the plugin); when the plugin ingests and renders that review through its dynamic block without neutralizing shortcode syntax, WordPress's native shortcode processor executes the embedded macro. A publicly available proof-of-concept exists per WPScan; no active exploitation has been confirmed in CISA KEV, though the public POC meaningfully elevates practical risk above what the moderate CVSS score of 4.8 suggests.

Cross-site scripting in fuint Member Marketing System v1.0 and earlier allows remote unauthenticated attackers to inject malicious JavaScript through the ClientMessageController component, executing within authenticated users' browser sessions when they view the compromised content. The CVSS 6.1 vector (AV:N/AC:L/PR:N/UI:R/S:C) confirms network-accessible, low-complexity injection requiring no authentication, with scope change indicating browser-context impact beyond the originating request. No public exploit has been confirmed at time of analysis, and this CVE is not listed in the CISA KEV catalog.

Remote code execution affects safishamsi GRAPHIFY versions 0.3.2 through 0.4.29 via a DNS rebinding attack targeting its URL-fetching subsystem. The functions validate_url, safe_fetch, _build_opener, _fetch_html, and _download_binary are exploitable when a maliciously controlled hostname performs DNS rebinding to bypass the URL validation layer, allowing an attacker to pivot into internal network resources and ultimately achieve code execution. A public proof-of-concept repository exists; no KEV listing is present at time of analysis, though the PoC lowers the bar for exploitation.

Code injection in zevorn rt-claw up to version 0.2.0 allows remote attackers to execute arbitrary code via the Telegram-to-AI Tool Execution Flow. The vulnerable function `tool_run_script_execute` in `claw/services/tools/script.c` fails to sanitize attacker-controlled input before passing it to script execution logic. A public proof-of-concept exploit has been released via GitHub issue #138, and the vendor has not yet responded to disclosure - no patch is available at time of analysis.

Full SYSTEM-level code execution in Broadcom's Symantec IT Management Suite (ITMS) 8.7.3 is reachable by any non-administrator interactive user via a DCOM and Windows Task Scheduler logic chain, requiring no network access and no memory corruption. The attack is confined to the local host, meaning a standard user account with an interactive session on the ITMS server is sufficient to achieve unrestricted SYSTEM privileges. No public exploit has been identified at time of analysis, though Broadcom's advisory carries the highest urgency rating (U:Red) and the CVSS 4.0 supplemental metric AU:Y indicates the exploitation steps can be automated once understood.

Path traversal in Activepieces Enterprise Edition git-sync prior to 0.82.0 allows an authenticated project administrator to overwrite arbitrary files on the host filesystem, with potential impact ranging from data tampering and denial of service to remote code execution. Two distinct weaknesses compound each other: Git's symbolic-link handling was not disabled during repository cloning, and user-supplied identifiers - repository slug and the externalId fields for flows, tables, and connections - were concatenated into filesystem paths without sanitization of directory-traversal sequences. No public exploit code has been identified and this CVE is not listed in the CISA KEV catalog, but the patch commit makes exploitation paths derivable by any skilled attacker reviewing the open-source diff.

Drive-by local filesystem exfiltration in FiftyOne versions below 1.17.0 allows any malicious website to silently read arbitrary files from a victim's machine. The FiftyOne App server unconditionally returns Access-Control-Allow-Origin: * on all responses, and the unauthenticated /media endpoint serves local filesystem files by path - together these let JavaScript on any visited webpage fetch files such as SSH keys, cloud credentials, or .env files from localhost:5151 and relay them to an attacker-controlled server. No public exploit (KEV or confirmed POC) is identified at time of analysis, but the attack requires no special tooling and is trivially reproducible in Safari and Firefox, which lack Private Network Access protections.