Unauthenticated arbitrary file upload in the Web to Print Online Designer WordPress plugin (versions 1.7.0 through before 2.15.0) allows any remote visitor to obtain the token that protects the plugin's upload handler and then push arbitrary files, including PHP scripts, into a web-reachable location - resulting in remote code execution with total confidentiality, integrity, and availability impact (CVSS 9.8). No authentication, user interaction, or non-default configuration is required; the plugin simply fails to validate file type or extension and discloses the upload token to anonymous requesters. Publicly available exploit code exists, so weaponization against exposed installations is a realistic short-term risk, although the vendor (WPScan-reported) has shipped a fix in 2.15.0 and EPSS currently rates near-term exploitation probability low at 0.14% (4th percentile), tracking the plugin's comparatively small install base.
Stored cross-site scripting and open redirect in Warpgate's SSO endpoints (versions prior to 0.25.5) allow an unauthenticated remote attacker to inject markup and JavaScript into the authenticated Warpgate origin. The attacker stores an arbitrary 'next' parameter via /@warpgate/api/sso/providers/:name/start, which the return handler later reflects without HTML escaping; the victim must follow the crafted link and complete an SSO login before the payload executes. Successful exploitation grants access to session data and user-level APIs, escalating to administrator APIs when the victim is a Warpgate administrator, and the same unvalidated value enables an open redirect via the GET /@warpgate/api/sso/return path. The vendor rates this 9.3 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:N), reflecting network reachability with no attacker privileges but mandatory victim interaction; no public exploit code or confirmed active exploitation was identified at time of analysis.
Local privilege escalation in the Moore Threads MTT S80 Driver Package 340.150 allows a low-privileged local user to abuse an improperly secured IOCTL handler and gain high-impact control over the system. The flaw resides in the Windows kernel-mode driver mtdispkm64.sys, specifically function sub_140006F0C, and is classified as CWE-269 improper privilege management; successful abuse yields high confidentiality, integrity and availability impact on both the vulnerable component and the subsequently compromised host. Exploitation requires an existing local foothold on a Windows machine with this specific GPU driver installed, with low privileges and no user interaction needed (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H; vendor-published CVSS 4.0 score 9.3). No public exploit code has been identified at time of analysis, and no CISA KEV listing exists, but the low attack complexity and the absence of a vendor patch make the flaw attractive to local attackers already present on a host.
Cache poisoning in the Open VSX registry allows an unauthenticated remote client to inject attacker-chosen download, signature, and public-key URLs into per-extension metadata that is then served to every other client, so downstream VS Code-compatible editors fetch and install an attacker-supplied VSIX. Exploitation requires the deployment to be reachable directly by clients, or fronted by a reverse proxy that relays rather than overwrites the client's X-Forwarded-Host/X-Forwarded-Proto/X-Forwarded-Prefix headers, with ovsx.server.url left unset and the attacker's source address treated as a trusted proxy (by default only loopback and private ranges are). Because the VSIX download URL, its signature URL and the verifying public key URL are all derived from the same base URL, extension signing provides no protection; poisoned entries persist for the cache lifetime (one hour by default) and spread cluster-wide when ovsx.redis.enabled is set. No public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, but the prerequisite is a common default deployment shape, so the risk is real and high rather than theoretical.
Joplin Server instances prior to 3.7.2 expose an SSO login-code redemption endpoint (GET /api/login_with_code/:id) that is not protected by the limiterLoginBruteForce rate limiter, allowing an unauthenticated remote attacker to make unlimited guesses against a nine-digit authentication code whose lifetime is only ten minutes; a single correct guess yields a full session token granting read and write access to the victim's notes, notebooks, and account settings. Successful exploitation is constrained by timing and throughput: the attacker must target a user during an active SSO login, know the login id, and search roughly 10^9 possible codes inside a 600-second window (about 1.6 million requests per second for reliable coverage), so the flaw is only practical against servers reachable at high request rates. The issue is confirmed by the vendor fix diff (CWE-307, missing limiterLoginBruteForce) and is fixed in 3.7.2; no public exploit code was identified at time of analysis and the flaw is not listed in CISA KEV.
Command injection in MaxKB before 2.10.5-lts allows unauthenticated remote attackers to execute arbitrary shell commands when an assistant is configured with a tool, MCP tool, skill, or sub-application. Untrusted chat messages or ingested documents can coerce the LLM into invoking the un-gated `execute` shell tool, which lacks human approval and is exposed by the SandboxShellBackend. Both source deployments with MAXKB_SANDBOX disabled and the official root container's vulnerable gosu wrapper permit command execution outside the intended sandbox; no public exploit code or confirmed active exploitation was identified at time of analysis. A vendor patch is available in version 2.10.5-lts.
Authenticated users of the Ajenti server admin panel - at any privilege level - can achieve root-level code execution and full host compromise on installations below version 2.2.16 by invoking the task API endpoint /api/core/tasks/start, which enforces no plugin-management authorization before enqueuing InstallPlugin, UnInstallPlugin, or UpgradeAll tasks whose package specifications are built from unvalidated name and version fields and then executed by pip under root. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, 9.9) confirms a network-reachable, low-privilege, no-interaction attack that escapes the panel's own security scope by gaining root on the underlying host, and exploitation works against default configurations since the missing permission check is the pre-2.2.16 default state. No public exploit code has been identified at time of analysis, and the flaw is not confirmed as actively exploited (no CISA KEV entry); nonetheless it is a genuine top-priority issue because a valid low-privileged account converts directly into root on the server.
Authentication bypass in Mailu 2.0 through 2024.06.55 and Mailu helm-charts before 2.7.3 allows unauthenticated remote attackers to spoof the trusted proxy identity via a client-controlled X-Forwarded-By header, bypassing header-based proxy authentication. This affects only deployments with PROXY_AUTH_WHITELIST configured and REAL_IP_HEADER unset; default configurations are not vulnerable. The vendor has released fixes in Mailu 2024.06.55 and helm-charts 2.7.3, and no public exploit has been identified at time of analysis.
Arbitrary command injection on Windows in the Perl distribution Email::Sender (Email::Sender::Transport::Sendmail versions before 2.602) lets an attacker who controls a From, To, or Cc header address execute commands as the sending process, because on MSWin32 the envelope sender and recipients are concatenated into a single command string that Perl's open() hands to a shell. The flaw is strictly Windows-only: on every other platform the transport uses open()'s list form and passes arguments directly to sendmail with no shell involved, so the injection path does not exist there, and exploitation additionally requires that the application use the sendmail transport rather than the SMTP transport and that the caller supply no explicit envelope (letting Email::Sender::Simple derive addresses from headers). The vendor CVSS of 9.8 (AV:N/AC:L/PR:N/UI:N) overstates real-world risk given that hard platform gate; our assessment uses CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H, EPSS is low at 0.22% (13th percentile), SSVC records no observed exploitation with automatable attack and total technical impact, and no public exploit code was identified at time of analysis, though a vendor patch (2.602) and an upstream commit are public.
Unauthenticated remote code execution affects ZLMediaKit builds based on commit 9fd5152, where broken access control in the HTTP API allows a remote attacker to overwrite the ffmpeg.snap snapshot configuration parameter with arbitrary shell commands through the setServerConfig endpoint, which are then executed with the privileges of the ZLMediaKit process when getSnap is invoked. Per the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8), no credentials or user interaction are required - the only practical prerequisite is network reachability to the exposed HTTP API service. Exploitation has not been confirmed as active (not in CISA KEV) and no public exploit code was identified at time of analysis; the EPSS score is low at 0.21% (11th percentile), but the unauthenticated, full-compromise nature of the flaw makes it a top-priority fix for any internet-facing or hostile-network-reachable deployment.
Remote code execution in Univer v1.0.0-alpha.2 allows unauthenticated network attackers to execute arbitrary code via a crafted payload sent to the RemoteRegisterFunctionService endpoint (/remote/remote-register-function.service.ts). The vulnerability is rated CVSS 9.8 (critical) and requires the remote function-registration service to be reachable; only this pre-release alpha build is named as affected. No public exploit code or confirmed active exploitation has been identified, and EPSS indicates a low likelihood of exploitation (0.21%).
Remote code execution affects Univer v1.0.0-alpha.2 through its Uniscript feature: the UniscriptExecutionService.execute() function in /services/script-execution.service.ts evaluates attacker-influenced script content (CWE-94), allowing arbitrary code execution with the privileges of the hosting process. The input CVSS vector rates this 9.8 (AV:N/AC:L/PR:N/UI:N), but the authoritative assessment refines the privilege requirement to PR:L, meaning an attacker generally needs a delivery channel - and for most deployments at least application-level access - to place a crafted script into the execution service, and the exposure is further limited to deployments that actually enable Uniscript on this early alpha build. No confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis; EPSS is 0.21% (11th percentile), indicating low modeled near-term exploitation likelihood.
Arbitrary code execution in the npm front-matter parser gray-matter is reachable through its built-in JavaScript engine, which evaluates front matter with eval() whenever the document declares a js/javascript language fence. Any application that passes attacker-influenced markdown or front-matter text into gray-matter's parse call can be induced to run attacker-supplied JavaScript in the Node.js process - the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) rates this as unauthenticated remote code execution, with the practical caveat from our assessment that the attack surface is gated by whether the host application exposes gray-matter parsing to untrusted content. Affected coverage is broad rather than version-specific: the reporter states all versions are impacted and verified 4.0.3, while there is no CISA KEV entry, no confirmed public exploit code, and a low EPSS of 0.17% (7th percentile) indicating limited observed exploitation pressure at time of analysis.
SQL injection in NocoBase v2.1.21 lets an attacker reach the SQL handling path behind the checkSQL function and submit crafted SQL statements that disclose sensitive database contents. Publicly available exploit code exists (SSVC Exploitation: poc, Automatable: yes, Technical Impact: total), though the EPSS score is only 0.15% (5th percentile) and CVE-2026-88402 is not confirmed actively exploited (CISA KEV). The published CVSS vector is 9.8 with PR:N/UI:N, but independent assessment rates the vector lower (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:L) and concludes that the SQL data-source/SQL-collection feature is normally an authenticated administrative capability, so the realistic limiting factor is a valid account with permission to define or run SQL sources rather than an unauthenticated remote attacker; this discrepancy should be confirmed with the vendor.
Unauthenticated remote code execution risk in Apache MINA 2.0.X through 2.0.30 and 2.1.X through 2.1.14 arises because those maintenance branches never received the resolveProxyClass() override that closed CVE-2026-47065. An attacker who can reach an application that uses MINA's ObjectSerializationDecoder and relies on acceptMatchers can wrap a malicious serialized object in java.lang.reflect.Proxy to bypass the allow-list, and, if a suitable gadget chain is present, execute code. No public exploit identified at time of analysis; upgrades within 2.0.X or 2.1.X do not remediate, so affected users must move to the 2.2.X line at 2.2.8 or later.
Command injection in the Netcore NBR200V2 router (firmware 1.3.241127.071246) lets remote attackers execute arbitrary shell commands on the device through the /www/cgi-bin/network_tools CGI diagnostic endpoint by supplying crafted param, key, or val arguments. The vendor CVSS 4.0 vector (9.3) rates this remote, unauthenticated, and requiring no user interaction, and publicly available exploit code exists; the vendor was contacted early but never responded, so no fix is available. Any deployment that exposes the router's web management interface to an untrusted network is at risk of full device compromise.
Authenticated OpenStack project members can inject arbitrary HAProxy configuration directives - and from there achieve code execution on Amphora load-balancer instances - by embedding newline characters in the tls_ciphers field of a TLS-enabled listener or pool in OpenStack Octavia before 18.0.1. The value is written verbatim into the HAProxy configuration generated on the amphora, so a crafted cipher string breaks out of the intended directive and appends attacker-controlled configuration (CWE-94). Only deployments using the Amphora provider driver are affected; no public exploit code was identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV), though the assessed CVSS:3.1 vector is AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, reflecting high confidentiality, integrity, and availability impact that extends beyond the vulnerable component to the amphora instance itself.
Authenticated OpenStack project members who own a load balancer can inject arbitrary HAProxy directives into the amphora configuration produced by Octavia before 18.0.1, because the Amphora provider driver fails to reject control characters in L7 policy redirect_url and redirect_prefix fields. The RFC 3986 URL validator percent-encodes control characters before validating, so newline-bearing payloads pass structural checks, but the raw value is stored and written verbatim into the generated HAProxy config - yielding code/directive injection with high confidentiality, integrity, and availability impact on the amphora and the traffic it proxies. Exploitation requires valid tenant credentials plus ownership of a load balancer (CVSS PR:L, unauthenticated paths do not exist), and only Amphora-provider deployments are affected; OVN and other Octavia providers are explicitly immune. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, though the assessment rates it a genuine high-priority problem rather than an inflated score.
Stack-based buffer overflow in Fluent Bit's out_forward Secure Forward plugin (versions 0.11.0 through releases prior to 5.0.8) lets an attacker who controls or can impersonate the configured forwarding destination overwrite stack memory while Fluent Bit processes the handshake PONG response. The vulnerable path is only reachable when the out_forward output plugin is configured in Secure Forward mode with Shared_Key or Empty_Shared_Key - not the default output configuration - and the CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N) plus the independent CVSS 3.1 assessment (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) both characterize it as an unauthenticated network attack that depends on specific deployment preconditions. Impact ranges from reliable process termination on builds compiled with a stack canary to full remote code execution as the Fluent Bit process user on builds lacking canary protection or where a memory-disclosure primitive exists; the opt-in --supervisor mode with fork-only respawns further weakens hardened builds by preserving canary and address layout across restarts. No public exploit code has been identified at time of analysis, and the issue is fixed in version 5.0.8.
A heap-based buffer overflow (CWE-122) in the IOCTL handler (sub_140001000) of mtdispkm64.sys, the kernel-mode display driver shipped with the Moore Threads MTT S80 GPU driver package up to version 340.150, lets a local low-privileged user who can open a handle to the driver's device object supply a malformed IOCTL request and corrupt kernel pool memory, potentially achieving elevation to SYSTEM. The flaw is not remotely reachable (AV:L, PR:L per the assessed CVSS:3.1 vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, rated 9.3), and exploitation is confined to Windows hosts that actually have this niche GPU driver installed and loaded. There is no vendor patch because Moore Threads did not respond to the disclosure, and no public exploit code has been identified at time of analysis.
Authenticated workspace members on MaxKB deployments prior to 2.10.5-lts can escalate to root-level command execution by abusing how the AWS Bedrock provider stores credentials. Because MaxKB writes user-supplied access_key_id and secret_access_key values into /root/.aws/credentials without proper parsing, an attacker can smuggle control characters and a forged [profile] block containing a credential_process directive, then trigger a later model-validation request that makes botocore run an attacker-controlled command as root. Exploitation requires valid workspace credentials, the reachable Bedrock provider configuration path, and a two-step inject-then-trigger sequence on a service running with root privileges; vendor-released patch 2.10.5-lts is available and no public exploit identified at time of analysis.
Server-side request forgery in CuteNews 2.1.2 (core/modules/media.php, the Media Manager 'Upload by URL' handler upload_from_inet) lets an attacker submit a crafted URL that the PHP backend fetches on the attacker's behalf, exposing internal-only services and cloud instance metadata endpoints to server-side retrieval. Our independent assessment scores this as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N rather than the published 9.1, because the Media Manager panel is a post-login feature, so a valid account is the practical prerequisite even though the published vector lists PR:N; realized impact further depends on internal network reachability and on whether the fetched response is returned or stored where the attacker can read it (blind SSRF only allows probing). No public exploit code or KEV-listed active exploitation was identified at time of analysis, and EPSS is very low at 0.15% (5th percentile), so this is a high-CVSS-but-modest-real-risk issue.
Logout on the Apache Airflow Core API revokes only the `_token` browser session cookie and silently ignores a credential presented as an `Authorization: Bearer` header, so an API client that logs out with a bearer token receives the endpoint's normal logout response while its JWT is never invalidated and remains usable until natural expiry (24 hours by default, configurable). Only deployments running Airflow 3.0.0 through 3.3.2 whose API clients authenticate with bearer tokens rather than the browser cookie are affected, and the hard prerequisite is that the attacker already holds a copy of that valid token - obtaining it is explicitly outside the scope of this issue, and no privileges beyond the victim's own are gained. No public exploit code has been identified at time of analysis; the vendor's CVSS 9.1 substantially overstates the exposure, and our independent assessment scores it 4.8 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N) because the flaw only extends a session the attacker could already use, rather than granting new access.