Remote Code Execution

Path traversal via symlink prefix reuse in gitoxide's gix-fs crate (before 0.23.0; GHSA lists <= 0.21.0) allows a crafted repository tree to write attacker-controlled symlinks outside the worktree during forced checkout with overwrite_existing enabled, enabling code execution by overwriting known paths such as .git/hooks/post-checkout. Exploitation is local, requires user interaction to initiate checkout of an untrusted tree, and has high attack complexity tied to winning the prefix-reuse condition; no public exploit was identified at time of analysis, and no KEV or EPSS data were provided. Per the assessed CVSS:3.1 vector AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H, unauthenticated but local access with user interaction is required.

Unauthenticated remote code execution in Apache Roller 6.1.5, where the XML-RPC endpoint deserializes attacker-controlled bytes during request parsing before any authentication check occurs. The servlet is mapped unconditionally, so the vulnerable parsing path is still reachable even when the global XML-RPC feature is turned off, and no non-default configuration is required. This rates CVSS 3.1 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), and no public exploit code has been identified at time of analysis; practical RCE reliability depends on a usable deserialization gadget chain being present on the application classpath, which the advisory does not enumerate. Vendor-released patch: Apache Roller 6.1.6.

Unauthenticated remote code execution affects GestSup, the PHP-based IT asset and ticket management application, in all versions before 3.2.61. Attackers simply send an email carrying a PHP attachment to a mailbox the GestSup basic IMAP connector monitors; the connector fails to apply its blocked-extension filter during attachment ingestion, writes the file into the web-accessible upload/ticket directory, and the payload executes when requested over HTTP (CWE-434). Exploitation requires the IMAP connector to be configured and actively polling a mailbox (the AT:P precondition in the CVSS 4.0 9.2 vector); deployments without email-to-ticket ingestion are not exposed, and no public exploit was identified at time of analysis.

Authenticated administrators of ClipBucket v5 who hold the manage_template_access permission can abuse a path traversal in the admin template editor (template_editor.php) to write attacker-controlled PHP files outside the intended styles/layout directory and have them executed as the web server user, yielding remote code execution on all versions before 5.5.3-#197. Publicly available exploit code exists (a HackMD writeup linked from the CVE record), and the vendor has released a fix in commit f31de49b and release tag 5.5.3-#197; the bug is access-gated by the administrator privilege and permission requirement (CVSS 4.0 base 8.6, PR:H), and there is no confirmed active exploitation in CISA KEV. This is a genuine but access-gated risk that primarily matters where multiple admin accounts exist or admin credentials are weak or reused.

Local privilege escalation in GNU libextractor before 1.16 allows a low-privileged local attacker to execute arbitrary code with elevated privileges by pointing the LIBEXTRACTOR_PREFIX environment variable at a directory containing a malicious plugin, which the library loads from that untrusted search path without privilege checks. Exploitation requires a setuid or setgid consumer of libextractor to be installed and invocable on the host, so the issue is conditionally gated rather than a remote-facing emergency. Publicly available exploit code exists (a PoC repository is referenced), and the vendor has released a fix; no CISA KEV entry confirms active exploitation at time of analysis.

Authenticated administrators of the Zammad helpdesk platform (versions prior to 7.1.2) can achieve remote code execution on the Zammad server by injecting specially crafted text into an AI Agent configuration field that bypasses the application's ERB sanitizer. Because the pre-7.1.2 sanitizer used Ruby's `.sub` and escaped only the first `<%` opener, an attacker with AI Agent create/edit permissions can smuggle a nested ERB tag (e.g. `<%<%= ... %>`) that executes automatically the next time the affected agent processes a ticket, with no interaction from other users required; this yields full read/write/delete access to data on the host (VC:H/VI:H/VA:H). The flaw is a genuine remote code execution issue, not a mislabeled availability problem, and it requires admin-level privileges (PR:H) plus the optional AI Agent feature being in active use; no public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor fix ships in Zammad 7.1.2 (GHSA-gp3x-9xm8-rcj6).

Remote code execution is achievable on self-hosted deployments of golang.org/x/playground by chaining two independent weaknesses: a crafted txtar archive that escapes the intended execution context and forces arbitrary writes into the playground host's trusted filesystem, plus a malicious go env configuration file that one of the three go vet invocation paths reads from the host's $HOME because that path fails to properly restrict its execution environment. Neither primitive is sufficient on its own - the attacker must combine the filesystem write with the poisoned environment file to reach code execution on the host, and the reachable surface is bounded to one specific vulnerable go vet invocation path out of three. The public go.dev/play service is explicitly NOT affected, so exposure is limited to independent forks and self-hosted deployments running golang.org/x/playground versions before 0.0.0-20260924211604-6d73cff14c17; no public exploit code or confirmed active exploitation was identified at time of analysis (CISA SSVC exploitation: none), and the vendor has released a patch.

Local file inclusion in InvoicePlane before 1.7.2 allows an authenticated low-privileged user who can influence the e-invoice xml_id configuration to use path traversal sequences to include an existing .php file from the XMLconfigs helper directory. This is a moderate-priority, not urgent, finding: the advisory establishes local file inclusion, while full code execution would require a separate file-upload or file-write primitive, and no public exploit identified at time of analysis. The issue is fixed in version 1.7.2 via an allowlist on xml_id.

Host root code execution is reachable from inside a Google gVisor sandbox built prior to commit 573a9e73cf844f when the host Linux platform has CUSE (Character Device in Userspace) enabled. A local attacker holding container-image deployment privileges (CVSS PR:L) can embed a /dev/cuse device node in an image; opening it in the sandbox passes through to the host gofer instead of the sentry's emulated device registry, letting the attacker register a host device and abuse CUSE's unrestricted ioctl handling to overwrite root udev helper memory. Exploitation is local and gated on the CUSE-enabled host prerequisite plus the pre-fix passthrough character-device behavior, so default hosts without CUSE are not exploitable; no public exploit code was identified at time of analysis and there is no CISA KEV listing (EPSS not provided).

Arbitrary code execution in IBM Guardium Data Protection 12.2 is reachable by an authenticated, high-privilege user who can write to or otherwise influence the Quartz JDBC job store, because the scheduler deserializes stored job data without validating the Java object graph it reconstructs. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, 7.2) requires valid privileged credentials but no victim interaction, and successful exploitation gives full loss of confidentiality, integrity, and availability on the affected server. No public exploit code has been identified at time of analysis and the CVE is not in CISA KEV, but IBM has published a vendor patch to remediate the issue.

Path traversal in IBM Guardium Data Protection 12.2 allows a remote attacker holding valid low-privilege credentials (CVSS PR:L) to escape a restricted directory and read sensitive files, delete arbitrary files, or execute arbitrary code on the appliance. The condition is not unauthenticated - it requires network reachability to the Guardium instance plus a legitimate low-privilege account - and attack complexity is rated high (AC:H), so exploitation depends on crafting path inputs that satisfy conditions outside the attacker's full control. No public exploit code has been identified and the flaw is not confirmed actively exploited (no CISA KEV listing), though vendor patch guidance is available and the CVSS score of 7.5 reflects the high confidentiality, integrity and availability impact if the traversal succeeds.

Image upload handling in Piwigo before 16.4.0 permits authenticated attackers to read arbitrary files and, in permissive configurations, write server-side files or achieve remote code execution by abusing Imagick's processing of user-supplied images. Format confusion-such as disguising SVG content as PNG-can trick Imagick into interpreting embedded SVG elements that reference local files, while the Magick Scripting Language (MSL) may be abused for unauthorized file writes and code execution if ImageMagick's policy.xml allows MSL and SVG delegates. Exploitation requires Piwigo to use the Imagick backend (not GD) and an authenticated account with upload rights; vendor rates it 7.2 with PR:H and full C/I/A impact, whereas independent assessment lowers integrity/availability to L and stresses that hardened ImageMagick policies commonly block the RCE path. No public exploit identified at time of analysis, and version 16.4.0 provides the vendor-released patch.

A use-after-free race condition in QEMU's 9pfs (virtfs) passthrough subsystem allows a malicious guest user to escape the shared directory boundary and read or write arbitrary files on the host, potentially achieving code execution as the QEMU process user (VM escape). Only hosts that have enabled 9pfs/virtfs host-directory sharing are exposed, since this is not a default configuration; the attacker must be a local guest user able to issue 9p protocol requests and must win a race between QEMU's main thread and a 9pfs worker thread with concurrent Tlcreate and Twalk requests. No public exploit code or active exploitation telemetry was identified at time of analysis, but the flaw is rated high severity (CVSS 8.8, scope-changed, C:H/I:H/A:H) and affects QEMU packages shipped in Red Hat Enterprise Linux 6 through 10, Red Hat OpenShift Container Platform 4, and related Red Hat products.

Command injection in the kitty terminal emulator (versions 0.47.3 through 0.48.x) lets any program that can get output rendered on screen - a file shown with cat, a log line, command output, an SSH banner, or a web response - make kitty write attacker-composed printable ASCII back into the pseudoterminal, where the user's shell treats it as typed input and executes it with the user's privileges. The root cause is that the OSC 21 colour-control handler echoed unrecognised field names verbatim into its reply, and the 0.47.3 restriction (introduced as the fix for CVE-2026-54057) to printable ASCII excluding ';' and '=' still left enough characters to compose a shell command; the newline needed to submit that command is obtainable through the ssh kitten path. Exploitation is local (AV:L) and requires the victim to display attacker-controlled bytes (UI:P), no privileges are required, and no public exploit code has been identified in the available intelligence at time of analysis. The 9.3 CVSS 4.0 base score overstates real-world reach, since this is not a remote, unauthenticated, one-click compromise; the vendor-released patch is kitty 0.49.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.

Local file inclusion in the WP Maps (flippercode) plugin for WordPress, affecting all versions up to and including 4.9.8, allows an authenticated attacker holding subscriber-level access or above to supply a crafted 'page' parameter that reaches the plugin's include logic and pulls in arbitrary local PHP files. File disclosure and access-control bypass are achievable against default configurations, but full remote code execution is conditional, requiring the attacker to additionally place or reference an includable .php file on the server (for example through an upload feature). There is no public exploit identified at time of analysis, and the issue is not confirmed as actively exploited (CISA KEV).

The Perl CPAN distribution IO::Socket::SSL::SelfCertificate version 1.00 is itself the attack artifact: its generate_certificate() routine writes a Python script disguised as a certificate file and executes it, causing base64-obfuscated code to be fetched from a hardcoded HTTP URL and run in memory without ever dropping a script to disk. Anyone who installs the 1.00 tarball and calls that function is exposed - a local, unauthenticated action requiring user interaction (assessed CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), rather than the remote pre-authentication scenario implied by the CNA's 9.8 network vector - and outbound HTTP egress must be reachable for the payload to be retrieved. The advisory notes there are no test scripts or build hooks, so nothing fires automatically at install time and the payload must be manually triggered; no public exploit code beyond the malicious package itself has been identified at time of analysis, EPSS is negligible at 0.12% (1st percentile), and the nearly identical CVE-2026-95831 covers the sibling Crypt::SelfCertificate module.

Improper TLS certificate validation in the eufy Omni C20 robot vacuum allows an attacker who has already obtained a man-in-the-middle position on the device's network path to present a forged certificate, hijack the connection, and ultimately execute arbitrary code on the device. The flaw carries a vendor/NVD CVSS 4.0 score of 9.3 (AV:N/AC:L/AT:N/PR:N/UI:N), but the independent assessment re-rates it as CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:L because exploitation is unauthenticated and requires no user interaction yet is gated on a privileged network position - hostile or shared Wi-Fi, a rogue access point, or ARP/DNS spoofing on the LAN path - meaning a purely off-path remote attacker cannot trigger it. Reported through CISA ICS-CERT (ICSA-26-267-02); no public exploit code has been identified at time of analysis and there is no confirmed actively exploited (CISA KEV) status. Devices that only ever connect to trusted, isolated home networks face substantially lower exposure than those on public, guest, or shared networks.

Local privilege escalation in Rapid7 Insight Agent on Windows allows an authenticated low-privileged local user to execute arbitrary code as SYSTEM when the agent runs InsightVM assessment content at or below version 0.0.261.0. The flaw stems from an unqualified `code` command invoked from a SYSTEM process, so a user-writable directory placed earlier in the machine PATH can supply a malicious executable. Rapid7 self-reported the issue and automatically remediated it through assessment content 0.0.269.0 on September 15, 2026; no public exploit was identified at time of analysis.

Type confusion in the AWS pgcollection PostgreSQL extension (versions 2.0.0 through 2.1.1) lets an authenticated remote database user execute arbitrary code as the postgres operating system user by submitting crafted SQL that triggers mismatched type metadata during collection value retrieval and array conversion. The flaw carries a CVSS 4.0 base score of 8.7 (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H), reflecting a network-reachable, low-complexity attack that requires only a valid low-privileged database role but yields full confidentiality, integrity and availability impact. AWS has released pgcollection 2.1.2 as the fix; no public exploit code has been identified at time of analysis, and exploitation is constrained to databases where the non-default extension is actually installed and where an attacker can execute the affected SQL functions.

Authenticated remote code execution in the Honeywell PD45 Industrial Printer web management interface lets a user holding an admin or itadmin account write arbitrary files and run commands on the device by feeding Intermec Fingerprint programming-language instructions directly to the printer's internal command interpreter. Only firmware version F10.19.010040 is identified as affected, and exploitation is not possible pre-authentication: valid administrative credentials and network reachability to the management interface are both mandatory, which is why our independent assessment rates the privilege requirement as High (PR:H) rather than the vendor's Low. No public exploit code has been identified at time of analysis and there is no CISA KEV listing; Honeywell addressed the flaw in firmware F10.22.030745.

Unauthenticated remote code execution in Honeywell PD45 Industrial Printer firmware F10.19.010040 lets any network-reachable attacker upload attacker-controlled files through the web management interface and execute them as malicious files and commands. The CVSS 3.1 base score of 9.8 (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H) reflects the complete absence of authentication or user interaction required, consistent with CWE-306 missing authentication for a critical function, so a single unauthenticated HTTP request path is enough to gain code execution on the device. Honeywell has released fixed firmware F10.22.030745; no public exploit code has been identified at time of analysis, but exposure is constrained mainly by the fact that these industrial printers typically sit on internal warehouse or manufacturing networks rather than the public internet, meaning an attacker usually needs an existing network foothold or adjacent access first.

DBHub's `readonly = true` option on its `execute_sql` tool fails to enforce read-only database access in versions prior to 0.22.6, because the connector code that would set PostgreSQL `default_transaction_read_only=on` and open SQLite in read-only mode is gated on a configuration value that is never populated. With only a first-keyword classifier left as a guard, any `SELECT` that calls a side-effecting function passes, allowing sequence tampering with an ordinary role and, with a privileged PostgreSQL role, arbitrary host file write via `lo_export`, arbitrary host file read via `pg_read_file`, and remote code execution via `dblink` combined with `COPY ... TO PROGRAM`. The HTTP transport is unauthenticated (CVSS vector PR:N) and binds to `0.0.0.0` by default, so any network caller of `/mcp` can reach the vulnerable tool; CVSS is 7.4 (AV:N/AC:H) and no public exploit code has been identified at time of analysis, though the vendor-released patch 0.22.6 resolves the issue.

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 remote code execution in IBM DataStage on Cloud Pak for Data 5.4.0.0 lets a low-privileged user with network access to the service reach an unsafe deserialization sink and execute arbitrary code in the context of the affected component. The issue is CWE-502 (deserialization of untrusted data) rated CVSS 3.1 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), so a successful attack yields high confidentiality, integrity and availability impact with no user interaction required. Exploitation requires previously obtained valid CP4D/DataStage credentials (PR:L) and no public exploit code has been identified at time of analysis; CISA's SSVC assessment records exploitation as none and the attack as not automatable, though the technical impact is rated total.

OS command injection in IBM DataStage on Cloud Pak for Data 5.4.0.0 lets a remote authenticated attacker with only low privileges (CVSS:3.1/AV:N/AC:L/PR:L/UI:N) run arbitrary operating system commands on the affected platform, yielding high confidentiality, integrity, and availability impact for an overall CVSS base score of 8.8. Exploitation requires a valid CP4D session and access to the DataStage functionality that forwards attacker-controlled input into a shell command without sanitization; no public exploit identified at time of analysis, and IBM has published a vendor fix. Only the 5.4.0.0 build is explicitly named as affected, so patched builds referenced in IBM's advisory remove the exposure.

Unauthenticated remote code execution in Rejetto HFS2 (HTTP File Server) through version 2.4.0 lets an attacker execute arbitrary commands on the underlying host by hiding server-side template syntax inside the filename of a multipart file upload. The crafted filename closes the template quoting context and injects an exec macro, which bypasses the dispatcher's authorization check, so no credentials or user interaction are required (assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H; vendor score 10.0). Publicly available exploit code exists and an advisory with a proof-of-concept walkthrough is referenced by VulnCheck, but no KEV entry was provided, so this is not confirmed as actively exploited; the practical limiting factor is whether the multipart upload endpoint is reachable from the attacker's network.

Local attackers can achieve arbitrary code execution by tricking a user or automation into processing a crafted manifest file with 'rpm -q -p', due to unexpected macro expansion of manifest entries in RPM before they are opened. This command injection flaw (CWE-78) affects Red Hat Enterprise Linux 6 through 10 and Red Hat Hardened Images, with a CVSS 3.1 base score of 7.8 (HIGH, AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H); exploitation requires user interaction but no privileges, and impact is limited to the privileges of the rpm process. No public exploit code or active exploitation has been identified at time of analysis.

Local privilege escalation in Evope Collector (all versions before 1.1.7.13) lets an attacker who already has a local foothold with write access to C:\ProgramData\Evope\ plant a file named wtsapi32.dll that Evope.Service.exe, running as NT AUTHORITY\SYSTEM, loads without validating its origin, resulting in arbitrary code execution with SYSTEM privileges. The weakness is an uncontrolled search path element in the service's DLL loading, so exploitation requires no victim interaction, though the service must start or restart before the planted library is loaded (captured as AT:P in the 7.5 CVSS 4.0 vector). No public exploit code or CISA KEV entry was identified at time of analysis, and the vendor has published a fixed version, 1.1.7.13.

Unauthenticated local file inclusion in the Visual Composer Website Builder plugin for WordPress (all versions up to and including 45.16.0) lets remote attackers supply the vcv-template request parameter to force the server to include and execute files of their choosing. Because the vulnerable code path is reachable without authentication (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), attackers can directly bypass access controls and read sensitive files on the host; full PHP code execution is achievable only where the attacker can also plant an includable file (for example an uploaded image or other supposedly 'safe' file type) on the server. At time of analysis there is no confirmed active exploitation (not listed in CISA KEV) and no public exploit code identified, though the Wordfence advisory and the plugin's own Trac changeset confirm an upstream fix has been committed.

An out-of-bounds write in GIMP's GIMPressionist plug-in allows an attacker to corrupt memory by convincing a user to load a malicious preset file, potentially leading to a crash or arbitrary code execution. The flaw is an unauthenticated local attack (CVSS PR:N) that requires user interaction (UI:R) to open a crafted preset file, and it affects GIMP as packaged in Red Hat Enterprise Linux 6 through 10 plus likely upstream GIMP versions. No public exploit has been identified at time of analysis, and the overall risk is assessed as genuine but not urgent due to the requirement for user interaction with a crafted file.

PHP object injection in the wpForo Forum WordPress plugin before 3.1.6 lets an authenticated attacker with Subscriber-level access or higher submit a crafted serialized value into a user-supplied profile field that the plugin deserializes without restricting which classes may be instantiated, as rated CVSS 7.5 (AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H). Because the plugin ships no POP/gadget chain of its own, escalation to remote code execution, arbitrary file operations, or SQL injection depends on a compatible chain being present via another installed plugin or theme - the factor driving the high attack complexity - and absent such a chain the outcome is limited to object injection with no confirmed high-severity effect. Publicly available exploit code exists, no active exploitation has been confirmed (not in CISA KEV, SSVC exploitation: none), and this is an incomplete fix of CVE-2026-49769.

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.

Remote code execution in mcp-remote 0.1.16 through 0.1.38 allows an attacker who controls or compromises a remote MCP server to run arbitrary code on a connected client by supplying a malicious OAuth authorization URL that the tool passes to open() without validation. Exploitation requires the victim to initiate a connection to that malicious server (user interaction, UI:R) and no victim-side authentication is required (PR:N); users who connect only to trusted first-party MCP servers are not affected. The EPSS score is low (0.29%, 19th percentile), no public exploit identified at time of analysis, and no CISA KEV confirmation of active exploitation.

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.

Authenticated users who can define or modify a CI/CD configuration can achieve remote code execution on GitLab CE/EE servers by submitting a specially crafted regular expression that triggers a double free during server-side parsing. All versions from 19.2 before 19.2.7, 19.3 before 19.3.3, and 19.4 before 19.4.1 are affected; the vendor scores the issue 9.9, while our assessment retains full confidentiality and integrity impact but raises attack complexity to high because the vulnerable path is state-dependent and double-free corruption is inherently unreliable to exploit. Publicly available exploit code exists (a HackerOne report is referenced), and patches are available in 19.2.7, 19.3.3, and 19.4.1; there is no CISA KEV confirmation of active exploitation.

Authenticated code execution on the GitLab server is possible in GitLab CE/EE 19.2 through 19.4.0, where an integer overflow triggered while compiling a specially crafted regular expression in a CI/CD configuration can be leveraged to run arbitrary code with the privileges of the GitLab application. The attacker must hold a GitLab account with enough project privileges to create or modify CI/CD configuration (typically Developer or higher on a project), and exploitation only occurs 'under certain conditions,' so it is not universally triggerable; the vendor-assessed vector is PR:L with scope change, and our independent assessment raises attack complexity to High (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H). Publicly available exploit code exists - a HackerOne report accompanies the fix - but there is no confirmed active exploitation (no CISA KEV listing), and instances already on 19.2.7, 19.3.3, or 19.4.1 or later are not exposed.

Remote code execution in Microsoft Outlook affects Microsoft 365 Apps for Enterprise, Office LTSC 2021, and Office LTSC 2024 when a targeted user opens or previews a specially crafted email message. The CVSS vector (AV:N/AC:L/PR:N/UI:R) indicates an unauthenticated remote attacker can trigger the flaw with no credentials, but success depends on the victim interacting with the malicious message - Outlook's Preview Pane is a plausible trigger surface for message-borne code execution. No public exploit code has been identified at time of analysis (E:U) and Microsoft has released an update, so this is a high-priority patching candidate given the enormous installed base of Outlook, but not an emergency requiring emergency change control.

OS command injection in IBM DataStage on Cloud Pak for Data 5.4.0.0 allows a remote authenticated attacker holding only a low-privilege account to execute arbitrary operating-system commands on the underlying host, fully compromising the confidentiality, integrity and availability of the affected deployment. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8) confirms network reachability, low attack complexity, mandatory authentication at the low privilege level and no user interaction, matching the independent assessment that this is a genuine high-priority vulnerability rather than a high-CVSS-but-low-risk artifact. No public exploit code was identified at time of analysis, and a vendor patch is available through IBM support node 7288649; accordingly, real-world risk is concentrated in reachable, unpatched 5.4.0.0 deployments rather than in broad opportunistic exploitation.

Unauthenticated file upload in Laravel-Mediable 7.0.0 and 7.0.1 lets a remote attacker upload a .pht file that passes MediaUploader::verifyExtension() and File::sanitizeFileName(), which is then written to disk and executed as PHP when requested on Apache servers configured with the Debian/Ubuntu default FilesMatch handler, resulting in remote code execution as the web server process. The flaw is an incomplete fix for CVE-2026-49972: the forbidden_extensions list added in config/mediable.php blocks phpt but omits pht, an Apache-recognized PHP extension. Vendor-released patch 7.0.2 closes the gap; no public exploit code was identified at time of analysis, but exploitation is trivial where the upload endpoint is reachable and unauthenticated, so the issue warrants high priority despite the platform-specific precondition.

Remote authenticated code execution in IBM DataStage on Cloud Pak for Data 5.4.0.0 is possible because connector property values are not properly escaped when OSH scripts are generated, allowing an attacker with a valid account and the ability to define or edit connector properties to inject commands that execute with DataStage privileges. The flaw is network-reachable, low-complexity, and requires no victim interaction, but it requires authentication (CVSS 3.1 PR:L) and is rated 8.8 HIGH (C:H/I:H/A:H). No public exploit code or confirmed active exploitation was identified in the provided intelligence, and a vendor patch is available via IBM support.

Use-after-free in IBM Concert 1.0.0 through 3.0.0 lets an attacker who can influence program input or execution flow corrupt heap memory, crash the application, or potentially hijack control flow for code execution. No public exploit code and no confirmed active exploitation were identified at time of analysis, and IBM has published a vendor fix (advisory node 7288830). The vendor-published vector claims unauthenticated network exploitation at 9.8, but our assessment scores the issue AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H: the practical attack is high-complexity, requires an authenticated position to supply the malicious input, and the specific trigger surface is unconfirmed, so real-world severity is materially lower than the published base score suggests.

Heap memory corruption in IBM Concert 1.0.0 through 3.0.0 lets an attacker who already has low-privileged local access to the host trigger a double free (CWE-415) and, with heap grooming, execute arbitrary code in the context of the affected process. Exploitation is authenticated and local only - CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (base 7.8) - with full confidentiality, integrity, and availability impact when successful; no public exploit identified at time of analysis. IBM has published a vendor advisory and patch guidance at https://www.ibm.com/support/pages/node/7288830.

Improper bounds checking in IBM Concert 1.0.0 through 3.0.0 lets a local, authenticated user supply overlong input that overflows a buffer and achieves arbitrary code execution under the privileges of the affected process, matching the assessed vector CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. IBM's own advisory scores the issue 9.8 with a network/unauthenticated vector (AV:N/AC:L/PR:N/UI:N), but the vendor description explicitly states a 'local user' is required, so realistic exposure is confined to systems where an attacker already has a local account - a foothold-to-full-compromise escalation rather than a pre-authentication remote RCE. No public exploit code or confirmed active exploitation was identified at time of analysis, and IBM has published an advisory with a vendor-supplied fix.

Unauthenticated remote code execution in IBM Concert 1.0.0 through 3.0.0 lets any attacker who can reach the service send specially crafted input that is incorporated into operating-system commands, executing arbitrary commands with the privileges of the Concert application. The vulnerability is rated CVSS 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), meaning no authentication, no user interaction, and no special conditions are required - only network reachability of an unpatched instance. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV, so exploitation appears opportunistic-dependent rather than confirmed in the wild, but IBM has published a vendor fix, so the priority is to patch exposed instances before exploit code or scanning activity emerges.

Argument injection in WP Toolkit for cPanel 6.11.2-10794 and earlier allows a remote authenticated (low-privileged, PR:L per the CVSS vector) customer account to read arbitrary files and execute arbitrary code, with the impact extending beyond the attacker's own account into other tenants hosted on the same cPanel server. Any standard shared-hosting customer login - including a self-registered or compromised account - is sufficient, requiring no user interaction and no elevated privileges, though the extension must be installed, enabled, and reachable on a version at or below 6.11.2-10794. There is no public exploit identified at time of analysis and the issue does not appear on CISA KEV; the defining risk amplifier is the multi-tenant scope change (S:C) rather than mass internet-wide exploitation.

Any holder of a valid low-privileged cPanel account can escalate to root and execute arbitrary code on the underlying host, because a privileged cPanel operation is executed with unnecessary root privileges (CWE-250). The flaw is remotely reachable over the network with low attack complexity and no user interaction, but it does require an authenticated account (CVSS 4.0 vector PR:L) - a trivial barrier on shared hosting where accounts are commonly sold or self-provisioned, and a meaningful one on locked-down single-tenant deployments. It carries a 9.4 CVSS 4.0 score and is rated a genuine high-priority issue rather than a high-score/low-real-risk case, though no public exploit code and no confirmed active exploitation were identified at time of analysis; no EPSS estimate was available in the supplied intelligence.

OS command injection in Plesk allows any authenticated low-privilege panel account - customer, reseller, or subscription level - to run arbitrary operating-system commands with root privileges, turning what is normally a tightly scoped hosting login into full control of the managed server. The flaw is remotely reachable over the network at low complexity with no user interaction (CVSS 4.0 base 9.4; independently assessed as CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), and the scope change plus high confidentiality, integrity, and availability impact reflect a complete host compromise rather than a single-tenant breach. No public exploit code has been identified at time of analysis and the CVE is not listed as confirmed actively exploited (CISA KEV), but the low bar of a single valid non-admin session keeps the practical risk high; the specific vulnerable panel function and the exact affected Plesk versions are not stated in the available data and must be confirmed against the vendor advisory.

Arbitrary code execution as root is achievable on affected Plesk servers by any authenticated panel user who can influence a directory on the untrusted search path used by the Plesk RESTful API extension. Exploitation requires Plesk core 18.0.34 through 18.0.80.7 or 18.0.81 (i.e., below 18.0.80.8 / 18.0.81.1 respectively) together with the 'Plesk RESTful API' extension at versions 2.4.2 through 2.4.6; the vector is network-reachable, needs only low-privilege credentials (PR:L per the CVSS 4.0 vector) and no user interaction, making a full root compromise of the hosting panel feasible from an ordinary subscription account. Independent assessment rates this a genuinely high-priority flaw despite thin external signal, since successful exploitation yields complete loss of confidentiality, integrity and availability on the panel host (CVSS 4.0 base 8.7; assessed CVSS 3.1 8.7 with S:U/C:H/I:H/A:H). No public exploit code identified at time of analysis, and no EPSS or CISA KEV data corroborates active exploitation; vendor fixes are available in Plesk 18.0.80.8 / 18.0.81.1 and extension 2.4.7.

Use-after-free in librsvg during rendering of crafted SVG documents with nested XInclude directives and duplicate entity declarations allows unauthenticated local attackers to crash or potentially execute code in applications that use the library. Tracked as CVE-2026-96889 and reported by Red Hat, the flaw affects librsvg as shipped in Red Hat Enterprise Linux 6, 7, 8, 9, and 10. Exploitation requires user interaction (UI:R) because a victim must open, preview, or thumbnail a malicious SVG; the CVSS 3.1 score is 7.8. No public exploit code was identified at time of analysis, and independent assessment indicates that arbitrary code execution is unproven-only denial of service or crash is reliably reachable.

Remote code execution in Red Hat Ansible Automation Platform 2's automation-controller is possible when a privileged, authenticated user (CVSS PR:H) defines a custom Credential Type and abuses its environment-variable injector to set a process-hijacking loader variable such as BASH_ENV, ENV, LD_PRELOAD, LD_LIBRARY_PATH, PYTHONSTARTUP, or GIT_SSH_COMMAND, which the existing ANSIBLE_* prefix check and fixed ENV_BLOCKLIST fail to catch. Paired with the credential file injector, the attacker plants a script in the execution environment and points the loader variable at it, so arbitrary code executes inside the execution-environment container for any job that later attaches a credential of that type; this requires both the high privilege to author the credential type and a subsequent job consuming it. Red Hat's published CVSS of 7.6 (C:L/I:H/A:N) is lower than our independent assessment of the full vector (C:H/I:H/A:H), and because the vulnerable controller and the impacted execution-environment container are different security scopes, S:C applies. There is no CISA KEV listing and no public exploit identified at time of analysis.

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.

Privilege escalation and remote code execution on managed hosts is possible in Red Hat Ansible Automation Platform 2 because the automation-controller exposes the provisioning-callback secret (host_config_key) to anyone holding only read-level view_jobtemplate permission and accepts a client-supplied X-Forwarded-For header as proof of caller identity when the gateway proxy allow-list is empty. An attacker who reads the secret from the job template API representation or the activity stream and spoofs X-Forwarded-For to match any host in the target job template's inventory can launch that template against arbitrary managed hosts using the template's stored credentials; CVSS 3.1 base score is 9.9 (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), no public exploit code was identified at time of analysis, and the decisive enabler is a non-default deployment condition - an empty proxy allow-list combined with provisioning callbacks actually being in use.

Local privilege escalation in Claris FileMaker Pro for Windows lets a low-privileged local user drop a malicious DLL into the directory used by the product's installer and thereby execute arbitrary code in the administrator context once a privileged user runs that installer. Only Windows installer builds prior to 26.0.3 are affected (EUVD records the range as 0 through 26.0.3); the installed application at runtime is not impacted. Exploitation requires local host access plus an admin-initiated installer run (CVSS:3.1/AV:L/AC:L/PR:L/UI:R), so it is neither remotely reachable nor automatable - CISA's SSVC rates Exploitation as none and Automatable as no - and no public exploit code exists, with EPSS at 0.15% (3rd percentile) reflecting the narrow local-use precondition. This is a local privilege-escalation issue with realistic but constrained risk; a vendor fix is available.

Heap-based memory corruption in Claris FileMaker Server's database engine block-parsing routine allows a maliciously crafted .fmp12 database file to overflow a heap buffer, potentially enabling arbitrary code execution in the context of the FileMaker Server process. All FileMaker Server releases prior to 26.0.3 are affected; exploitation requires that the crafted database be delivered to and processed by the server and that an operator open or host it (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 7.8), so the local delivery path and required user interaction are the principal limiting factors rather than any authentication barrier, since no privileges are needed (PR:N). No public exploit code has been identified at time of analysis, CISA SSVC records Exploitation: none with Automatable: no, and EPSS is low at 0.16% (4th percentile), making this a moderate-priority memory-corruption fix rather than an urgent field threat; Claris has released a vendor patch in FileMaker Server 26.0.3.

Remote code execution in MLflow's statsmodel flavor (versions 2.1.0 through 3.14.0) occurs because _load_model() omits the MLFLOW_ALLOW_PICKLE_DESERIALIZATION=False safeguard, allowing a crafted MLmodel artifact to trigger unsafe pickle deserialization (CWE-502). An authenticated low-privileged attacker (PR:L) who can register or supply a malicious artifact to the model registry or artifact store can achieve arbitrary code execution when a victim's pipeline or serving process loads it, although the victim must load the untrusted artifact (UI:R). The independent assessment notes that no public exploit was identified at time of analysis (SSVC Exploitation: none), and exposure is limited to environments that load untrusted statsmodel artifacts; those using only trusted internal models are not realistically exposed.

Arbitrary code execution in MLflow (versions 2.0 and later) via the dspy flavor, where an attacker-crafted MLflow model artifact causes remote code execution when loaded by a victim. The vulnerability arises because the MLFLOW_ALLOW_PICKLE_DESERIALIZATION=False safety control is enforced only when the model_path ends in '.pkl'; any other path (or extension) silently skips the check and unpickles attacker-controlled data. Per the CVSS vector (AV:N/AC:L/PR:N/UI:R) an unauthenticated remote attacker can exploit this, but success depends on user interaction: a person or automated pipeline must fetch and load the malicious model. Exploitation has not been confirmed as active (not in CISA KEV) and no public exploit code was identified at time of analysis, and CISA SSVC rates exploitation as 'none' with automatable 'no', though technical impact is total (full confidentiality, integrity, and availability loss on the host that loads the model). The CVSS 8.8 score is well-justified by the technical impact rather than inflated.

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.

Authenticated code execution in Plex Media Server before 1.43.3.10861 is a genuine but privilege-gated code-execution flaw: an attacker who first obtains admin-level access to the server's management interface can leverage the TranscoderH264Options preference, which is appended verbatim to x264's option string on every transcode, or write a malicious .so file that is loaded and executed at startup without signature, execute-bit, or symbol checks. This affects servers running versions prior to 1.43.3.10861; no public exploit was identified at time of analysis, and the supplied CVSS 4.0 score is 8.6 with PR:H, consistent with our independent CVSS 3.1 assessment requiring high privileges (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H). Because Plex admin is often the single server-owner account, the realistic attack path is credential compromise or exposure of the admin interface to untrusted networks; execution then occurs on the next transcode or after a server restart.

Unauthenticated remote code execution in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift allows an attacker positioned on an adjacent network segment to send a crafted Java-serialized payload to the PayDir Business Rules Manager RMI SSL endpoint and execute arbitrary code on the target host. Because the vulnerable service is exposed with no authentication and no user interaction required (CVSS 8.8, AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), successful exploitation exposes all PayDir credentials and enables manipulation of payment business rules, producing high confidentiality and integrity impact. The adjacency requirement is the primary limiting factor, and no public exploit identified at time of analysis; a vendor patch is available per the IBM advisory.

Message-filtering bypass in xdg-dbus-proxy before 0.1.9 lets a malicious or already-compromised sandboxed application - most notably a Flatpak app, but also deployments under frameworks such as Firejail - escape its confinement and execute arbitrary code on the host by attaching a forged reply serial number to non-reply D-Bus messages. The flaw carries a CVSS 4.0 base score of 8.7 (AV:N/AC:L/PR:N/UI:P, with high confidentiality, integrity and availability impact scoped to the sandbox-escape boundary) and is rated a genuine high-priority sandbox-escape issue rather than a CVSS-inflated paper risk; the practical precondition is that an attacker must first get code running inside a sandbox that routes its session bus through the vulnerable proxy, typically by tricking a user into installing or launching a hostile or trojanized app. No confirmed active exploitation (CISA KEV) and no public exploit code were identified at time of analysis; vendor-released patch: 0.1.9.

SQL injection in ManageEngine Applications Manager (builds 182000 and below) allows an authenticated low-privileged user to run arbitrary SQL commands against the application's database, enabling escalation to administrator privileges and, from there, remote code execution on the underlying host. The flaw carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and is rated high priority because the only meaningful barrier is possession of any valid low-privileged account - no user interaction or special configuration is required, and once credentials exist the attack complexity is low. Exploitation status: no public exploit identified at time of analysis; the issue was reported by the vendor (Zohocorp), and no CISA KEV listing or public proof-of-concept code has been observed in the supplied intelligence.

Remote code execution affects LightLLM deployments through version 1.2.0 that run the KV-transfer worker with the non-default '--pd_trans_mode nccl' option, which exposes an unauthenticated RPyC ThreadedServer control channel on the network. An attacker with network reachability can send a malicious pickled object to that channel, triggering unsafe deserialization and executing arbitrary code with the privileges of the LightLLM service account (CVSS 9.3; PR:N/UI:N). The vulnerability is not known to be actively exploited and no public exploit code has been identified at time of analysis, though the non-default configuration limits exposure to deployments that explicitly enable NCCL-based prefill/decode disaggregation.

Authenticated OS command injection in Zoho ManageEngine OpManager MSP 12.8.709 and below allows an attacker holding any valid low-privilege console account to execute arbitrary operating system commands on the server through the Notification Profile module, with no user interaction required. Exploitation yields full compromise of confidentiality, integrity and availability of the OpManager host, which for an MSP deployment typically means access to monitored customer infrastructure. The vendor rates the issue 9.9 (scope-changed); our independent assessment places it at high severity with unchanged scope, and no public exploit code has been identified at time of analysis, so the practical risk is concentrated in environments where operator or tenant accounts are widely provisioned or reusable.

Server-side template injection in the Configlet processing feature of ManageEngine OpManager, NetFlow Analyzer, and Network Configuration Manager (versions 12.8.667 and below) allows a low-privileged authenticated user to inject template expressions that the server evaluates, leading to remote code execution in the application's process context. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H; the source data lists 7.6) confirms network reachability, low privileges, and no victim interaction, but valid application credentials plus access to the Configlet/template capability are prerequisites, so real-world exposure is reduced where the console is network-restricted or where accounts lack configuration-template rights. No public exploit identified at time of analysis and no confirmed actively exploited (CISA KEV) status; this is a genuine mid-to-upper priority issue but not an emergency.

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.

Every desktop application generated by Pake inherits two upstream template defaults that together hand native IPC functionality to untrusted web content, allowing scripts served from any HTTPS origin to invoke the application's own native commands, including download_file. The root cause is a wildcard Tauri capability ("remote": { "urls": ["https://*.*"] } in src-tauri/capabilities/default.json) paired with "withGlobalTauri": true in src-tauri/tauri.conf.json, which places window.__TAURI__.core.invoke() within reach of ordinary page JavaScript; because Tauri's access control list only validates plugin: commands and not commands registered by the application itself via generate_handler!, no permission entry is required to call them. Exploitation is unauthenticated per the assessed vector (PR:N) but requires user interaction (UI:R) - the victim must run the generated app and attacker-controlled JavaScript must execute inside it, whether directly or through third-party analytics, advertising, or a compromised CDN loaded by the wrapped site. Chained with the path traversal tracked separately as CVE-2026-82635, this escalates to arbitrary file write and persistent code execution; no public exploit identified at time of analysis, and the issue is fixed in Pake V3.17.0.

An out-of-bounds write (CWE-787) in the PDF rendering engine of Foxit PDF Editor and Foxit PDF Reader can be triggered when a victim opens a specially crafted PDF containing malformed color space data, causing the application to crash and potentially allowing remote code execution in the context of the logged-in user. The flaw is rated CVSS 3.1 7.8 (High) with vector AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H: exploitation is unauthenticated per the vector but strictly local in attack path and requires user interaction, meaning the attacker must deliver the file and convince the target to open it on an affected default installation. There is no confirmed active exploitation (not listed in CISA KEV) and no public exploit identified at time of analysis; the confirmed outcome is a crash, with code execution described by the vendor as potential rather than demonstrated, and EPSS data was not provided with this record.

Crafted PDF files can trigger a memory-corruption condition in the FileOpen (DRM) plugin of Foxit PDF Editor and Foxit PDF Reader, exploiting inadequate validation of encryption metadata to dereference an invalid internal pointer. Successful exploitation requires a victim to open a malicious PDF, after which the flaw may allow arbitrary code execution in the context of the local user; the vendor qualifies that code execution is only potentially achievable versus a crash. No public exploit identified at time of analysis, and no authentication is needed on the attacker side.

Use-after-free in Foxit PDF Editor and Foxit PDF Reader (CWE-416) lets a specially crafted PDF trigger memory corruption while the application processes JavaScript array objects, potentially crashing the viewer or achieving arbitrary code execution in the context of the logged-on user. Exploitation is client-side only: the attacker must lure a victim into opening a malicious PDF with JavaScript execution enabled in the product (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, 7.8), and there is no privilege prerequisite or network-service exposure. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and no EPSS score was supplied; turning the use-after-free into reliable code execution additionally depends on attacker-controlled heap state, which is the principal limiting factor beyond the mandatory user interaction.

Insufficient validation of embedded-resource file paths in Foxit PDF Editor and Foxit PDF Reader (CVE-2026-91801) lets an attacker embed traversal sequences in a PDF so that files are written outside their intended location when the document is opened or previewed, with a conditional path from that arbitrary-file-write primitive to code execution. Rated 7.8 (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), the issue is a client-side parsing flaw: no authentication is required, but user interaction is mandatory and there is no network-facing or default-service exposure, so risk is bounded to users who process untrusted PDFs. No public exploit identified at time of analysis, and escalation to code execution remains conditional on a viable write target.

Man-in-the-middle attackers occupying the network path of Foxit PDF Editor and Foxit PDF Reader software-update traffic can bypass TLS certificate validation and update package integrity checks, allowing a forged update to be accepted and executed with system privileges. Exploitation is materially constrained: the client must both be intercepted and perform an update check/download in that window, which is why the CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H vector scores AC:H, and no authentication (PR:N) or user interaction (UI:N) is required. Affected builds are Foxit PDF Editor 2026.2 and earlier, 14.0.7 and earlier, and 13.2.6 and earlier, plus Foxit PDF Reader 2026.2 and earlier; no public exploit code and no confirmed active exploitation (not in CISA KEV) have been identified at time of analysis, EPSS is low at 0.13% (3rd percentile), and CISA's SSVC rates the technical impact as total while noting exploitation and automability as none/no.

Local privilege escalation in Foxit PDF Editor (versions 14.0.7, 13.2.6 and 2026.2 and earlier) and Foxit PDF Reader (2026.2 and earlier) lets an attacker who already has low-privileged local code execution swap the staged update package between download and high-privilege extraction, yielding arbitrary code execution as SYSTEM/admin. The root cause is a time-of-check-to-time-of-use race (CWE-367) combined with insufficient file locking and missing integrity validation on the update package, consistent with the CVSS:3.1 vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8 High). There is no public exploit identified at time of analysis, no confirmed active exploitation (CISA KEV negative; SSVC Exploitation: none), and EPSS is only 0.13% (3rd percentile); the attacker must also win a timing race during an in-progress update cycle, consistent with SSVC Automatable: no, making this a genuine but non-urgent local privilege-escalation issue rather than a mass-exploitable remote flaw.

Heap-based out-of-bounds write in Foxit PDF Editor and Foxit PDF Reader occurs when the products decode JPEG2000 image data inside a PDF and fail to sufficiently validate the embedded image metadata, allowing the malformed metadata to drive writes past the end of an allocated heap buffer. An attacker can deliver the trigger inside an ordinary-looking PDF; because the CVSS vector is AV:L with UI:R and PR:N, the flaw is not remotely exploitable without interaction - the victim must open or render the crafted file, and exploitation then runs in that user's context with high confidentiality, integrity and availability impact (CVSS 7.8). No confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis, and this is a client-side file-parsing bug rather than a wormable or pre-auth network service issue.

Out-of-bounds write in the U3D/GIF texture decoding path of Foxit PDF Editor and Foxit PDF Reader allows a crafted PDF to corrupt process memory and potentially achieve remote code execution when the victim opens the file. Exploitation requires user interaction (the document must be opened and the malicious 3D model or GIF texture must actually be rendered) and is delivered through the local file/processing path (AV:L), while no application-level authentication is required (PR:N). No confirmed active exploitation and no public exploit code were identified at time of analysis; Foxit directs users to its security bulletins page for version guidance.

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.

Unauthenticated remote code execution is possible in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift because the product improperly deserializes untrusted data (CWE-502), allowing a remote attacker who can reach a vulnerable endpoint to execute arbitrary code with the privileges of the affected service. IBM rates the flaw CVSS 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), meaning no authentication, no user interaction and only network reachability are required, so any default-exposed FTM instance is at risk; the practical limiting factor is exposure, since FTM is specialized financial middleware normally deployed inside enterprise OpenShift clusters rather than on the public internet. Patch available per vendor advisory; no public exploit identified at time of analysis (no CISA KEV listing and no POC reporting in the available intelligence), though deserialization RCE is a well-understood and reliably weaponizable bug class once reachability exists.

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.

Authenticated remote code execution affects IBM Financial Transaction Manager (FTM) for Red Hat OpenShift, where a buffer overflow (out-of-bounds write) in an FTM component lets an attacker with valid low-privilege credentials submit crafted input and gain code execution in the containerized transaction platform. The vendor rates this 8.5 (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H), and our independent assessment concurs on high confidentiality and integrity impact while treating the scope change as unproven (S:U). Exploitation requires authentication (PR:L) and is not considered reliably repeatable on the first attempt (AC:H), and no public exploit identified at time of analysis. A vendor patch is available per IBM advisory node/7288641, so organizations running FTM on OpenShift should treat this as a priority patch action for their FTM estate.

Deserialization of untrusted data in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift lets an unauthenticated attacker who already has network reachability to the affected component from an adjacent network segment execute arbitrary code with high impact to confidentiality, integrity and availability (CVSS 3.1 base 8.8). The exposure prerequisite is meaningful: the flaw is reachable from a neighboring position such as a compromised pod, sidecar or host inside the same OpenShift cluster or VLAN, not directly from the public internet, and no authentication or user interaction is required once that path is reachable. At the time of analysis there is no public exploit code identified and no evidence of confirmed active exploitation (no CISA KEV listing); IBM has published a vendor fix via its support advisory, so the primary risk window is the interval between advisory release and patch deployment.

Remote code execution in IBM FTM for Red Hat OpenShift is possible when an authenticated attacker submits a manipulated quantity value to a vulnerable feature, causing an out-of-bounds write (CWE-787) that can lead to arbitrary code execution. The CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects a network-reachable, low-complexity flaw requiring low privileges and no user interaction, with full confidentiality, integrity, and availability impact. No public exploit code or confirmed active exploitation was identified in the provided intelligence at time of analysis; a vendor patch is available via IBM support node 7288641.

Authenticated remote code execution in IBM DataStage on Cloud Pak for Data 5.4.0.0 allows an attacker who holds a valid, low-privileged account to inject and execute arbitrary operating system commands through the product's command-handling logic, giving full compromise of confidentiality, integrity, and availability on the affected deployment. The flaw is rated CVSS v3.1 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), so it is network-reachable and requires no user interaction, but it is gated behind authentication - making stolen credentials or a malicious insider the realistic threat model rather than anonymous internet-wide exploitation. A vendor patch is available from IBM, and no public exploit code or confirmed active exploitation was identified at time of analysis.

Server-side request forgery in the GitHub Enterprise Server notebook viewer allows a remote attacker to direct requests to internal services listening on non-standard ports of the same appliance, because the viewer validated a user-supplied URL's scheme and host but not its port. Response bodies are not returned, but response timing acts as an oracle that can be used to extract instance secrets character by character; an extracted secret can then be used in a separate interaction with an internal service to obtain remote code execution on the appliance. All GitHub Enterprise Server versions 3.17 through 3.22 are affected; exploitation requires network access to the instance and is unauthenticated only when private mode is disabled, otherwise any authenticated user suffices, and no public exploit has been identified at time of analysis. Note that the independent assessment rates this as high difficulty (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H), since full impact depends on a multi-step timing-oracle extraction succeeding and a usable internal service being reachable for the follow-on RCE.

Arbitrary code execution in GNU Emacs 28.1 through 31.1 is triggered simply by opening a crafted file: an untrusted read-symbol-shorthands value supplied by that file reaches the Lisp reader's intern and unintern functions and is honored under Emacs's default configuration, so no special user settings or opt-ins are required. Exploitation is bounded by delivery - the attacker must get a victim to open the malicious file locally (AV:L with UI:R), and any resulting code executes with the privileges of the user running Emacs; no network service, listener, or authentication is involved. The issue carries a CVSS 4.0 score of 7.5 and is assessed under CVSS 3.1 as AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, with high confidentiality, integrity, and availability impact and no public exploit identified at time of analysis.