Code Injection

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

Remote code execution in the PraisonAI TypeScript `codeMode` tool (npm package `praisonai` <= 1.7.1) lets an attacker who can influence the model-generated `code` argument escape the regex blocklist 'sandbox' and run arbitrary JavaScript with the host process's privileges, reading and writing files, harvesting environment credentials, and executing operating-system commands. The CVSS 3.1 vector is unauthenticated and network-facing (AV:N/AC:L/PR:N/UI:N, 9.8) with total confidentiality and integrity impact, though the real-world prerequisite is that `codeMode` is enabled for an agent and the attacker can steer the tool argument - typically through prompt injection into untrusted content the agent ingests. Publicly available proof-of-concept code exists (published in the GitHub advisory, demonstrated against Node.js v20.20.0), EPSS is a low 0.77% (54th percentile) and CISA SSVC records Exploitation: none, so there is no confirmation of active exploitation at time of analysis; the vendor fix is version 1.7.2.

CVE-2026-86320 is a vulnerability reported via the Ubuntu vendor channel for which no public description, CVSS score, CWE classification, or technical detail has been disclosed at time of analysis. The affected product and impact cannot be independently characterized from available intelligence. Security teams should monitor the Ubuntu Security Notices (USN) portal and the Ubuntu CVE tracker for disclosure once an advisory is published.

IBM DataStage on Cloud Pak for Data 5.4.0.0 can be made to execute arbitrary code by an authenticated remote user because the XSLT transformation engine is misconfigured in a way that lets attacker-supplied transformations reach code-execution paths. The flaw is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N, C/I/A all High), meaning any holder of valid low-privilege DataStage credentials can potentially obtain full control of the affected service. IBM has published a patch, and there is no public exploit code or CISA KEV listing associated with this CVE at time of analysis.

PraisonAI's optional standalone async-jobs HTTP server can be driven by any unauthenticated network client that can reach its listener, which binds 0.0.0.0:8005 by default, because every route under /api/v1/runs lacks authentication and per-job ownership checks. An attacker can submit jobs carrying attacker-controlled prompts and agent YAML/configuration, causing the operator's process to execute agents with access to its environment variables, service credentials, and connected tool capabilities, and can also list, read, stream, cancel, or delete any job system-wide. Rated CVSS 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), with publicly available exploit code exists per SSVC exploitation: poc, an EPSS of 0.97% (60th percentile), and no CISA KEV listing; the vendor has published patched releases.

Eval injection in CONPROSYS HMI System (CHS) by Contec allows authenticated network attackers to execute arbitrary code on the server hosting the HMI application. The flaw (CWE-95) occurs when user-supplied input reaches a dynamic code evaluation function without proper neutralization, enabling full server-side code execution. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis, but the low-complexity, network-accessible nature of the vulnerability makes it a priority for ICS/OT environments running this product.

Remote code execution in Regular Labs' Conditional Content Pro extension for Joomla (versions before 8.0.0) lets an author with article-publishing rights embed inline PHP inside Condition Rules, which the extension hands to its Conditions evaluator without verifying who authored the content. Because Joomla's standard Author text filter preserves the rule syntax, publishing a crafted article executes the attacker's PHP as the web-server process. No public exploit has been identified at time of analysis, and the flaw requires an authenticated, privileged Joomla account.

Remote code execution in vLLM's LlavaOnevision2 processor loader allows an attacker who controls a model repository to execute arbitrary code on systems that load that model, bypassing the trust_remote_code=False safety parameter entirely. All vLLM installations prior to version 0.28.0 are affected when loading LlavaOnevision2-architecture models; the security control that operators rely on to safely evaluate third-party models is silently non-functional for this processor class. No public exploit code has been identified and the vulnerability is not listed in CISA KEV, but the attack requires only the ability to publish a model to an accessible registry and social-engineer a user into loading it.

Remote code execution in The Events Calendar WordPress plugin (StellarWP) through version 6.17.3 lets unauthenticated attackers run arbitrary PHP on the server by abusing Element_Classes::parse_array(). A plain-array widget 'classes' payload evades the is_safe_widget_instance() object check and reaches a callable-invocation sink; the chain fires when do_blocks() renders a single-event page whose comment area contains a crafted wp:legacy-widget block. Reported by Wordfence with a 9.8 CVSS; no public exploit identified at time of analysis, and the flaw is only reachable on sites that enable comments on tribe_events posts.

Remote code execution in SGLang AI inference servers allows unauthenticated attackers to run arbitrary code through the /update_weights_from_tensor endpoint when no authentication keys are configured. The SafeUnpickler policy can be bypassed because builtins.import and builtins.getattr remain resolvable, enabling malicious pickle REDUCE instructions to execute attacker-supplied code. EPSS is 0.21% and no CISA KEV or public exploit is identified, but CVSS rates the flaw critical.

Unauthenticated remote code execution in the Teddy Bear Customize Addon WordPress plugin (all versions through 1.0.5) allows attackers to upload arbitrary PHP files to the server and execute code. The plugin's upload handler trusts the client-supplied MIME/content type and preserves the original attacker-controlled filename, so a request declaring an image content type while carrying a .php payload lands as an executable script in the webroot. Publicly available exploit details have been published by WPScan; no active exploitation has been confirmed in CISA KEV at time of analysis.

Authenticated low-privileged users on WoltLab Suite Core (WCF) 6.1.0 through 6.1.22 and 6.2.0 through 6.2.5 can break out of the nowdoc wrapper used by the disk cache writer and inject arbitrary PHP that executes when the poisoned cache file is included, giving code execution with high confidentiality and integrity impact. The issue is a CWE-94 code-injection defect in the DiskCacheSource class, rated 8.8 under CVSS 3.1 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), where the only meaningful prerequisite is a valid low-privileged account whose submitted data reaches a cached value. No public exploit code and no confirmed active exploitation were identified at time of analysis, and EPSS is low at 0.17% (6th percentile), so the practical risk is concentrated in unpatched, internet-facing WoltLab communities rather than being a broad ecosystem emergency.

Remote code execution in IBM Langflow OSS 1.0.0 through 1.11.5 allows authenticated network attackers to run arbitrary operating system commands by supplying crafted input to an unguarded eval() call within the application. The root cause is CWE-94 code injection - attacker-controlled data is passed directly to a dynamic evaluation function without sanitization or sandboxing. IBM has released a patch and no public exploit code or CISA KEV listing has been identified at time of analysis, but the straightforward nature of eval()-based injection and the low privilege bar (any authenticated user) make this a meaningful post-authentication escalation risk.

Remote code execution in IBM Langflow OSS versions 1.0.0 through 1.11.5 allows authenticated low-privileged users to execute arbitrary server-side code by exploiting an incomplete environment variable blocklist. The root cause (CWE-94, Code Injection) means the platform's intended restrictions on environment variable access can be circumvented by supplying references to variables omitted from the blocklist, resulting in full confidentiality, integrity, and availability compromise. No public exploit has been identified at time of analysis, and a vendor-released patch is available per IBM advisory node/7286666.

Remote code execution in IBM Langflow OSS versions 1.0.0 through 1.11.5 allows an unauthenticated remote attacker to run arbitrary code by injecting malicious code that is evaluated during graph construction (CWE-94). Because Langflow is a visual framework for building LLM/agent workflows whose flows are assembled into executable graphs, a crafted flow definition submitted to the server is interpreted as code rather than data. The CVSS vector (AV:N/AC:L/PR:N/UI:N) indicates trivial, network-reachable, unauthenticated exploitation, though there is no public exploit identified at time of analysis.

Remote code execution in IBM Langflow OSS 1.0.0 through 1.11.5 allows any authenticated low-privileged user to inject and execute arbitrary server-side code by embedding special characters in flow display names. The root cause is inadequate neutralization of user-controlled input before it enters a code-generation or evaluation context (CWE-94), yielding full host compromise across confidentiality, integrity, and availability. No public exploit code or CISA KEV listing has been identified at time of analysis.

IBM WebSphere Application Server 8.5 and 9.0 contain improper authentication controls that allow an attacker who already holds a local, low-privileged foothold on the server to bypass security checks and escalate privileges. Successful exploitation yields high confidentiality and integrity impact — protected resources and configuration can be read and modified — though availability is unaffected per the CVSS vector. No public exploit code has been identified, EPSS is very low at 0.12% (3rd percentile), the issue is not in CISA KEV, and a vendor patch is available from IBM.

Remote code execution in OmniRoute AI gateway 3.8.49 and earlier lets attackers run arbitrary commands in the server container via the POST /api/acp/agents custom ACP agent endpoint. The endpoint accepts attacker-controlled 'binary' and 'versionCommand' values and passes them to execFileSync after only a self-consistency (binary-match) check, so a matching interpreter carrying an eval-style argument (e.g. node -e, python -c) executes as code without any shell metacharacter. Because api/acp/ is excluded from the authentication-required prefixes, exploitation is remote and anonymous whenever requireLogin=false or during the fresh-instance bootstrap window; no fixed version exists and no public exploit is identified, though the GitHub advisory documents the PoC shape.

Remote code execution in the RepairBuddy WordPress plugin (versions <= 4.1224) is reachable by authenticated users holding only subscriber-level privileges - the lowest WordPress role - via a code injection flaw (CWE-94). A subscriber can send a crafted network request to trigger server-side code execution, achieving full confidentiality, integrity, and availability compromise of the WordPress host. No public exploit or KEV listing has been identified at time of analysis, but Patchstack has disclosed the vulnerability with a dedicated advisory.

Cross-tenant remote code execution in Apache Camel K (2.0.0 before 2.9.3, and 2.10.1 before 2.10.2) arises from improper neutralization of directives in dynamically evaluated Maven configuration, letting a tenant supply repository content that is evaluated inside the operator pod. A tenant can thereby execute arbitrary code with the privileges of the shared Camel K operator, escaping their own tenancy. No public exploit identified at time of analysis, and EPSS is low (0.18%), but the impact is a full operator-level compromise in multi-tenant deployments.

Code injection in Apache Camel K (2.0.0-2.9.2 and 2.10.1) lets an authorized custom-resource author smuggle arbitrary Kubernetes object definitions through YAML in CR configuration, which the operator then materializes using its own elevated service-account privileges. Because the operator typically holds broad cluster permissions, this converts limited CR-authoring rights into unauthorized creation of arbitrary Kubernetes resources - a privilege-escalation and in-cluster RCE primitive. Apache-released fixes exist; there is no public exploit identified at time of analysis and EPSS is low (0.16%).

Remote code execution in Flowise 3.1.2 (the FlowiseAI low-code LLM/agent builder) lets a remote attacker run arbitrary code by sending crafted input to the /api/v1/prediction/<flowId> endpoint. The CVSS vector marks it unauthenticated (PR:N), and the vendor source references to validateKey.ts suggest the endpoint's API-key check can be bypassed so untrusted callers reach code-executing flow nodes. CVSS is 9.8; there is no public exploit identified at time of analysis and it is not listed in CISA KEV, though EPSS/POC signals were not supplied.

Heap-based memory corruption in GPAC's DVB-MPE/DSM-CC transport-stream parser lets an attacker who supplies a crafted MPEG-2 TS file trigger out-of-bounds reads and writes that can be turned into arbitrary code execution in the context of the parsing process. The flaw lives in src/media_tools/dvb_mpe.c in descriptorTime_slice_fec_identifier(), gf_m2ts_ipdatagram_reader() and the DSM-CC section/descriptor loops, and is fixed by commit 0e4093392e1f847c90d20e031e893cd942fef938. No public exploit code or in-the-wild exploitation is known, EPSS is a low 0.16% (5th percentile), and the vendor-supplied CVSS of 8.4 assumes local access with no privileges or user interaction.

Arbitrary code execution in GitPython before 3.1.60 is possible when a victim application calls index.commit() on an attacker-controlled repository. The root cause is insufficient validation of the git directory location: GitPython trusts tracked files such as gitdir, commondir, and HEAD to resolve the effective git directory, allowing a crafted repository to redirect that resolution to an attacker-controlled path containing a malicious pre-commit hook. No public exploit has been identified at time of analysis, but the attack is realistic in any Python-based DevOps pipeline, CI/CD system, or tooling that opens and commits to externally sourced repositories.

Remote code execution in Perforce Akana API Platform allows unauthenticated attackers to run arbitrary code on the Policy Manager console host. A path normalization discrepancy between the authentication filter and the servlet dispatcher lets a crafted request slip past authentication and reach an endpoint that evaluates attacker-supplied script without sandboxing. Rated CVSS 4.0 10.0; no public exploit identified at time of analysis, but the no-auth/no-interaction profile makes this a top-priority patch.

Argument injection in bestzip's nativeZip function (versions 2.2.6 and 3.0.2) allows attackers who control the destination path or source file entries to inject arbitrary flags into the underlying Info-ZIP binary, achieving command execution at the Node.js process privilege level. Two distinct injection vectors exist: passing a flag-like string such as `-n` as the destination consumes the `--` argument separator, allowing source entries like `--unzip-command` to be interpreted as zip binary flags that trigger shell execution during archive validation. Patched versions 2.2.7 and 3.0.3 apply `path.resolve()` to normalize the destination before constructing the argument list. No public exploit is identified at time of analysis and the CVE is not in CISA KEV.

Arbitrary code execution in Actions Semiconductor's Tool - Media Player Utilities v4.46 lets a physically proximate attacker run code on a host by abusing the Production.dll and RdiskUpgrade.exe firmware/disk-upgrade components (CWE-94 code injection). The flaw affects this specific flashing/production utility bundled with Actions Semiconductor media-player SoC toolchains. SSVC rates technical impact as total with a public proof-of-concept, but EPSS is only 0.17% (6th percentile), and the required physical/local proximity sharply limits real-world reach.

Code injection in n8n's legacy expression engine allows an authenticated user to replace the mutable global JSON.stringify function within expression evaluation, causing subsequent code-generation paths to embed and execute attacker-controlled JavaScript. Affected are all n8n versions prior to 1.123.76 (v1 branch), 2.37.7, and 2.38.2. The vulnerability is confined to the legacy expression engine (isolated-vm-bridge.ts and ExpressionBuilder.ts); the vm expression engine is unaffected. No public exploit or CISA KEV listing has been identified at time of analysis.

Remote code execution in n8n workflow automation platform prior to versions 1.123.76, 2.37.7, and 2.38.2 is achievable by any authenticated user who can author workflow expressions. The root cause is a sandbox escape in the PrototypeSanitizer AST hook: because the sanitizer references itself via dynamically scoped `this`, a crafted class field named `__sanitize` rebinds the sanitizer function, after which the expression freely invokes the JavaScript `Function()` constructor and executes arbitrary Node.js code on the backend. No public exploit has been identified at time of analysis, but the Function constructor escape technique is well-documented in the JavaScript security research community, lowering the barrier to independent rediscovery.

Local privilege escalation in Auth0 AD/LDAP Connector versions up to and including 6.5.0 allows a low-privileged local user to modify the connector's configuration file due to improper permission handling during service startup processing. When the connector service restarts - whether scheduled, OS-triggered, or manually - the tampered configuration value is evaluated, resulting in code execution with the privileges of the service account running the connector. No public exploit code has been identified at time of analysis, but the straightforward local exploitation path (AC:L) and high impact to a service that often holds privileged Active Directory credentials make this a meaningful risk in environments running on-premise Auth0 connector deployments.

Server-side code execution in CMSimple 5.22's CoAuthors plugin enables an authenticated low-privileged user who can edit page content to achieve full remote code execution by passing crafted external or uploaded text through the plugin's content import feature. The vulnerability is rooted in CWE-94 (improper code generation control), where imported content is processed server-side without sufficient sanitization, allowing arbitrary PHP or server-side logic to execute in the web server context. Publicly available exploit code exists via a GitHub gist and associated issue tracker, though EPSS stands at 0.17%, reflecting limited observed exploitation at this time.

Code execution with the privileges of the management console is possible in Okta Access Gateway releases before 2026.9.1, where the console's exception-handling path passes user-supplied input to eval() without sanitization. Reaching that path requires an already-authenticated administrator SSH session (CVSS vector PR:H), so this is a privilege-boundary break that lets a trusted console operator escalate from constrained administrative commands to arbitrary code execution rather than an anonymous network entry point. No public exploit code has been identified at time of analysis, CISA SSVC records no observed exploitation and no automatable attack path, and EPSS is a low 0.36% (29th percentile), so real-world priority is low despite the high confidentiality, integrity and availability impact scored in the CVSS 7.2 assessment.

Authenticated administrative users of Okta Access Gateway can achieve arbitrary command execution on the underlying gateway host by storing crafted values in an application's label field, which the product interpolates without sanitization into generated nginx server block configuration. The flaw affects Okta Access Gateway versions prior to 2026.9.1 (CPE cpe:2.3:a:okta:access_gateway), scores CVSS 3.1 base 7.2 (High) with total confidentiality, integrity, and availability impact under vector CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, and requires high-privilege (PR:H) access to the management console to seed the malicious label - no user interaction is needed, and the injected directives take effect when the gateway regenerates and reloads its nginx configuration. There is no public exploit identified at time of analysis, CISA SSVC records Exploitation: none and Automatable: no, and EPSS is low at 0.36% (29th percentile), so this is best characterized as an admin-to-host privilege-abuse vector rather than a remotely exploitable unauthenticated issue.

Eval injection (CWE-95) in Adobe ColdFusion 2023 (≤Update 23) and ColdFusion 2025 (≤Update 12) enables unauthenticated, network-based arbitrary code execution without user interaction. User-supplied input reaching a dynamic code evaluation function is processed without sanitization, allowing injected CFML or Java expressions to execute server-side as the application user. The CVSS scope-change metric (S:C) indicates the impact can extend beyond the ColdFusion process itself; Adobe PSIRT issued formal advisory APSB26-119. No public exploit or CISA KEV listing has been identified at time of analysis.

Remote code execution in Adobe ColdFusion 2023 (update ≤23) and ColdFusion 2025 (update ≤12) allows a low-privileged, authenticated attacker to inject directives into dynamically evaluated code (CWE-95, 'Eval Injection') and execute arbitrary code in the context of the current user without any user interaction. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C, 9.9) reflects a network-reachable, low-complexity flaw with a scope change, meaning code executes beyond the initially authorized security context. No public exploit is identified at time of analysis, but ColdFusion RCE flaws are historically high-value targets and are frequently weaponized quickly after disclosure.

Code injection in Microsoft Remote Desktop Client for Windows Desktop (versions 1.2.0.0 through below 1.2.7279.0) enables an unauthenticated network attacker to execute arbitrary code on the connecting client machine. The vulnerability is triggered when a user connects to an attacker-controlled RDP server that delivers malicious server-side responses exploiting CWE-94 code generation flaws in the client. No public exploit code and no CISA KEV listing have been identified at time of analysis; a vendor-released patch is available.

Remote code execution in Microsoft Dynamics 365 Customer Engagement V9.1 (versions below 9.1.0048.0004) is achievable by authenticated network attackers through a code injection vulnerability (CWE-94). An attacker holding a low-privilege account can submit a crafted request that causes the server to generate and execute attacker-controlled code, resulting in full confidentiality, integrity, and availability compromise of the affected instance. Microsoft has released a patch via the MSRC update guide, and no public exploit code has been identified at time of analysis.

Code injection in Adobe Animate allows a low-privileged attacker to achieve arbitrary code execution in the context of the current user by convincing a victim to open a specially crafted malicious file. Both the 2023 and 2024 major release lines are affected, covering all versions up to and including 23.0.16 and 24.0.14 respectively. SSVC assessment indicates no current exploitation activity, but the technical impact is rated total due to full C/I/A compromise and a scope change beyond the vulnerable component.

Local privilege escalation in Microsoft .NET Runtime and Visual Studio exploits a code injection weakness (CWE-94) allowing a low-privileged authenticated local user to gain full system-level control over confidentiality, integrity, and availability. Affected versions span .NET 9.0, 10.0, and the pre-release 11.0 RC1, plus Visual Studio 2022 (17.14.x) and the pre-release Visual Studio 2026 (18.9.x). No public exploit has been identified at time of analysis, and Microsoft has released patches across all affected release branches.

Code injection via the Apache Nutch Server REST API allows low-privileged remote attackers to execute arbitrary code on hosts running Nutch versions 1.11 through 1.22. The vulnerability chains missing authorization controls with unsafe reflection and dynamic code execution in the Nutch REST API, enabling full compromise of confidentiality, integrity, and availability. No public exploit has been identified at time of analysis; the vendor's definitive fix in version 1.23 removes the Nutch Server component entirely.

Remote code execution in Craft CMS before 5.10.12 allows authenticated content editors to achieve full server compromise through a PHP class-injection and log-poisoning chain. By supplying a crafted criteria[withTransforms][0][class] parameter to the element-index endpoint, an attacker forces ImageTransforms::normalizeTransform() to instantiate an arbitrary PHP class; chaining this with yii\rbac\PhpManager - a built-in Yii RBAC component - the attacker can execute PHP payloads previously smuggled into request logs via the User-Agent header. No public exploit tool or CISA KEV listing is identified at time of analysis, but the fully documented multi-stage technique materially lowers the expertise barrier for exploitation.

Remote code execution in Craft CMS before 5.10.12 is achievable by any authenticated control-panel user through Yii2 behavior injection. The vulnerability arises because string-typed field-layout elements are not properly cleansed before processing, allowing attackers to embed Yii2 behavior attachments and event handlers in JSON-formatted field-layout tab submissions that bypass validation and reach Craft::createObject(), instantiating arbitrary PHP objects and executing attacker-controlled code. No public exploit code is confirmed and this CVE is not listed in CISA KEV, but the low privilege bar - any control-panel account suffices - elevates real-world risk for organizations with multiple editor or author accounts.

Command argument injection (CWE-88) in Hitachi's Cosminexus Component Container Java application-server middleware allows remote attackers to inject additional arguments into an underlying command invocation, per the vendor CVSS vector enabling full compromise of confidentiality, integrity and availability. A very wide band of releases is affected, spanning the 09-00 through 11-70 trains. No public exploit has been identified at time of analysis, though Hitachi has released fixed maintenance versions.

Client Code Execution in Siemens Desigo CC building management clients allows a low-privileged attacker to execute injected scripts and write arbitrary files to the client operating system by enticing an operator to open a maliciously crafted graphics document. All versions of the ClickOnce, Flex, and Installed Client variants across the V6, V7, V8, and V9 product lines are confirmed affected per Siemens SSA-330084. The subsequent-system impact (SC:H/SI:H/SA:H in the vendor-supplied CVSS 4.0 vector) reflects the documented lateral movement risk within OT environments. No public exploit is identified at time of analysis.

Remote code execution in mpush v0.8.1 lets attackers run arbitrary code on the gateway server by sending a crafted broadcast message that is unsafely processed (CWE-94 code injection). The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N) indicates unauthenticated network exploitation with full confidentiality, integrity, and availability impact. Publicly available exploit documentation exists (GitHub write-up), though EPSS is low (0.17%, 6th percentile) and the flaw is not in CISA KEV.

Eval injection in FreeIPA's idp-add command allows any authenticated IPA domain principal, regardless of privilege, to enumerate the server process's environment variables and cause memory exhaustion denial of service. The flaw arises because user-supplied --organization and --base-url inputs reach a constrained eval() call before the LDAP access control check that should gate idp-add to IPA administrators is enforced - creating an authorization-order bypass. No public exploit has been identified at time of analysis, and this CVE is not listed in CISA KEV.

Bifrost HTTP transport before version 2.0.0 exposes an unauthenticated plugin installation endpoint (POST /api/plugins) that accepts HTTP URLs as plugin paths, enabling SSRF on all build types and unauthenticated remote code execution on dynamically linked builds. Because management authentication is disabled by default (governance.auth_config.is_enabled=false), no credentials are required to trigger the flaw; the shared-object loader fetches the attacker-supplied URL, writes it as a temporary .so, and on DYNAMIC=1 builds calls plugin.Open() which immediately executes the plugin's Init() function as the Bifrost process user. Reported by JFrog, the fix ships in transports/v2.0.0, adding an SSRF-safe dial context (SSRFSafeDialContextWithAllowlist) around plugin downloads; no public exploit code or active exploitation has been confirmed at time of analysis.

Bilibili Desktop through v1.18.0 achieves full system command execution and credential theft by combining two design-level failures: TLS certificate verification is disabled process-wide (accepting any certificate, including attacker-controlled), and remote JavaScript configuration is fetched and executed without code-signing or integrity validation. Any on-path network adversary - via rogue Wi-Fi, ARP spoofing, or a compromised gateway - can intercept these fetches, present a forged certificate, and inject arbitrary JavaScript that runs in the app's renderer context with direct access to the privileged IPC bridge, enabling OS-level command execution or session-token exfiltration. A public proof-of-concept repository exists (GitHub: LeoWSY-hashblue/bilibili-desktop-tls-disabled-rce); no vendor-released patch has been identified at time of analysis.

Remote code execution in the Hummingbird performance/caching plugin for WordPress (versions up to and including 3.21.0) lets unauthenticated attackers write arbitrary PHP into a web-accessible debug-log file and execute it with a single anonymous request. The plugin's protective '<?php die(); ?>' header is silently dropped due to a PHP namespace bug in a class_exists() check, and unsanitized cookie names are written straight into wp-content/wphb-logs/page-caching-log.php. Reported by Wordfence with no public exploit identified at time of analysis; exploitation depends on a non-default Debug Log configuration.

CRLF injection in Laravel Framework (CWE-93) enables unauthenticated remote attackers to manipulate outbound email processing in any application that passes user-supplied email addresses to Laravel's mail functions. An attacker who can provide an email address to an application flow - such as registration, password reset, or contact forms - can embed carriage-return/line-feed sequences to inject additional SMTP headers, reroute messages to unintended recipients, or abuse the application's mail infrastructure as an open relay. The vendor has released patches in versions 12.60.0 and 13.10.0; no public exploit code or CISA KEV listing has been identified at time of analysis.

Privilege escalation to root/SYSTEM in IXON VPN Client before 1.4.7 lets an attacker inject arbitrary configuration directives via a CRLF (improper neutralization, CWE-93) flaw: the client's local configuration interface accepts changes without authenticating or verifying the requester's origin, writes those values to a file, and a privileged subprocess later consumes them. By embedding line-ending sequences the attacker smuggles additional directives that run with elevated privileges. Because the malicious config persists across client restarts and OS reboots while the VPN keeps functioning normally, the compromise is stealthy with no user-visible change. No public exploit identified at time of analysis; no CISA KEV listing.

Remote code execution in IBM Langflow OSS 1.0.0 through 1.11.2 is reachable by any low-privileged authenticated attacker through an authorization bypass in the platform's flow build process. The flaw (CWE-94, Code Injection) allows a user with minimal credentials to submit flow build requests that exceed their authorized scope, causing the server to execute attacker-supplied code with full confidentiality, integrity, and availability impact. No CISA KEV listing and no public exploit code have been identified at time of analysis.

Remote code execution in LaVague 0.2.35, an LLM-driven web-automation agent framework, arises because PythonFromMarkdownExtractor.extract_as_object evaluates language-model output that is derived from attacker-influenced web page content. An attacker who controls or poisons a page the agent visits can use indirect prompt injection to coerce the model into emitting Python that is then eval'd and executed on the operator's host with no human review. Reported by VulnCheck (CWE-94); no public exploit identified at time of analysis and it is not listed in CISA KEV.

Arbitrary shell command execution in aider (aider-chat) is triggered silently when a user runs the tool inside a crafted git repository containing a malicious `.aider.conf.yml` configuration file. The tool unconditionally reads this file at startup and passes `test-cmd` and `lint-cmd` values directly to Python's `subprocess` with `shell=True`, with no user confirmation, no LLM involvement, and no API key required. Confirmed present on version 0.86.2 and the 0.86.3.dev main branch per the VulnCheck advisory; no vendor-released patch has been identified at time of analysis, and no public exploit code has been identified beyond the mechanism documented in the public GitHub issue.

Arbitrary command execution in goose v1.37.0 allows an attacker to embed shell commands inside recipe stdio extension definitions and retry.check fields that are silently executed under the victim user's OS privileges. The built-in recipe security scanner does not inspect these fields, providing a false safety guarantee and a clear bypass path. No public exploit is identified at time of analysis, but exploitation is low-complexity once a target user loads a malicious recipe.

Argument injection in GFI Exinda AI before 7.6.5 allows any authenticated user - including those with the lowest-privilege Unprivileged account - to exfiltrate arbitrary files from the host system. The web_tools_cmd() function in the Tools Iperf Client feature concatenates user-supplied server and options parameters directly into an iperf command without sanitization, enabling injection of the iperf -F flag to redirect file contents to an attacker-controlled iperf server. No public exploit has been identified and the vulnerability is not listed in CISA KEV, but exploitation is straightforward given knowledge of standard iperf flags.

Authenticated remote code execution in OpenPanel before 2.3.0 allows any project member with read access to escape the mathjs formula sandbox by traversing matrix object prototypes to recover the native JavaScript Function constructor. Once recovered, the constructor enables loading Node.js core modules such as child_process, granting full OS command execution with the privileges of the API process. The vulnerability crosses organization authorization boundaries, meaning a low-privileged member of one project can pivot to affect all organizations co-hosted on the same OpenPanel instance. No public exploit has been identified at time of analysis.

Remote code execution in Grav CMS (versions ≤2.0.17) lets authenticated users holding only page-write rights achieve arbitrary PHP execution on the web server by exploiting a Twig sandbox bypass in the |sort filter. The sortFunc wrapper in GravExtension.php incorrectly hardcodes isSandboxed=false-unlike |map, |filter, and |reduce-allowing |sort to resolve plain PHP callable names including spl_autoload, which is absent from the function denylist and performs a PHP include operation. A content editor can deliver a crafted payload through mechanisms such as form frontmatter rendered by the Email plugin, resulting in code execution as the web server user. A vendor-released patch is available in version 2.0.19, and no active exploitation appears in CISA KEV at time of analysis.

Privilege escalation with arbitrary code execution in the Hummingbird Performance WordPress plugin (versions 3.15.0 through before 3.21.2) allows any site-level administrator on a WordPress multisite network to access and modify a network-wide configuration setting that should be gated to super admins, achieving code execution across all sites on the network. The vulnerability stems from missing capability enforcement (CWE-94) on a sensitive network-scope action. A publicly available proof-of-concept exists, and the vendor has released a patched version (3.21.2) addressing the access control gap.

Remote code execution in esoTalk v1.0.0g4 arises from configuration comment injection that allows attacker-controlled input reaching ETMemberModel, ETMemberController and ET.class.php to be persisted into a PHP configuration file and subsequently interpreted as code (CWE-94). Documented only in a third-party Notion writeup with no public exploit tool; EPSS is low at 0.19% (9th percentile). No public exploit identified at time of analysis and the CVE is not in CISA KEV.

Remote code execution in DocsGPT 0.15.0 and earlier arises from its custom-prompt feature, which passes user-supplied prompt content into Jinja template rendering with no sanitization or sandboxing. An unauthenticated attacker can submit crafted template expressions to achieve server-side template injection (SSTI) that escalates to full RCE on the host running the chatbot backend. VulDB has published an entry and a public writeup/PoC repository exists, though the flaw is not listed in CISA KEV and SSVC records exploitation status as 'none'.

Arbitrary OS command execution in GeoNetwork before 4.4.12 and 4.2.17 arises because the Saxon XSLT processor that renders formatters runs without FEATURE_SECURE_PROCESSING and with Java extension functions (ALLOW_EXTERNAL_FUNCTIONS) enabled. A user privileged enough to upload a formatter can supply a malicious .xsl stylesheet that invokes java.lang.Runtime.exec() or java.lang.ProcessBuilder, running commands as the GeoNetwork process user. No public exploit is identified at time of analysis, though the vendor GHSA advisory and public reporting describe the technique in detail.

Prototype chain sandbox escape in n8n's $fromAI expression handler allows any user holding workflow-build privilege to achieve remote code execution within the main n8n server process. The $fromAI handler failed to restrict placeholder key lookup to own properties and permitted reserved prototype keys; when the input value is a primitive, the handler returns a live reference to the host-prototype chain, enabling traversal to Function.prototype.constructor and compilation of arbitrary JavaScript outside the expression sandbox. All n8n deployments running versions below 1.123.73 (v1 track), 2.35.4, or 2.36.2 (v2 track) are affected. No public exploit code or CISA KEV listing has been identified at time of analysis, but the technique (prototype chain walk to Function constructor) is well-understood and reliable once sandbox access is obtained.

Expression sandbox bypass in n8n before 2.36.2 allows authenticated workflow editors to escape the sandboxed evaluation environment by placing free identifiers in spread, computed-key, switch-case, or class-extension positions, which resolve against Node.js process globals instead of the restricted sandbox scope. Exploiting this flaw enables mutation of host objects - including prototype chains or environment-level state - with those changes persisting process-wide until the n8n service is restarted, affecting all concurrent workflows and users on the same instance. No public exploit or CISA KEV listing has been identified at time of analysis; patch version 2.36.2 is confirmed via the GitHub Security Advisory.

URI authority injection in fast-uri allows an attacker-supplied port value containing delimiter characters to demote the intended host to userinfo and redirect the parsed authority to an attacker-controlled hostname, bypassing downstream re-validation because both fast-uri and Node.js's built-in URL parser silently accept the malformed output as well-formed. Applications in the Fastify ecosystem that build URIs from parts — passing untrusted data into the port field of a URI object through serialize, normalize, or equal — on fast-uri versions before 2.4.6, 3.1.7, or 4.1.4 are affected. No public exploit has been identified at time of analysis, and the CVE is not listed in CISA KEV; vendor-released patches are available across all three active release lines.

Remote code execution as root on the Submariner gateway node is possible in cert-auth mode, affecting Submariner as bundled in Red Hat Advanced Cluster Management for Kubernetes 2. The gateway builds its IPsec connection configuration from unvalidated free-form CRD fields, so a malicious member cluster can publish a CableName containing embedded newlines and ipsec.conf directives (e.g. a leftupdown hook) that get executed on the gateway. No public exploit identified at time of analysis; the flaw is reported and tracked by Red Hat.

Annotation injection in F5 NGINX Ingress Controller allows any authenticated Kubernetes principal with write access to Ingress resources to embed arbitrary NGINX configuration directives through unsanitized annotation fields. The configuration generator passes multiple user-controllable annotation values directly into the generated nginx.conf without sanitization, enabling an attacker to inject directives that create or delete files, disable services, or manipulate NGINX routing behavior. Impact is confined to the Kubernetes control plane; the NGINX data plane itself is not directly reachable through this vulnerability.

Configuration injection in NGINX Gateway Fabric allows authenticated Kubernetes users with CRD or Secret write permissions to embed arbitrary NGINX directives into the generated server configuration. The vulnerability originates in the NGINX configuration generator component, which renders Authentication Filter fields - clientID, cookieName, and clientSecret - directly into configuration templates without sanitization. Successful exploitation is limited to the control plane; no data-plane traffic is directly manipulated, but an attacker can introduce directives that compromise confidentiality and integrity of the NGINX Plus configuration. No public exploit has been identified and the issue is not listed in CISA KEV at time of analysis.

Remote code execution in Jenkins 2.579 and earlier (LTS 2.568.2 and earlier) allows any low-privileged authenticated user to compromise the Jenkins controller by submitting a crafted `config.xml` document. The document embeds objects that Jenkins treats as independent top-level configuration types - such as job definitions or global settings - as nested field values; once bound into Jenkins' runtime object graph, Stapler (Jenkins' HTTP routing framework) begins dispatching live HTTP requests through those embedded objects, providing an attacker-controlled code execution path. Vendor-released patches (Jenkins 2.580, LTS 2.568.3) are available as of 2026-09-02; no KEV listing or public POC is confirmed at time of analysis.

Remote code execution in the WatchMan-Site7 WordPress plugin (all versions through 4.2.0) allows any authenticated user - including a low-privilege subscriber - to run arbitrary PHP on the server because the plugin's debugging console, which evaluates user-supplied PHP, is not access-restricted. Publicly available exploit code exists (reported by WPScan), and with CVSS 9.9 this represents full server compromise from the lowest authenticated role. There is no public evidence of active in-the-wild exploitation at time of analysis.

Template injection in Eclipse Ditto's ImplicitThingCreationMessageMapper (versions 1.3.0 through 3.9.6) allows authenticated connection publishers to override the administrator-configured access policy of a newly provisioned digital twin by embedding JSON-breaking characters in attacker-controlled inbound message headers. The mapper substitutes header placeholder values as raw, unescaped strings into a pre-configured JSON thing-template before parsing, enabling a crafted header value containing a double-quote to escape its string context and inject an inline _policy object - effectively granting the attacker full read/write access to the twin while permanently revoking the legitimate owner's access. Exploitation requires a non-default mapper configuration and a template that reflects attacker-controllable headers; no public exploit code or active exploitation (CISA KEV) has been identified.

RESP protocol command injection in Predis, the popular PHP client for Redis and Valkey, affects versions 3.0.0-RC1 through 3.2.x when pipeline() is used over aggregate cluster or replication connections. Because AbstractAggregateConnection::write() re-splits an already-serialized RESP buffer on CRLF instead of respecting RESP length prefixes, attacker-controlled keys or values containing carriage-return/line-feed bytes are re-parsed as additional Redis commands, enabling shard-wide cache deletion, targeted data reads/writes, or node disruption on clusters and denial-of-service on replication setups. Fixed in 3.3.0; no public exploit identified at time of analysis, and it is not listed in CISA KEV.

Unauthenticated remote code execution in HPE Networking Fabric Composer allows a network attacker to run arbitrary code as a privileged user on the appliance's underlying operating system, resulting in complete host compromise. HPE notes exploitation depends on 'certain preconditions outside of the attacker's control,' which is reflected in the CVSS high attack complexity (AC:H). No public exploit is identified at time of analysis and the flaw is not listed in CISA KEV.

XML injection in @xmldom/xmldom 0.9.0-0.9.11 allows an attacker to embed malicious markup into serialized XML output by supplying element or attribute names containing ECMAScript line terminators (U+000A, U+000D, U+2028, U+2029). The QName_exact regex in lib/grammar.js is compiled with JavaScript's multiline flag, causing the ^ and $ anchors to match per-line rather than over the full string - a name whose first line is a valid QName passes validation while subsequent lines carry injected markup, bypassing both the default serialization path and requireWellFormed: true. No public exploit has been identified at time of analysis, but the CVSS 4.0 score of 8.7 with no prerequisites reflects the high-integrity impact when an application passes attacker-controlled input to createElementNS, createAttributeNS, createDocumentType, or createAttribute.

XML injection in the xmldom serializer allows a crafted DocumentType.name containing '>' or whitespace to prematurely close the <!DOCTYPE ...> declaration and inject arbitrary sibling markup into serialized XML output. The gap exists because XMLSerializer.serializeToString() under requireWellFormed: true validates publicId, systemId, and internalSubset but emits DocumentType.name verbatim, violating the XML Name production consistently enforced for the other fields. Affected packages are @xmldom/xmldom prior to 0.8.15 and 0.9.12, and all versions of the legacy unscoped xmldom (0.6.0 and earlier) for which no vendor-released fix will be issued; no public exploit code or CISA KEV listing has been identified at time of analysis.

XML injection in the xmldom JavaScript library allows crafted attribute names to break out of attribute context during serialization, enabling injection of arbitrary attributes — including event handlers — into browser-consumed XML/HTML output. Applications using @xmldom/xmldom before 0.8.14 or 0.9.11, or any version of the legacy xmldom package (≤0.6.0), are affected when attacker-controlled data reaches Element.setAttribute() and the result is serialized via XMLSerializer.serializeToString(). No public exploit is identified at time of analysis, but the vulnerability class is well-understood and the injection mechanism is straightforward for any attacker who can influence attribute name input.

Code injection in Dell PowerStore storage appliances (500T through 7000T series and potentially additional models) allows an authenticated user with limited privileges to execute arbitrary code at root privilege level, achieving full appliance compromise. The CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H vector confirms that exploitation requires only local authenticated access with low-level credentials and no user interaction, with the resulting code execution crossing a privilege boundary into a root context. No public exploit code has been identified and this vulnerability is not listed in the CISA KEV catalog at time of analysis.

Remote code execution in Klemsan KIO (Klemsan Internet Objects) versions prior to v1.9 allows attackers to inject and execute arbitrary code against the network-facing application. The flaw, reported by TR-CERT (Turkey's national CSIRT), carries a CVSS 9.8 and requires no authentication or user interaction, giving full compromise of confidentiality, integrity, and availability. There is no public exploit identified at time of analysis and it is not listed in CISA KEV, but the trivial attack profile makes it a high-priority patch.

Remote code execution in Lutece Core (versions up to and including 7.1.7) allows an authenticated administrator to run arbitrary Java code on the server by abusing the XSL export management module. Because the XML/XSLT processor is configured without FEATURE_SECURE_PROCESSING, malicious XSL stylesheets can invoke Java extension functions; an admin uploads a crafted XSL transformation and triggers it during a user export. Rated CVSS 4.0 9.4 (critical); no public exploit identified at time of analysis and it is not listed in CISA KEV.

Eval injection in cPanel's Park API (versions 11.138.0.0 and earlier) enables remote authenticated users to execute arbitrary code with root-level privileges on affected hosting servers. The vulnerability, classified under CWE-95 (Eval Injection) and reported via HackerOne, was disclosed alongside a WebPros vendor advisory on August 27, 2026. No public exploit code or CISA KEV listing has been identified at time of analysis, though the direct path to root execution across a widely deployed hosting platform makes this a critical remediation priority.

Remote code execution in lllyasviel Fooocus 2.1.854 through 2.5.5 allows any user who can upload an image to execute arbitrary Python code on the hosting server. The vulnerability stems from the `get_list` function in `modules/meta_parser.py` passing a `styles` field extracted from image EXIF metadata directly to Python's `eval()` without sanitization or sandboxing. A detailed technical writeup exists at mrbruh.com/fooocus and the vulnerable code path is publicly visible in the repository; no confirmed active exploitation has been identified at time of analysis, and EPSS stands at 0.24% (15th percentile).

Remote code execution in ash_ai (versions 0.1.0 through pre-1.0.0) allows unauthenticated network attackers to execute arbitrary Elixir code on the server by submitting EEx template payloads through prompt action arguments. The AshAi.Actions.Prompt module incorrectly passed function-supplied prompt content - which is frequently assembled from user-controlled action arguments - through EEx.eval_string/2 before forwarding to the AI model, meaning payloads like <%= System.cmd("id", []) %> execute server-side with application process privileges. No public exploit code or CISA KEV listing exists at time of analysis, but the zero-authentication, single-request exploitation path gives this a higher operational priority than the EPSS percentile alone suggests.

Authenticated command injection in IBM Langflow OSS 1.0.0 through 1.11.1 lets any logged-in flow user escalate to arbitrary OS command execution under the server process identity. By saving a flow containing a crafted 'type' field and triggering a build of a wrapper flow that references it, the attacker coerces the backend into evaluating attacker-controlled code, defeating the LANGFLOW_ALLOW_CUSTOM_COMPONENTS=false guardrail intended to block custom code execution. The vendor (IBM) reported it and has released a fix; there is no public exploit identified at time of analysis and it is not in CISA KEV.

Remote code execution in IBM Langflow OSS 1.0.0 through 1.11.1 arises from the A2A (agent-to-agent) public endpoint failing to properly enforce security restrictions, letting a network attacker inject and run arbitrary code on the host. The CWE-94 code-injection flaw carries a critical 9.8 CVSS score with a network, no-privilege, no-interaction vector, meaning any reachable instance is directly at risk. IBM has released a fix; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.

Remote code execution in IBM Langflow OSS 1.0.0 through 1.11.1 allows a network-accessible authenticated attacker with low privileges to inject and execute arbitrary code server-side due to improper control of code generation (CWE-94). The CVSS 8.8 High score reflects low attack complexity, no required user interaction, and full confidentiality, integrity, and availability impact against the vulnerable host. IBM has released a patch; no public exploit or CISA KEV listing is identified at time of analysis.

Remote code execution in Yamcs (yamcs-core <= 5.12.7 and 5.13.0-5.13.1) lets an authenticated, low-privileged user run arbitrary OS commands by injecting a StreamSQL LIKE pattern that breaks out of a generated Java string literal compiled at runtime by Janino. Because the pattern is embedded raw whether it arrives as a SQL literal or a bound '?' argument, the sink is reachable not only from the archiving endpoints but from routine read-only APIs (readRows, events search, activities listing), including the Events page search box. A detailed vendor-published proof of concept exists; this is not in CISA KEV, so it is publicly available exploit code rather than confirmed active exploitation.

Remote code execution in Yamcs (open-source mission-control server) versions <= 5.12.7 and 5.13.0-5.13.1 allows a caller with the CreateInstances privilege - or any unauthenticated user in the default no-security.yaml configuration where guest is superuser - to inject YAML into an instance template via the templateArgs parameter of POST /api/instances (and PATCH /api/instances/{instance}). Because arguments are written into the rendered config as raw, unescaped text and then loaded as YAML, an attacker can inject a services: entry that instantiates org.yamcs.ProcessRunner and executes an arbitrary command as the Yamcs service account. Publicly available exploit code exists (a full PoC with a reverse shell is published in the GitHub Security Advisory), and vendor patches are available in 5.12.8 and 5.13.2.

Remote code execution in Yamcs (Mission Control) versions <= 5.12.7 and 5.13.0-5.13.1 allows an authenticated user holding the ControlArchiving system privilege to run arbitrary Java on the server host by embedding executable code in a StreamSQL column name. The malicious name is interpolated unescaped into Java source that Janino compiles without a sandbox when a sum() aggregate is evaluated over that column via POST /api/archive/{instance}:executeSql. This is a second, independent Janino sink sharing the root cause of CVE-2026-44632, which the earlier fix did not close; the advisory (GHSA-3g44-3m7x-cgg2) includes a full working PoC verified end-to-end against a real, security-enabled Yamcs 5.13.0, though there is no CISA KEV listing.

Expression language injection in Flextype CMS through v1.0.0-dev enables authenticated API token holders to read arbitrary server-side files by passing unsanitized input to the Symfony ExpressionLanguage engine via POST /api/v1/query. The evaluation scope exposes application objects including filesystem() and serializers(), making sensitive file disclosure (credentials, configuration files, secrets) straightforward for any token-bearing attacker. Escalation to remote code execution is conditionally possible if a secondary vector exists to place a PHP file on disk; a publicly available proof-of-concept exists, and the vulnerability is not yet in CISA KEV.

Remote code execution in BISHENG's workflow engine (versions before 2.6.0) allows any authenticated user to submit crafted Code node definitions to the POST /api/v1/workflow/run_once endpoint, where they are evaluated via Python's exec() built-in without sandboxing or process isolation. Successful exploitation grants full server-side code execution with access to the host filesystem, stored credentials, and internal network resources reachable from the BISHENG backend process. No public exploit or CISA KEV listing has been identified at time of analysis, but the low-complexity, authenticated network attack path represents a critical risk especially in multi-tenant or shared-access deployments.