Code Injection

Unauthenticated remote attackers can delete every device registration in a Parse Server application - or any attacker-chosen subset - by submitting non-string (object) values in installation/device-token fields that are used to build the deduplication query without type validation. The only prerequisite is knowledge of the public application ID, which is intentionally distributed inside client apps; no account, session token, master key, or user interaction is required, and the destructive cleanup runs with elevated privileges before class-level permissions are evaluated. Parse Server versions prior to 8.6.90 and 9.0.0 through 9.10.1-alpha.9 are affected in the default configuration that exposes the REST API to clients and uses push notifications, and because deleted registrations cannot be recovered server-side, push delivery halts until every client re-registers; no public exploit identified at time of analysis, and the vendor-released patch is 8.6.90 or 9.10.1-alpha.9.

Capgo's native build TUS upload proxy forwards a user-controlled TUS resource suffix to the builder service while injecting Capgo's own privileged builder API key, without ever binding that suffix to the upload_path or upload_session_key of the build job the caller was actually authorized for, allowing cross-job writes to another build's upload resource. All versions of capgo.app are affected, and no vendor patch was available at the time of the advisory publication. Exploitation is access-gated rather than anonymous: it requires a valid Capgo API key of scope 'all' or 'write' carrying app.build_native permission for at least one application (plus a legitimate proxy path from an active job A), and knowledge of another job's (job B's) TUS resource suffix, so the realistic impact is integrity-only - corruption of build artifacts - with no read/exfiltration or availability loss, and no public exploit code has been identified at time of analysis.

Authenticated code injection in Horilla HR (horilla-hr) before 2.0.0 lets any user with access to the HorillaListView export functionality run arbitrary operating-system commands with the privileges of the application process - root, in the project's shipped horilla/horilla-hr Docker image. The issue is rated CVSS v3.1 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H): exploitable remotely over the network with low privileges, requiring only a valid account able to reach the list/export endpoint, with no user interaction and no non-default configuration. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor released a fix in version 2.0.0.

Remote code execution in the WordPress s2Member plugin (all versions up to and including 260814) lets unauthenticated attackers execute arbitrary PHP on the server by injecting code through the 'first_name' parameter, which is substituted unsanitized into an eval'd Signup Tracking Codes template. Exploitation is conditional rather than default-config: the site administrator must have configured a Signup Tracking Codes template containing the documented %%first_name%% placeholder, and the attacker must first obtain the site-global proxy verification key that s2Member exposes in plaintext in the JSON response of any PayPal Checkout AJAX request, which also permits bypassing PayPal postback verification. Both prerequisites together yield unauthenticated remote code execution with high attack complexity and no user interaction; no public exploit code or CISA KEV listing was identified at time of analysis, and no EPSS score was provided.

CRLF header injection in zbateson/mail-mime-parser before 3.0.6 and 4.0.2 allows an attacker-influenced attachment filename - including one harvested directly from parsed inbound mail - to be interpolated unescaped into Content-Type and Content-Disposition, so a filename containing \r\n serializes into one or more additional attacker-controlled header lines, for example a forged Bcc: that silently exfiltrates a copy of the outgoing message. Exploitation is limited to PHP applications that use the library to build or forward MIME messages with untrusted filenames (reusing getFilename() output or passing an attacker-supplied name into the attachment APIs); parse-only applications that never re-serialize the filename are not exposed. Per the CVSS vector the issue is network-reachable and requires no authentication or user interaction, no public exploit code was identified at time of analysis, and the vendor has shipped fixes in 3.0.6 and 4.0.2 while the 1.x and 2.x lines are end-of-life and will not be patched.

Amazon Kiro IDE versions before 1.0.242 can have attacker-controlled content written into the agent's auto-loaded global configuration directory (~/.kiro) when a user opens a crafted repository as an untrusted workspace and then sends any message to the agent. The flaw (CWE-829, inclusion of functionality from an untrusted control sphere) is an indirect prompt-injection chain: the agent's file-write tool is steered by repository-supplied instructions rather than by a direct network request, so the attacker does not need credentials (CVSS PR:N) but does depend on victim interaction (CVSS UI:A). Exploitation is not confirmed as active and no public exploit code was identified at time of analysis. Risk is rated High (vendor CVSS 4.0 base 8.6; independent CVSS 3.1 assessment AV:N/AC:H/PR:N/UI:R/S:C/C:L/I:H/A:L), with the dominant impact being integrity compromise of the developer's global Kiro configuration.

Code injection in MongoDB Compass lets an attacker who holds database-creation privileges on a MongoDB server interpolate unescaped shell syntax into the initial input of Compass's embedded MongoDB shell; when a victim user navigates to that database's view and explicitly opens the shell from it, the injected content is evaluated inside the Compass client process with that process's privileges. Exploitation is constrained: the attacker must be able to create databases on the connected server and name one maliciously, and the victim must perform the specific action of opening the shell for exactly that database, which is why the issue carries High attack complexity despite the 7.3 severity. Execution is confined to the Compass client process and does not reach the MongoDB server; Compass v1.49.12 is the fixed release, and no public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.

Authenticated administrators of PaperCut NG/MF can abuse the device-scripting feature's embedded execution engine to break out of its runtime sandbox and run arbitrary operating system commands with administrative privileges on the host. The weakness is a code-injection flaw (CWE-94) rooted in insufficient sanitization and access restrictions inside that scripting engine, and it is heavily gated: the attacker must already hold administrative access to the management interface (CVSS 4.0 PR:H), and the vendor vector's AT:P indicates a further attack precondition must be satisfied beyond mere admin credentials, so this is a high-technical-impact but low-urgency issue for most defenders rather than a broadly reachable one. No public exploit code has been identified at time of analysis and no active exploitation is confirmed by the available data (there is no CISA KEV entry among the supplied sources); prioritise patching environments where device scripting is enabled and administrative access is widely granted.

A credential-isolation flaw in geelen mcp-remote 0.1.16 through 0.1.38 allows a remote attacker who controls or can predict the MCP server URL a victim configures to cause MD5-derived credential-store paths to collide or match, potentially exposing or overwriting another server's cached OAuth tokens via the getServerUrlHash function in src/lib/utils.ts. The package is an npm bridge that connects local MCP clients to remote MCP servers, so practical exploitation depends on the victim adding the attacker's server URL and on the OAuth credential-persistence feature being in use (user interaction), which is inconsistent with the no-interaction AV:N/AC:L/PR:N/UI:N profile of the 9.8 headline score. No public exploit code was identified at time of analysis and EPSS is low (0.29%, 19th percentile), so the CWE-94 arbitrary-code-execution framing should be treated as unverified rather than confirmed remote code execution.

Command injection in the automation controller's external logging (rsyslog) configuration of Red Hat Ansible Automation Platform 2 allows a superuser to achieve arbitrary command execution inside the control-plane rsyslog component, exposing the controller SECRET_KEY and database credentials and enabling decryption of all stored credentials. Exploitation requires authenticated superuser privileges (CVSS 3.1 7.2, PR:H, no user interaction) and only takes effect when external logging is in use, so the malicious RainerScript configuration is actually generated and loaded. No public exploit code was identified and there is no CISA KEV listing indicating active exploitation, meaning real-world risk is strongly gated by the elevated privilege requirement even though the post-exploitation impact is a full control-plane compromise.

Maliciously crafted on-chain account names processed by Klever-Go prior to 1.7.20 are spliced into Elasticsearch _bulk request bodies without JSON escaping, allowing an attacker who can submit a SetAccountName transaction to inject forged bulk actions that create, overwrite, or delete documents in any index the indexer can write to. Because the name is stored in consensus account state, the poisoned value is replayed by new and historical indexers, and no access to the indexing host or the Elasticsearch port is required. Severity is rated 8.4 (CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:H/SC:N/SI:H/SA:L; our independent assessment CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:H/A:H), exploitation requires an authenticated low-privilege on-chain account plus a deployment that actually runs the Elasticsearch indexer, and the issue is fixed in 1.7.20; no public exploit identified at time of analysis, though the upstream fix ships a regression test that reproduces the advisory's injection construction.

Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in user, including one with only low-tier permissions, execute arbitrary Ruby and Python code on the COSMOS server and its per-target decom microservices. COSMOS reads configuration from a user-writable overlay (targets_modified/) before its read-only targets/ tree and then executes that content - rendering it as ERB, eval-ing GENERIC_READ/WRITE_CONVERSION blocks, or require-ing Script Runner procedure files - so an attacker who can write to the overlay via the screen-save or storage-upload endpoints achieves code execution as the openc3 user, which holds Redis and object-store credentials and sits on the internal service network. A working proof-of-concept is published in the vendor GitHub advisory, and the vendor has released 7.3.0 as the fix; no confirmed active exploitation (CISA KEV) has been reported. Reachability is limited on default single-host installs because the shipped docker-compose binds Traefik to 127.0.0.1:2900, so exploitation is realistic on multi-user deployments that expose the web port.

Code generation in orval before 8.29.0 writes the raw OpenAPI operationId into a single-quoted object literal inside generated TanStack Query mutator metadata, so a crafted operationId can break out of the string and inject arbitrary JavaScript that executes when the generated query or mutation hooks are called. Practical exploitation requires a developer or CI pipeline to run orval codegen against an OpenAPI document whose operationId is attacker-controlled and then to execute the generated hooks - a conditional path that hinges on the trust boundary of the ingested spec, even though PR:N appears in the vector; the independent assessment (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) reflects this required victim interaction, while the headline CVSS 4.0 score of 9.3 (UI:N) overstates how freely the flaw triggers. No public exploit code and no CISA KEV entry were identified at time of analysis, and no EPSS score was provided; a vendor patch is available (orval 8.29.0).

Code injection in the Orval OpenAPI client generator (@orval/core before 8.28.0) lets an attacker who controls a multipart schema property name in a supplied OpenAPI document smuggle a `${...}` template-literal expression into the generated client, which then executes as live JavaScript with the privileges of the process that builds or runs that client. The vendor rates this CVSS 4.0 9.3 (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H), while our independent assessment scores it CVSS 3.1 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) because exploitation is not reachable over a network service directly - it requires a developer to generate and then execute a client from an attacker-influenced spec, which is meaningful user interaction. This is a build-time/tooling supply-chain flaw: only organizations that feed untrusted, third-party, or externally sourced OpenAPI documents into Orval and then run the generated code are exposed. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV, though a vendor patch and the upstream fix commits are public, so weaponization of the technique is plausible for anyone who reads the advisory.

Code injection in orval before 8.29.0 lets an attacker who controls or influences the OpenAPI specification being processed smuggle executable JavaScript into the generated client: media-type (Content-Type) keys are written into single-quoted string literals without escaping, so punctuation in a crafted key terminates the literal and injects arbitrary statements into the emitted code. The CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H) makes this an unauthenticated remote code-injection flaw at 9.3, but exploitation in practice is gated by the victim actually running orval over the malicious spec and then invoking the generated fetch operation or mock resolver - our independent assessment therefore applies UI:R (CVSS 3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), and teams that only generate clients from their own trusted specifications are not realistically exposed. No public exploit code or confirmed active exploitation has been identified at time of analysis, and the vendor has released a fix in orval 8.29.0.

Code injection in the Orval OpenAPI-to-TypeScript client generator (@orval/core) before 8.30.0 lets an attacker who controls the default value of a date or date-time field in an OpenAPI schema splice arbitrary JavaScript into generated factory code, which then executes with the privileges of whatever process consumes the generated client. Exploitation is not remote against a deployed service: it requires the non-default factoryMethods and useDates options to be enabled, a developer running codegen against a spec the attacker can influence, and the resulting factory client being executed, giving an assessed CVSS 3.1 vector of AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H (the advisory lists 9.2 under CVSS 4.0). No public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV); the vendor has shipped a fix in 8.30.0.

Code injection in the Orval OpenAPI client generator's @orval/effect package (versions 8.14.0 through 8.28.1) lets an attacker who can influence an OpenAPI schema embed arbitrary JavaScript expressions in the generated validation module, which execute at module scope as soon as that generated code is built or imported. The injection point is the schema `default` value, which the effect generator rewrites into a template literal so that `${...}` syntax (or a literal backtick) re-arms interpolation, with numeric constraints such as minimum/maximum/multipleOf similarly emitted as unquoted expressions; exploitation is remote and does not require prior credentials per the vendor vector (PR:N), but it does require the victim to run the generator against an untrusted or third-party spec and then build or import the output, giving injected code the developer's build-time privileges. No public exploit code has been identified at time of analysis and the issue is patched upstream, so real-world urgency is lower than the vendor's CVSS 4.0 score of 9.3 suggests - this is a build-time/developer-tooling flaw rather than a network-facing service exposure (independent assessment: CVSS 3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, reflecting the victim interaction the vendor rating understates).

Code injection in orval's opt-in @orval/hono generator (all versions before 8.29.0) lets an attacker who controls an OpenAPI document plant an apostrophe in a static path segment and break out of the single-quoted route literal, injecting arbitrary JavaScript that runs whenever the generated TypeScript module is imported or built. This is a build-time supply-chain style flaw rather than a runtime flaw in a network service: the affected party must run orval code generation against an untrusted spec and then import the generated output, and the CVSS v4.0 score of 9.3 reflects high confidentiality, integrity and availability impact on the build/developer environment. Exploitation is not confirmed in the wild (no CISA KEV entry) and no public exploit code was identified at time of analysis, though the upstream patch and the exact vulnerable code path are publicly documented.

An authenticated, low-privileged user of ManageEngine OpManager or ManageEngine Firewall Analyzer (versions 12.8.709 and below) can abuse the 'Rule Tracking Compare Policies' feature to inject crafted XML that is parsed server-side, disclosing data beyond that feature's authorization boundary. The vendor-assigned CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N, base 7.7) reflects a network-reachable, low-complexity issue requiring only any valid console credential and no user interaction, with a scope change and high confidentiality impact but no integrity or availability impact, which confines the practical effect to information disclosure rather than code execution or service disruption. Because a session is required, the flaw is not pre-authentication exploitable; no public exploit code has been identified at time of analysis and no KEV listing was provided in the available intelligence, so exploitation appears to depend on an attacker first obtaining or holding a low-privilege console account with access to the affected feature.

Apache Tomcat's HTTP/2 connector harbors a race condition (CWE-362) that allows unauthenticated remote attackers to inject trailer fields into another user's concurrent HTTP/2 request, resulting in high confidentiality and integrity impact without affecting availability. Affected versions are 11.0.0-M1 through 11.0.25, 10.1.0-M1 through 10.1.59, 9.0.39 through 9.0.121, and the end-of-life 8.5.59 through 8.5.100; exploitation is conditional on winning a concurrency race and only applies when the HTTP/2 upgrade protocol is enabled and actively serving traffic. No public exploit code or active exploitation has been identified at time of analysis, and the overall threat is considered credible but conditional.

Code execution in GNU Emacs versions prior to 31.2 occurs when Flymake performs on-the-fly syntax checking with a language backend other than Emacs Lisp, allowing code embedded in an untrusted file to run with the privileges of the user who opened or edited it. The CVSS vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) reflects that the attack is local and requires the victim to open a malicious file, but needs no privileges and can fully compromise confidentiality, integrity, and availability of that user's session; the flaw is tracked by Red Hat as CVE-2026-96442 with a vendor score of 7.8. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the risk is concentrated in developer and administration workstations where Emacs commonly opens untrusted source files from downloads, mail attachments, or repositories.

Unauthenticated remote code execution in the YAHMAN Add-ons WordPress plugin affects all versions before 0.9.31 when the plugin's remote-file caching feature is explicitly enabled. The plugin stores remotely fetched files in a publicly accessible cache directory without validating their type, so an attacker can plant arbitrary PHP content there and have the web server execute it, yielding code execution with full confidentiality, integrity, and availability impact (CVSS 9.0, CRITICAL; AV:N/AC:H/PR:N/UI:N). Exploitation is unauthenticated and requires no user interaction, but it is gated by the non-default cache feature and rated high complexity (AC:H), and no public exploit code was identified at time of analysis. There is no confirmed active exploitation (no CISA KEV listing).

Server-side template injection in web.py 0.76 allows an attacker who can write to the application's template source directory to achieve arbitrary Python code and OS command execution on the server, but only when the application precompiles those templates and later renders them through the precompiled template loader; that specific deployment pattern is what defeats the template engine's built-in sandbox. The flaw is a genuine RCE-class issue (CWE-94) at CVSS 8.5, yet it is gated by real prerequisites: the CVSS vector indicates authenticated access (PR:L) and high attack complexity (AC:H), because the attacker must first obtain write access to the template directory and the application must use the precompiled code path rather than direct sandboxed rendering. It is not a remote-unauthenticated exploit against stock configurations, and no public exploit identified at time of analysis; exploitation is not confirmed actively exploited (CISA KEV) and no KEV entry is present in the source data.

Remote code execution in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift lets an unauthenticated network attacker run arbitrary code on affected deployments. The flaw is CWE-94 (improper control of code generation): user-controlled input is passed into a JavaScript `new Function()` constructor without neutralization, so injected input is compiled and executed as code. Per the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) no credentials, privileges, or victim interaction are required - only network reach to the vulnerable code path. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation (CISA KEV); the practical limiting factor is exposure, since the specific input-handling routine must be reachable and FTM's narrow financial-services enterprise footprint constrains the target population.

Arbitrary server-side code execution in the Plone process is possible through the Classic portlet shipped in plone.app.portlets 5.0.0 through 7.0.1, where user-supplied template and macro fields are assembled into a TALES path expression and then evaluated by the TAL path() helper, allowing a crafted value to be interpreted as a full expression rather than a constrained path. Any authenticated user who can add or edit a Classic portlet can execute code, and under Plone's default role map that includes ordinary registered users on their personal dashboard, so the issue amounts to a post-authentication privilege escalation across the trust boundary between a web user and the server-side Plone process (CVSS 3.1 9.9, scope changed: AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H). There is no confirmed active exploitation (no CISA KEV listing) and no public exploit identified at time of analysis, but vendor patches are available in 5.0.8, 6.0.4, and 7.0.2.

Format-string injection in RTI Connext Professional Core Libraries (versions 7.5.0 before 7.7.0.1 and 7.3.0.10 before 7.3.1.6) allows unauthenticated remote attackers with access to a DDS domain to corrupt memory, potentially leading to code execution or denial of service. Exploitation is gated by high attack complexity-the attacker must precisely control data that reaches a vulnerable format-string sink-and by the need for network reachability to a DDS domain, which is typically segmented in robotics, industrial, and defense deployments. No public exploit code has been identified at time of analysis.

Arbitrary code execution in Adobe Campaign Classic, documented in Adobe security advisory APSB26-142, lets remote attackers run code in the context of the running ACC service. The vendor's CVSS 3.1 base score of 10.0 (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H) marks it as maximum severity: network-reachable, low-complexity, unauthenticated, requiring no user interaction, with a scope change and full loss of confidentiality, integrity, and availability. No public exploit code has been identified and there is no confirmed active exploitation (no CISA KEV listing) at time of analysis, so the practical exposure driver is whether an unpatched ACC instance is reachable over the network.

Unauthenticated remote code execution in Adobe Campaign Classic lets any attacker who can reach the server run arbitrary code in the context of the affected process, and the CVSS 3.1 base score is the maximum 10.0 (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H) with scope changed, meaning a successful compromise can cross the component's security boundary and affect resources beyond its intended authority. No user interaction and no authentication prerequisite are required, so the practical exposure is driven almost entirely by whether an ACC instance is reachable from untrusted networks. No public exploit code and no confirmed active exploitation were identified at time of analysis, but the structural severity signals make this a top-priority patch item; Adobe's bulletin APSB26-142 is the authoritative source for fixed builds.

Code injection in Adobe Campaign Classic allows an authenticated attacker holding only a low-privileged account to execute arbitrary code on the server in the context of the current user, with no user interaction required (CVSS 9.9, Critical). The flaw is network-reachable and low-complexity, but the required low-privilege account is the primary limiting factor - this is not exploitable by fully unauthenticated remote attackers, unlike some sibling Adobe Campaign issues. No public exploit code and no confirmed active exploitation were identified at time of analysis; Adobe has published a security advisory (APSB26-142) for the issue.

Unauthenticated remote code execution in Adobe Campaign Classic (ACC) allows a network-reachable attacker to execute arbitrary code in the context of the current user, as described by the vendor CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H (score 10.0). The flaw is a CWE-94 code injection issue tracked via CPE cpe:2.3:a:adobe:adobe_campaign_classic, with exact vulnerable and fixed builds enumerated only in Adobe advisory APSB26-142, which the provided data points to but does not quote. No public exploit code and no confirmed active exploitation were identified at time of analysis, but because exploitation requires no authentication and no user interaction, any ACC instance reachable from untrusted networks should be treated as high risk.

Unauthenticated remote code execution in Adobe Campaign Classic allows an attacker who can reach the application to execute arbitrary code with a CVSS 3.1 base score of 10.0 (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H); no user interaction is required, and the scope change means impact is not necessarily confined to the vulnerable component. The affected version range and fixed build are not enumerated in the available intelligence, and no public exploit code or confirmed active exploitation (CISA KEV) has been identified at time of analysis, so risk is currently driven by structural severity rather than observed attacks. Because ACC is an internet-reachable marketing automation platform that typically stores customer data and holds credentials for downstream systems, this should be treated as a top-priority patch item even though corroborating sources are limited to Adobe's own advisory.

Remote, unauthenticated attackers can execute arbitrary code in the context of the current application user on systems running Adobe Campaign Classic, tracked as CVE-2026-73369, per the CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:C with a base score of 10.0 (CWE-94 code injection). Exploitation requires no authentication, no user interaction, and no confirmed special configuration; the vector's changed scope (S:C) means the compromise can affect resources beyond the vulnerable component's security authority, though the code itself runs as the current application user rather than as a privileged system account. No public exploit code has been identified at time of analysis and CISA KEV does not list this issue, but the impact, the low attack complexity, and the two practical limiting factors - network reachability of the ACC instance and the currently unspecified affected version range (CPE is a wildcard) - make this a genuine top-tier priority for any deployment confirmed affected by Adobe advisory APSB26-142.

Code injection in Adobe Campaign Classic allows remote attackers to execute arbitrary code in the context of the current user, carrying a maximum-severity CVSS 3.1 base score of 10.0 (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H) with no user interaction required under the vendor vector. The CPE data flags the product with a wildcard version, so the specific affected release range is not enumerated in the supplied intelligence, and Adobe's advisory (APSB26-142) is the only reference. Exploitation status: no public exploit identified at time of analysis; independent analysis cautions that the advisory is sparse and that the description's 'current user' wording may imply an existing session context, so the PR:N unauthenticated rating should be confirmed with Adobe.

Authenticated shortcode injection in the WP Ultimate Review WordPress plugin (Roxnor) allows any user with subscriber-level access or higher to run arbitrary registered shortcodes on sites running version 2.4.2 or earlier. The attacker passes a crafted value to a plugin action that feeds it into do_shortcode() without validation (CWE-94), yielding high confidentiality and integrity impact per the assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N (8.1). No public exploit code was identified at time of analysis and there is no confirmed active exploitation (CISA KEV), but on sites with open registration the subscriber prerequisite is trivial to satisfy, and the real-world severity is bounded by which powerful shortcodes are registered by this or other installed plugins and themes - arbitrary operating-system command execution is not guaranteed.

Unauthenticated remote code execution affects ZLMediaKit builds based on commit 9fd5152, where broken access control in the HTTP API allows a remote attacker to overwrite the ffmpeg.snap snapshot configuration parameter with arbitrary shell commands through the setServerConfig endpoint, which are then executed with the privileges of the ZLMediaKit process when getSnap is invoked. Per the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8), no credentials or user interaction are required - the only practical prerequisite is network reachability to the exposed HTTP API service. Exploitation has not been confirmed as active (not in CISA KEV) and no public exploit code was identified at time of analysis; the EPSS score is low at 0.21% (11th percentile), but the unauthenticated, full-compromise nature of the flaw makes it a top-priority fix for any internet-facing or hostile-network-reachable deployment.

Authenticated OpenStack project members can inject arbitrary HAProxy configuration directives - and from there achieve code execution on Amphora load-balancer instances - by embedding newline characters in the tls_ciphers field of a TLS-enabled listener or pool in OpenStack Octavia before 18.0.1. The value is written verbatim into the HAProxy configuration generated on the amphora, so a crafted cipher string breaks out of the intended directive and appends attacker-controlled configuration (CWE-94). Only deployments using the Amphora provider driver are affected; no public exploit code was identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV), though the assessed CVSS:3.1 vector is AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, reflecting high confidentiality, integrity, and availability impact that extends beyond the vulnerable component to the amphora instance itself.

Authenticated OpenStack project members who own a load balancer can inject arbitrary HAProxy directives into the amphora configuration produced by Octavia before 18.0.1, because the Amphora provider driver fails to reject control characters in L7 policy redirect_url and redirect_prefix fields. The RFC 3986 URL validator percent-encodes control characters before validating, so newline-bearing payloads pass structural checks, but the raw value is stored and written verbatim into the generated HAProxy config - yielding code/directive injection with high confidentiality, integrity, and availability impact on the amphora and the traffic it proxies. Exploitation requires valid tenant credentials plus ownership of a load balancer (CVSS PR:L, unauthenticated paths do not exist), and only Amphora-provider deployments are affected; OVN and other Octavia providers are explicitly immune. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, though the assessment rates it a genuine high-priority problem rather than an inflated score.

Remote code execution in Univer v1.0.0-alpha.2 allows unauthenticated network attackers to execute arbitrary code via a crafted payload sent to the RemoteRegisterFunctionService endpoint (/remote/remote-register-function.service.ts). The vulnerability is rated CVSS 9.8 (critical) and requires the remote function-registration service to be reachable; only this pre-release alpha build is named as affected. No public exploit code or confirmed active exploitation has been identified, and EPSS indicates a low likelihood of exploitation (0.21%).

Arbitrary code execution in the npm front-matter parser gray-matter is reachable through its built-in JavaScript engine, which evaluates front matter with eval() whenever the document declares a js/javascript language fence. Any application that passes attacker-influenced markdown or front-matter text into gray-matter's parse call can be induced to run attacker-supplied JavaScript in the Node.js process - the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) rates this as unauthenticated remote code execution, with the practical caveat from our assessment that the attack surface is gated by whether the host application exposes gray-matter parsing to untrusted content. Affected coverage is broad rather than version-specific: the reporter states all versions are impacted and verified 4.0.3, while there is no CISA KEV entry, no confirmed public exploit code, and a low EPSS of 0.17% (7th percentile) indicating limited observed exploitation pressure at time of analysis.

Remote code execution affects Univer v1.0.0-alpha.2 through its Uniscript feature: the UniscriptExecutionService.execute() function in /services/script-execution.service.ts evaluates attacker-influenced script content (CWE-94), allowing arbitrary code execution with the privileges of the hosting process. The input CVSS vector rates this 9.8 (AV:N/AC:L/PR:N/UI:N), but the authoritative assessment refines the privilege requirement to PR:L, meaning an attacker generally needs a delivery channel - and for most deployments at least application-level access - to place a crafted script into the execution service, and the exposure is further limited to deployments that actually enable Uniscript on this early alpha build. No confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis; EPSS is 0.21% (11th percentile), indicating low modeled near-term exploitation likelihood.

Authenticated remote code execution in OrdaSoft Joomla Gallery (both the free and commercial editions) for Joomla below version 6.2.7 lets anyone holding a privileged Joomla backend account execute arbitrary PHP functions on the underlying server. The extension's updateOSGallery() handler, invoked through task=update_osgallery, takes a JSON body and calls the supplied 'method' value as a live PHP function with the 'package' value as its only argument, with no is_callable() check or allow-list, so functions such as system, exec, shell_exec and passthru are directly reachable. Rated CVSS 9.4 (CVSS 4.0 AV:N/AC:L/AT:N/PR:H/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H; independently assessed as CVSS 3.1 scope-changed with C:H/I:H/A:H); exploitation requires authentication with a high-privilege role, which is the main limiting factor - this is not reachable by anonymous internet users, and no public exploit code was identified at time of analysis.

Unauthenticated remote code execution in REDCap 13.3.0 and later allows an attacker who knows a valid public survey hash to reach an unintended controller route through the survey passthrough routing logic and then supply a crafted file-path/stream parameter to the Data Import processing logic, resulting in arbitrary code execution on the REDCap server. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) confirms remote, unauthenticated exploitation with no user interaction required, but the mandatory knowledge of a valid public survey hash is a meaningful prerequisite that rules out blind mass scanning and confines practical exposure to instances actively publishing public surveys. Exploitation status: no public exploit identified at time of analysis; the flaw was reported by Securifera.

Authenticated code execution in the Forminator Forms WordPress plugin (before 1.57.2.1) lets a user who holds the plugin's forms-management capability abuse unrestricted class instantiation during deserialization of an XML-RPC value, ultimately writing a file of the attacker's choosing and executing arbitrary code on the server. That capability is granted to administrators by default, so sites that have not delegated it through Forminator's own settings are materially less exposed, but any lower role given forms-management can reach the flaw; exploitation also depends on a reachable XML-RPC interface and a usable PHP gadget chain, which is reflected in the high attack-complexity component of the 8.5 CVSS score (PR:L, AC:H). Publicly available exploit code exists, and a vendor patch shipping in 1.57.2.1 is available, so sites running affected versions should upgrade promptly.

Malformed UTF-16 decoding in libexpat through 2.8.4 lets remote attackers hide XML markup from the parser: a lone high surrogate paired with the following code unit is accepted as a valid surrogate pair, so a character such as '<' is consumed as part of the pair and never tokenized. Only applications that parse UTF-16-encoded XML (little- or big-endian) from an untrusted source are affected - the dominant UTF-8 input path is not exploitable - and meaningful integrity impact additionally requires a downstream filter, sanitizer, or validator that trusts the parsed structure and therefore sees different markup than Expat exposes. No public exploit has been identified at time of analysis; an upstream fix is available in the Expat repository (PR #1282, commit ff6e1d7e750bbe245178f51a47a965dc8342861a), reported via VulnCheck.

Code execution in OpenPanel's js-runtime component lets an authenticated user who holds project write access escape the JavaScript webhook template sandbox and run arbitrary code inside the worker process. The template validator fails to block computed (bracket-notation) member access that traverses a constructor chain to the Function constructor, so merely creating or editing a webhook template is sufficient - no user interaction is required (UI:N). No public exploit code has been identified at time of analysis, and no CISA KEV or EPSS signal was supplied, but our independent assessment rates this a genuine high-priority issue, with CVSS 3.1 AV:N/PR:L/UI:N/S:C/C:H/I:H/A:H (scope change to the host system and full confidentiality, integrity and availability impact).

Authenticated users with subscriber-level access or higher can execute arbitrary WordPress shortcodes through the ProfilePress plugin (slug wp-user-avatar) in all versions up to and including 4.17.2, because user-controlled values reach do_shortcode() without validation. Exploitation requires a low-privilege account, which is trivially obtained on sites that enable the plugin's self-service registration feature, and no user interaction is needed; however, the practical impact is variable and often limited, since substantial confidentiality or integrity loss only materializes when other privileged or data-exposing shortcodes are registered on the same site. The vendor's upstream severity rating is 8.1, while independent assessment rates the realistic vector as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N (limited C/I, no availability impact); no public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis.

Remote code execution in The Welcomizer WordPress plugin versions up to and including 2.8.1 lets authenticated users with Subscriber-level access or higher execute arbitrary PHP on the server by abusing the twiz_ajax_callback AJAX action's savesection handler. The handler checks a nonce but omits a current_user_can() capability check, and eval() processes attacker-supplied PHP from the twiz_custom_logic POST parameter when output is set to twiz_logic_output; the nonce is exposed to any authenticated user via twiz-ajax.js.php, so it does not prevent exploitation. Wordfence reports this with CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), and no public exploit identified at time of analysis.

Arbitrary PHP function invocation in the Save as PDF Plugin by PDFCrowd for WordPress (all versions up to and including 4.6.1) allows any authenticated user with Contributor-level access or higher to have the server AES-encrypt an attacker-chosen pdf_created_callback value into a valid button blob, which is later passed to PHP as a callable when any unauthenticated visitor POSTs that blob to the wp_ajax_nopriv_save_as_pdf_pdfcrowd AJAX endpoint. Published CVSS 3.1 is 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H); our assessment retains the High rating but bounds the impact to C:H/I:L/A:L because the invoked callback receives only the plugin's options array as its single, fixed argument, making disclosure of the site's stored PDFCrowd API key and username the most reliable outcome rather than fully attacker-controlled code execution. Contributors are required only to mint the blob - the trigger replay is unauthenticated - and no public exploit identified at time of analysis, with no confirmed actively exploited (CISA KEV) status.

Shortcode injection in the WP Recipe Maker plugin for WordPress (all versions up to and including 10.8.1) lets an attacker plant arbitrary registered shortcode tokens inside the content of an approved wprm-comment-rating comment, which the plugin later feeds through do_shortcode() during recipe metadata generation and reflects into the JSON-LD reviewBody field served on every recipe page render. Because execution occurs before the plugin's strip_shortcodes()/wp_strip_all_tags() cleanup runs on the resulting string, output from sensitive shortcodes (attachment captions, private post fields, other data exposed by installed shortcodes) can be disclosed to any visitor loading the affected page. The CVSS vector records PR:N, so the injection itself is unauthenticated, but practical exploitation is gated by the site's comment-approval threshold and by whether installed shortcodes actually expose sensitive content; the vendor score of 9.1 is assessed as inflated relative to an AC:H/I:L reality, and no public exploit code has been identified at time of analysis.

Unauthenticated attackers can execute arbitrary WordPress shortcodes through the Forminator Forms plugin (all versions up to and including 1.57.2) because a value reaching do_shortcode in the quizzes front-action handler is not properly validated. A site is only reachable through this path if Forminator is installed and active and a form or quiz routes through the vulnerable front-action, and the real-world damage is bounded by which shortcodes other installed plugins register - benign shortcodes mean limited impact, while data- or state-changing shortcodes raise it substantially. No public exploit code or confirmed in-the-wild activity (CISA KEV) was identified at time of analysis; note that the vendor-assigned CVSS 9.1 overstates the assessed impact, which our analysis places at CVSS 6.5 (C:L/I:L) for fully remote, unauthenticated, low-complexity exploitation.

Unauthenticated insecure deserialization in the Change Audit System (CAS) listener of IBM Guardium Data Protection 12.2 allows a network attacker who can reach TCP port 16017 to submit crafted serialized messages that are insecurely deserialized and used for attacker-controlled reflective method dispatch, potentially resulting in unintended code execution on the Guardium appliance with high confidentiality, integrity, and availability impact. The vendor-reported base score is 9.8 (AV:N/AC:L/PR:N/UI:N); our independent assessment keeps the unauthenticated, no-user-interaction profile but applies AC:H, because the practical gating factor is whether an attacker has a network path to the non-standard CAS port rather than any product configuration toggle. No public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited (not in CISA KEV); IBM has published a vendor patch advisory, and this should be treated as a genuinely high-priority issue for any deployment where port 16017 is reachable from untrusted networks, while remaining lower-risk in segmented or hardened environments where the listener is internal-only.

Prototype pollution in the deepmerge JavaScript library (all versions through 4.3.1) allows an attacker who controls a source object passed into a merge operation to inject properties such as '__proto__', 'constructor', or 'prototype' into the resulting object's prototype chain. The impact is latency-dependent: applications that merge untrusted data (for example, a JSON request body) and then read properties without own-property checks will silently inherit attacker-chosen values, which can corrupt application logic, bypass authorization checks, or influence downstream behaviour. The flaw is a library primitive rather than a standalone exploit, and no public exploit code was identified at time of analysis; the vendor CVSS 4.0 score of 8.7 reflects integrity impact only (VC:N/VA:N), and an independent assessment rates it considerably lower (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N) because exploitation requires the consuming application to both pass attacker-controlled source objects and perform unchecked inherited-property reads.

Authenticated users of SysReptor Professional can turn a crafted image upload into arbitrary code execution: image formats that cause the platform's processing pipeline to invoke Ghostscript allow embedded PostScript to run inside a shared temporary directory, and a race against GnuPG configuration files created in temporary subdirectories makes GnuPG copy attacker-controlled Python into the application code directory, where it executes with the SysReptor process's privileges after the next worker restart. The Community edition is not affected, and exploitation requires a valid authenticated account plus a timing-sensitive race. Version 2026.58 provides only a partial mitigation and the issue is fully fixed in 2026.61; no public exploit code or confirmed active exploitation was identified at time of analysis, although the vendor rates this High at CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) while an independent assessment treats the race as AC:H.

Code injection in Mongoid allows unauthenticated attackers who can influence a query argument to execute arbitrary JavaScript in the MongoDB server via a string-typed query criterion, leading to disclosure of stored field values, unintended document selection for writes, and reduced database performance. The vulnerability affects Mongoid versions 8.0.0 through 8.0.12, 8.1.0 through 8.1.12, 9.0.0 through 9.0.11, and 9.1.0, but exploitation requires the application to pass externally influenced string criteria to the query builder and the MongoDB deployment to permit server-side JavaScript evaluation. No public exploit identified at time of analysis.

Unauthenticated remote code execution affects the Interchange e-commerce platform (the interchange/interchange project) through its admin 'quick question' page, where attacker-supplied yes/no parameters flow into a reparsed [calc] template block and injected Perl is evaluated server-side. The flaw is reachable without authentication in default installations, as confirmed by the upstream fix adding a previously absent [if-mm super] superuser gate, and SSVC rates it Automatable with total technical impact; however, injected code executes inside Interchange's Safe compartment, so unrestricted, full-impact code execution additionally requires the non-default AllowGlobal directive to be enabled on the catalog being accessed. The vendor rates this 9.8 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) while our independent assessment rates it AC:H given the sandbox constraint; no public exploit code and no confirmed active exploitation were identified at time of analysis, and a vendor patch/advisory is available.

Authenticated code injection in XWiki Rendering (the xwiki-rendering-xml module, versions before 14.10.2) lets any user who can edit their own user profile - or any other document - close the surrounding HTML macro and inject Groovy or Python script macros that execute with programming rights, granting remote code execution and unrestricted read/write access to all wiki contents. Exploitation requires only a low-privilege, authenticated account (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, severity 9.9) and needs no victim interaction beyond the affected page being rendered; the attacker reaches the flaw through rendered output that is embedded in an HTML macro without escaping, with exploitable sinks including the user profile (since XWiki syntax 2.0, demonstrably exploitable from XWiki 3.3 Milestone 1) and the extension point org.xwiki.platform.search.ui.docdoesnotexist (added in XWiki 8.3 Milestone 1). No confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis, though the vendor advisory documents a detailed reproduction payload and the scope change (S:C) combined with high confidentiality, integrity and availability impact makes this a genuine high-priority issue; vendors have released the fix in XWiki 14.10.2 and 15.0 RC1.

Sandbox escape in vm2 through 3.12.0 lets unauthenticated remote attackers execute arbitrary code on the host when the embedding application exposes at least one non-strict (sloppy-mode) host function to the sandbox. By calling such a function with a nullish receiver (`fn()`, `fn.call()`, `Reflect.apply(fn, undefined, [])`, etc.), sandboxed script causes V8 to substitute the host realm’s global object for `this`, which vm2 then wraps and returns as a live proxy of the host global; the attacker can then reach `process` and run commands such as `process.getBuiltinModule('child_process').execSync`. Vendor-released patch: upgrade to 3.12.1; no public exploit identified at time of analysis, but the required pre-condition is common because ordinary JavaScript functions are non-strict by default, and vm2 is deprecated, so unmaintained deployments remain exposed-independent assessment rates this a top-tier priority.

CRLF injection in the Synology DiskStation Manager (DSM) User API lets a remote, low-privileged authenticated user (PR:L) who can also induce limited user interaction (UI:R) read or write arbitrary files on the appliance and trigger a denial-of-service condition that surfaces only after the next reboot. Deployments running DSM before 7.2.1-69057-10, before 7.2.2-72806-7, or before 7.3.2-86009-2 are affected; there is no public exploit identified at time of analysis and the issue is not listed as confirmed actively exploited (CISA KEV). Because the flaw is a file read/write primitive, integrity and confidentiality impact is high, but it is gated behind a valid low-privileged DSM account rather than being unauthenticated mass-exploitable, and vendor-released fixed builds eliminate exposure.

Remote code execution in the AF Companion WordPress plugin before version 2.2.0 lets an authenticated user who holds the plugin's low-privileged 'store-management' role upload arbitrary files, including PHP, through an import feature that performs no file-type validation. Because the uploaded PHP is executable by the web server, an attacker with that mid-tier account - a WooCommerce shop-manager-tier role rather than a full administrator - can place and run code on the host with no user interaction and no non-default configuration required. Publicly available exploit code exists for this issue, and the vendor has released version 2.2.0 to fix it; the practical limiting factor is the authenticated mid-tier role, so sites that never delegate store-management accounts to untrusted parties face materially lower risk.

Privilege elevation in Microsoft Azure Cosmos DB allows an attacker who already holds valid low-level authorization to a Cosmos DB account or service to exploit an injection flaw (CWE-74) and reach a downstream component with improperly neutralized special elements, escalating privileges over the network. The CVSS 3.1 base score is 9.6 (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:N) - network-reachable, low complexity, no user interaction, but gated behind existing authorization, with a scope change (S:C) driving the Critical rating despite the absence of an availability impact. No public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV; because Cosmos DB is a Microsoft-managed cloud service, remediation is applied server-side and the exploitable window is controlled by Microsoft rather than persisting until customers patch.

Unauthenticated remote code execution affects Wavelog amateur radio logging software versions 1.8 through 2.4.1 because the installer endpoints /install/ajax.php and /install/includes/interface_assets/triggers.php remain reachable after setup and pass unsanitized input into configuration-writing routines. An attacker who can reach the exposed /install/ path can inject attacker-controlled PHP into configuration files, resulting in code execution on the server, with no authentication or user interaction required (CVSS vector PR:N/UI:N). The issue is fixed in version 2.4.2, and no public exploit identified at time of analysis.

HTTP response splitting and header injection in Sanic let unauthenticated remote attackers forge arbitrary response headers - and potentially split a response into two - when a Sanic application reflects attacker-controlled data into response.headers, the filename argument of file(..., filename=...), or cookie path/domain attributes. The flaw affects all Sanic releases prior to 24.12.1 as well as version 25.12.0, and carries a CVSS 3.1 base score of 8.2 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:N) with integrity impact dominant, since a successful injection can enable session fixation through injected cookies, cache poisoning, or corruption of security headers such as CSP or HSTS. No public exploit identified at time of analysis, and the issue is not listed as confirmed actively exploited (CISA KEV); realized impact still depends heavily on intermediate proxy and cache behavior and on whether the application actually exposes an injection sink.

Sandbox escape leading to remote code execution in vm2 3.11.6 lets untrusted code inside the sandbox reach a live proxy to a host-realm object and run commands with the host process privileges, for example through e.detail.mainModule.require('child_process').execSync(...). The flaw is an incomplete fix for GHSA-m283-3h24-438v: registering a rejection handler via Function.prototype.call or .apply indirection (p.then.call(p, undefined, cb)) bypasses the identity check at lib/bridge.js:1624, so the raw host Error and its non-primitive own properties are handed to sandbox code. Exploitation is conditional: the embedder must bridge an async host Promise into the sandbox and that Promise must reject with an Error carrying a non-primitive own property that references a host object (for example err.detail = process); direct p.then(undefined, cb), .bind and Reflect.apply forms are correctly sanitised. Upgrade to vm2 3.11.7 closes the bypass; no public exploit identified at time of analysis.

Unauthenticated remote code execution in Migratico Lite, a WordPress site-migration plugin, affects all versions up to and including 2.6.8 and lets a remote attacker who can reach an affected site inject and execute arbitrary code with the privileges of the web server. The vendor-disclosed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H = 10.0, reported by Patchstack) requires no authentication and no user interaction, so any WordPress installation running an affected plugin version is potentially exposed; our independent assessment keeps the same network/authentication profile but scores scope as unchanged (S:U), giving an effective base score of 9.8. Exploitation is tempered by practical limits: Migratico Lite is a niche migration plugin with a modest install base, and the sparse public advisory does not disclose the vulnerable endpoint or parameter, so no public exploit code has been identified at time of analysis and weaponization currently depends on an attacker locating the injection sink themselves. There is no CISA KEV entry for this CVE.

Unauthenticated remote code execution in the wpShopGermany IT-RECHT KANZLEI WordPress plugin affects every release from 1.6 up to but not including 2.4. The plugin builds its API authentication token from data the requester supplies and creates that token as a side effect of the routine that is supposed to validate it, so an attacker can compute a valid token without any credentials and use the access it grants to write arbitrary files on the server, which in a PHP/WordPress context converts directly into code execution. No authentication or user interaction is required - only network reachability to the plugin's token-authenticated API endpoint - and publicly available exploit code exists (the finding was published by WPScan). Our independent assessment rates the realistic vector as AC:L/PR:N/UI:N/S:U with high confidentiality, integrity and availability impact, a step more severe than the vendor's 9.0 AC:H/S:C rating; the practical brake on this issue is deployment scope, since this is a niche legal-compliance plugin rather than a mass-market component.

Local privilege escalation in the NetworkManager-vpnc plugin lets a low-privileged user who can create or edit VPNC connection profiles inject a newline character into the username field, causing that value to spill into the root-run vpnc password helper and ultimately execute with root privileges (CWE-93, CVSS 7.8, vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The attack requires local access and an unprivileged account with write permission to NetworkManager connection profiles, plus the vpnc plugin installed and in use; no victim interaction is needed because the attacker only uses their own session. It is not remotely reachable and there is no confirmed active exploitation (CISA KEV) and no public exploit identified at time of analysis, making this a prompt-patching priority for affected Ubuntu/RHEL systems that ship the plugin rather than a mass-exploitation emergency.

Server-side template injection in Craft CMS 5.10.0 through 5.10.12 allows an authenticated low-privilege control-panel user with edit rights on even a single element type to execute arbitrary PHP code and fully compromise the server. The bug is an incomplete fix for CVE-2026-55794: the Controller::getPostedRedirectUrl() to View::renderObjectTemplate() redirect sink stayed unsandboxed, and the same patch introduced a self-signing oracle in Cp::elementLabelHtml(); because Craft/Yii HMAC tokens are not bound to a parameter name, a token minted over attacker-controlled Twig for returnUrl can be replayed as the redirect POST parameter. Exploitation requires a valid CP account with element-edit permissions (PR:L, no user interaction); no public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor-released patch is Craft CMS 5.10.13.

Refine's @refinedev/inferencer package through version 7.0.0 interpolates API field names straight into generated JSX source without escaping, so an attacker who controls or has compromised the data provider can supply crafted JSON property names that execute as JavaScript in a developer's browser when an Inferencer-generated page renders. Remote, unauthenticated input is possible per the published vector (PR:N), but exploitation is gated on developer interaction (UI:P/UI:R), a malicious or untrusted backend (AC:H/AT:P), and a developer actually previewing Inferencer output - hence our independent assessment rates real-world risk materially below the 7.7 CVSS 4.0 headline, and no public exploit code was identified at time of analysis. The issue is tracked upstream in the refinedev/refine repository as issue #7556.

Unauthenticated remote code injection in HP Advance can let an attacker with network reachability to the print-management server hosting HP AC Print & Scan or HP Output Central achieve elevation of privilege, remote code execution, or arbitrary file write, as described in HP's self-published advisory hpsbpi04149 (CVSS 4.0 base score 9.3 Critical, CWE-94). The vendor scores both the vulnerable component (VC:H/VI:L) and subsequent systems (SC:H/SI:H) as impacted, and our independent assessment retains a high-severity rating (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H) while noting that HP's explicit 'under certain conditions' wording implies a specific feature, endpoint, or deployment mode is a likely precondition despite the AC:L rating. Exploitation requires no authentication and no user interaction per the CVSS vector, but there is no CISA KEV entry, no public exploit code identified at time of analysis, and no affected version range published by the vendor.

Unauthenticated remote code execution and privilege escalation in HP Advance software can lead to full server compromise, but exploitation requires specific, undisclosed configuration or deployment conditions according to HP's advisory. The flaw affects the HP AC Print & Scan and HP Output Central components hosted on the HP Advance server. No public exploit code has been identified at time of analysis, though the vendor's CVSS 4.0 vector rates it 9.3 critical while an independent assessment adjusts attack complexity to High due to the gating conditions.

Arbitrary code execution in Redocly CLI and @redocly/respect-core before version 2.33.0 allows a crafted Arazzo description to run attacker-controlled JavaScript with the privileges of the CLI process. The flaw lives in the `respect` command's `$faker` runtime-expression evaluator (get-value-from-context.ts), which permits property traversal through `constructor`, `prototype`, and `__proto__` to reach the JavaScript Function constructor; because the vector is local (AV:L) with required user interaction (UI:R, PR:N), a victim or CI job must actually process an untrusted, attacker-supplied workflow description for exploitation to occur. Impact is high in CI environments, where the injected code can execute shell commands or read pipeline secrets, while users who only run trusted, self-authored workflows are unaffected; no public exploit code was identified at the time of analysis, but a patch exists in 2.33.0.

Arbitrary code execution in Arista EOS with the gRPC Network Packet Sampling Interface (gNPSI) enabled allows an unauthenticated gNPSI client to craft a malicious request that executes code on the switch, yielding full administrative control of the device. The exploit path is gated by a hard precondition: gNPSI is not enabled by default and the gRPC endpoint must be network-reachable, which the vendor vector captures as AT:P and the advisory describes as 'under certain circumstances'; given that condition, no authentication (PR:N) or user interaction (UI:N) is needed. The vulnerability is rated critical (CVSS 4.0 base 9.2, independent 3.1 assessment AV:N/AC:H/PR:N/UI:N with high confidentiality, integrity, and availability impact), and no public exploit code has been identified at time of analysis, so realistic risk is concentrated on switches where gNPSI has been turned on and exposed to untrusted network segments.

Authenticated remote code execution in ScadaLTS 2.8.1-release-candidate build 0 allows any holder of a low-privilege account to run arbitrary JavaScript on the server by abusing the scripting sandbox. The DWR-exposed DataSourceEditDwr.validateScript method performs no authorization check and is reachable through a DWR routing bypass, so supplied code is compiled and executed by the Rhino engine with the application's privileges (CVSS 3.1: 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). There is no public exploit identified at time of analysis and no confirmed actively exploited (CISA KEV) status; the independent assessment treats this as a genuine, credible priority rather than an inflated high-CVSS artifact, with the requirement for valid credentials being the principal limiting factor.

Arbitrary code execution in Jenkins Script Security Plugin 1415.v9a_f9b_3a_c253d and earlier: when a user with job-configure privileges defines classpath entries in an item configuration, those entries are silently auto-approved the moment a user holding Overall/Administer permission copies that item or updates its configuration through the REST API or CLI. The result is code execution inside the Jenkins controller JVM (CWE-94, CVSS 8.0), but exploitation is a two-actor, confused-deputy scenario: the attacker needs pre-existing config-edit rights (PR:L) and must wait for a privileged user to perform the copy or API/CLI update (UI:R), so installations where only administrators author jobs and never copy them or drive configuration through REST/CLI are effectively unexposed. No public exploit code or confirmed active exploitation was identified at time of analysis.

Sandbox escape leading to arbitrary code execution inside the Jenkins controller JVM affects Script Security Plugin 1415.v9a_f9b_3a_c253d and earlier because the plugin fails to reject the @GroovyASTTransformationClass annotation in script source. An authenticated Jenkins user with permission to define and run sandboxed scripts, including Pipelines (the CVSS vector carries PR:L), can submit a script that registers a Groovy AST transformation executed at compile time, before the sandbox applies, resulting in high confidentiality, integrity, and availability impact on the controller; our independent assessment scores this 8.8 with a scope change (S:C) rather than the provider's S:U. No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV, but for any account holding script-submission rights the exploit path is direct rather than theoretical, so the practical risk concentrates on instances that grant Job/Configure or equivalent Pipeline-authoring rights broadly. This is a genuine high-priority vulnerability, not CVSS inflation: the sandbox itself, not a misconfiguration, is the control being bypassed.

Arbitrary Lua code execution is possible on Advantech EKI-1242EIMS and EKI-1242IEIMS industrial Modbus gateways running firmware V1.06.01, because the Modbus CSV import workflow fails to neutralize code embedded in an uploaded configuration file (CWE-94). Exploitation requires an attacker to already hold a high-privilege authenticated session on the device web management interface and to be able to reach that interface over the network, which materially limits exposure in properly segmented OT environments; no user interaction on the part of a legitimate operator is needed, only the attacker's own crafted upload. Successful exploitation yields full loss of confidentiality, integrity, and availability of the device, but no public exploit code has been identified at time of analysis, and there is no confirmation of active exploitation (not listed in CISA KEV); the vulnerability was identified by Nozomi Networks Labs and a vendor security advisory has been published.

Code injection in the web management interface of Advantech EKI-1242IEIMS (and the closely related EKI-1242EIMS) industrial gateways on firmware V1.06.01 lets a remote attacker who already holds high-privilege web UI credentials execute arbitrary code on the device, including OS commands running as root. Exploitation is low-complexity once the attacker is authenticated, but the admin credential requirement (CVSS PR:H) is a hard gate that limits exposure to devices whose management interfaces are reachable and whose admin accounts have been compromised, reused, or left at weak/default values. No public exploit code has been identified at time of analysis and the flaw is not confirmed as actively exploited (no CISA KEV listing); Advantech has published a security advisory for the issue, with Nozomi Networks Labs credited for the discovery. Risk framing: this is a genuine but access-gated risk concentrated on internet- or flat-network-exposed management interfaces rather than on segmented OT deployments.

Incorrect jump-offset calculation in the LoongArch BPF JIT of the Linux kernel can emit wrong tail-call branch targets, causing soft lockups (high availability impact) and, per the assessed vector, limited integrity impact, while confidentiality is unaffected. Affected are LoongArch (Loongson) systems running vulnerable kernel branches including the 6.1.x, 6.6.x, 6.12.x, 6.15.x, 6.16.x and 6.17 lines; exploitation requires local access plus the capability to load eBPF programs into the kernel (CAP_BPF or CAP_SYS_ADMIN, since unprivileged BPF is disabled by default), and only manifests when extra JIT passes occur, so it is not a deterministic single-request trigger. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and the assessed severity is lower than the headline 7.8 because the flaw is architecture-specific, capability-gated and condition-dependent; vendor-released patches are available in 6.18.51, 7.2.5 and 7.3-rc1.

Unauthenticated remote code execution affects Arista EOS platforms on which the non-default P4Runtime service has been explicitly enabled, letting an attacker who can reach that service take complete administrative control of the switch. The defect is a code-injection flaw (CWE-94) triggered by a crafted packet during P4Runtime session initiation, rated 9.5 Critical under CVSS 4.0 and assessed as CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H, with high attack complexity and a changed scope because compromise of the switching platform can extend to subsequent systems. Exposure is limited: P4Runtime is disabled by default, so stock EOS deployments are not at risk, and successful exploitation also depends on a specific timing/condition requirement (AT:P, 'Attack Requirements: Present'); Arista discovered the issue internally, reports no malicious exploitation in customer networks, and no public exploit code has been identified at time of analysis.

Authenticated remote code execution in Arista EOS allows a malicious client with valid gRPC Network Management Interface (gNMI) access to execute arbitrary code with root privileges on the switch by sending a single specially crafted request. Only switches where gNMI has been explicitly enabled are exposed - gNMI is a non-default management API - and the attacker must already hold working gNMI credentials, which limits practical exposure to insiders or adversaries who have already compromised network-automation or management accounts, but grants them full root control of the device with low attack complexity and no user interaction. No public exploit code has been identified at time of analysis and the vulnerability is not confirmed as actively exploited (no CISA KEV listing); no EPSS score was provided. The vendor has published security advisory SA-0166 at https://www.arista.com/en/support/advisories-notices/security-advisory/24722-security-advisory-0166.

Unrestricted PHP function invocation in the WP Import Export Lite WordPress plugin before 3.9.33 allows a user holding the plugin's export permission to achieve remote code execution by applying arbitrary PHP functions to exported field values they control. Exploitation requires an authenticated, high-privilege account (PR:H in the assessed CVSS vector) that can configure and run an export, needs no user interaction, and is network-reachable. Publicly available exploit code exists, though EPSS is low at 0.27% (20th percentile) and there is no CISA KEV listing; the vendor has released a fix in version 3.9.33.

Remote code execution in the WP Import Export Lite WordPress plugin before 3.9.34 requires an authenticated user who has been granted the plugin's export permission, a privileged, non-default capability typically held by administrators or trusted operators. The plugin does not validate the user-supplied output path or filename when its export routine writes files, so that user can write a file with an arbitrary name - for example a .php webshell - into an arbitrary web-accessible directory and have it executed with the web server's privileges. Publicly available exploit code exists, but the flaw is not listed in CISA KEV, there is no confirmed active exploitation, and EPSS is low at 0.27% (20th percentile); the vendor has released 3.9.34 as the fix.

Let me synthesize. CVE-2026-73459: Arista EOS IS-IS LSP purge via crafted IS-IS LSP PDU. Unauthenticated attacker with adjacency/adjacent network access. CVSS 4.0: AV:A (adjacent), AC:L, AT:P (attack requirements present), PR:N, UI:N, VC:N, VI:N, VA:H, SC:N, SI:N, SA:H. CWE-354: Improper Validation of Integrity Check Value. Hmm, CWE-354 is "Improper Validation of Integrity Check Value". Actually CWE-354 is "Improper Validation of Integrity Check Value". Yes. So the crafted LSP with invalid/wrong checksum (IS-IS LSP checksum) isn't validated, causing legitimate LSP to be purged (sequence number manipulation / LSP purge). Actually the scenario: attacker injects crafted IS-IS LSP PDU that purges a legitimate LSP from the link-state database — likely by spoofing LSP with same LSP ID (source ID + pseudonode ID) with... Actually removal could happen by a zero-lifetime LSP or by "purge" mechanism with Remaining Lifetime = 0. In IS-IS, an LSP with remaining lifetime 0 is purged. So crafted LSP with matching LSP ID and Remaining Lifetime 0 plus invalid checksum being accepted → purges legitimate LSP. AV:A — adjacent network — requires attacker on same broadcast segment / L2 adjacency, must be able to send IS-IS PDUs (L2 multicast, no auth if authentication not configured). AT:P — attack requirements present: need to be on an IS-IS enabled link/adjacency; possibly need to be able to form adjacency or at least inject raw L2 frames. PR:N — no auth (if IS-IS authentication is not configured). But PR:N in CVSS 4.0 means none — no privileges required. However, if IS-IS authentication is configured, injection requires the auth key — hence AT:P captures the requirement. EPSS: not given. KEV: not given (not listed). POC: not given. Patch: EOS 4.36.0 ≤4.36.1F affected; advisory 0160 available. Fix version not explicitly given in input — the advisory presumably lists fixed versions. I should not invent. So: "Patch available per vendor advisory" — advisory SAF-0160 at arista.com.

Arbitrary code execution in Sogou Input Method versions before 16.3.0.3498 allows a remote attacker to run code through the biz_helper.exe helper component on Windows. The vendor CVSS vector is AV:N/AC:L/PR:N/UI:N (9.8), but the independent assessment rates the vector as AV:N/AC:L/PR:N/UI:R, meaning a victim likely must interact with attacker-controlled content for exploitation. No public exploit identified at time of analysis, and upgrading to 16.3.0.3498 or later is the confirmed fix.

Remote compromise of Oracle GraalVM is possible: an unauthenticated attacker with HTTP access can exploit a defect in the Compiler component to achieve full takeover of the affected runtime, with high confidentiality, integrity and availability impact. Affected builds are Oracle GraalVM for JDK 17 (23.0.13.1), Oracle GraalVM for JDK 21 (23.1.12.1) and Oracle GraalVM 25 (25.0.4.1). No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV, so exploitation is currently assessed as targeted rather than opportunistic; note that the accompanying 'Information Disclosure' tag understates the stated impact.

Code injection in XML handling in Google Chrome versions prior to 153.0.8010.47 could let a remote attacker bypass the web origin policy by luring a victim into opening a crafted HTML page (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:N per independent assessment, versus Google's published 8.1 vector). Exploitation requires user interaction - the victim must load the malicious page - and no authentication is needed, while Google's own Chromium severity rating is 'Low', indicating constrained real-world impact; the EPSS score is 0.26% (17th percentile) and no public exploit has been identified at time of analysis. A vendor patch is available in Chrome 153.0.8010.47, and Chrome's automatic background update mechanism rapidly retires vulnerable versions.

Unauthenticated argument injection in the Fireshare video upload function allows a remote attacker to write to or overwrite arbitrary files on the host filesystem in all versions prior to 1.6.14. The flaw is rated CVSS 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), meaning no credentials, user interaction, or non-default configuration are required - the only practical prerequisite is network reachability to the upload endpoint of a self-hosted instance. Exploitation status at time of analysis is no public exploit identified at time of analysis; CISA KEV does not list this CVE, and no public proof-of-concept was supplied in the available intelligence. A vendor-released patch exists: Fireshare 1.6.14 resolves the issue, and given the unauthenticated, full-integrity-impact nature of the bug, upgrading should be treated as high priority for any internet-exposed deployment.

Sandbox escape in the python_sandbox_server subproject of IBM MCP Context Forge (versions up to and including 1.0.1) allows a remote, unauthenticated attacker to execute arbitrary OS commands with the privileges of the server process. The vulnerable execute_code MCP tool can be exposed over the HTTP/SSE transport without any authentication layer, so any client that can reach the endpoint can submit a payload via tools/call; publicly available exploit code exists (the vendor advisory includes a working local PoC with artifact hashes). Exploitation is conditional on the optional python_sandbox_server being deployed and network-reachable - the core Context Forge gateway and proxy components are not directly affected, and stdio-only deployments are not remotely exposed - but when reachable it is a critical-severity, unauthenticated code-execution path.

Authenticated remote code execution in Koha lets anyone who can reach the affected web service on TCP port 8081 feed a crafted string into an eval() call and run arbitrary code as the service account. The bug is rated CVSS 8.8 (CWE-95) because it needs only a low-privilege authenticated session and no user interaction, yet yields full confidentiality, integrity and availability impact. No CISA KEV listing and no public exploit code were identified at time of analysis.

The npm package praisonai exposes a SandboxExecutor 'network-isolated' mode that is advertised to users as 'No network access (proxy blocked)' but only injects http_proxy/https_proxy=http://localhost:0 without creating any operating-system network boundary, so sandboxed commands that ignore proxy environment variables can still open sockets directly. Versions 1.2.3 through 1.7.1 of the npm package are affected; an initial fix shipped in 1.7.2. A local-only proof-of-concept is described in the vendor advisory (a plain Node HTTP client reaches a loopback server while a proxy