Unauthenticated remote code execution in the Improve SEO WordPress plugin (versions through 2.0.11) lets attackers upload executable PHP files by exploiting a file-upload routine that only validates MIME content type while writing files with the attacker-controlled extension into a web-accessible directory. Any visitor can drop a PHP webshell and execute arbitrary code on the server without credentials or user interaction. Publicly available exploit code exists (reported by WPScan), though the EPSS score is low (0.20%, 10th percentile) and it is not on CISA KEV.
Unauthenticated remote code execution in Puwell IP Camera firmware versions 2.x through 4.x lets remote attackers achieve root-level control by sending a crafted JSON payload to an undocumented DebugShell service listening on TCP port 34567. Because the service performs neither authentication nor input sanitization, any attacker with network reach to the port can pass operating-system commands directly to the device, resulting in full compromise. Reported by VulnCheck with publicly available exploit code exists; no public evidence of active in-the-wild exploitation (not in CISA KEV).
Remote code execution in Flowise before 3.1.3 arises because its Pyodide Python-code validator (validatePythonCodeForDataFrame) can be defeated with Unicode homoglyph identifiers, letting an attacker run arbitrary Python that escapes the Pyodide sandbox and executes OS commands on the Flowise host with the process's privileges. The affected CSV Agent and Airtable Agent nodes gate LLM-generated (and config-supplied) Python through an ASCII word-boundary regex blacklist, which Python's NFKC identifier normalization silently rewrites back into the forbidden dunders. There is no public exploit identified at time of analysis and it is not in CISA KEV, but the GitHub advisory documents a complete, reproducible bypass technique, so weaponization is straightforward; the vendor rates it 9.5 (CVSS 4.0).
Remote code execution in Flowise (npm flowise / flowise-components <= 3.1.2) lets an unauthenticated attacker who can query a chatflow built on the CSV Agent node coerce the backing LLM, via prompt injection, into returning a Python payload that slips past the regex blocklist validator and runs in an unsandboxed pyodide runtime, yielding arbitrary code execution as the Flowise service account. Trend Micro ZDI (Dre Cura, TrendAI Research) demonstrated eight distinct validator-bypass techniques and shipped a working proof of concept; this is scored CVSS 4.0 9.5 (CWE-94). Publicly available exploit code exists, but there is no CISA KEV listing or evidence of active exploitation at time of analysis.
Remote code execution in FlowiseAI Flowise before 3.1.3 lets an attacker execute arbitrary OS commands as the Flowise process by abusing the CSVAgent node, which interpolates an attacker-controlled base64 segment of the csvFile data URI directly into a Python template run by Pyodide. Because Pyodide's default js bridge exposes globalThis (including eval and dynamic import on Node.js), the injected code can break out of the Python string, call js.eval, import fs and child_process, and run host commands; the surrounding validators are never applied to this bootstrap template. A low-privileged workspace user plants the malicious node, after which any unauthenticated request to the public POST /api/v1/prediction/:id endpoint triggers the RCE. No public exploit is identified at time of analysis (no KEV, no POC signal in the provided data), but the fix is confirmed in version 3.1.3.
Remote code execution in Flowise (flowise and flowise-components <= 3.1.2) is possible through the CSVAgent node, which executes user-supplied Python in a pyodide runtime. A regex denylist blocks imports and dangerous builtins, but attackers bypass it entirely by calling the pre-imported pandas library's read_pickle() to deserialize an attacker-controlled base64 pickle, achieving arbitrary command execution. A detailed working proof-of-concept (pickle __reduce__ gadget plus a custom file-like reader class to feed the payload) is published in the vendor GHSA advisory; publicly available exploit code exists, but there is no public exploit identified as being used in the wild and it is not in CISA KEV.
Remote code execution as root in Flowise (npm packages flowise and flowise-components, versions 3.0.5 through 3.1.2) lets any authenticated user with a valid API key escape the NodeVM sandbox used by the custom-function feature and run arbitrary OS commands. The flaw stems from executeJavaScriptCode() merging caller-supplied nodeVMOptions over its secure defaults with a JavaScript spread, so an attacker can re-enable blocked builtins (child_process, fs) via require.builtin:["*"]. A detailed working exploit is published in the vendor's GHSA advisory, so publicly available exploit code exists; there is no CISA KEV listing, meaning no confirmed active exploitation at time of analysis.
Remote code execution in FlowiseAI Flowise 3.1.2 lets an authenticated user abuse the 'SQLite Record Manager' node's `additionalConfig` input to override the target database path and write an attacker-shaped SQLite file to any location on disk. Because the official Docker image runs as root, the file can be planted at /etc/chromium/exploit.conf, and a second Upsert operation that launches Puppeteer/Chromium sources that .conf file and executes an embedded reverse-shell payload, yielding full application compromise as root. No public exploit is identified at time of analysis beyond the detailed reproduction steps in the elttam advisory; the issue is patched in 3.1.3.
Command injection in GL.iNet GL-MT3000 router firmware (all versions through 4.4.5) allows unauthenticated remote attackers to execute arbitrary OS commands via the nas-web RPC wrapper's add_user function at /cgi-bin/glc. The vendor has confirmed the vulnerability exists following early disclosure, and a public proof-of-concept exploit is hosted on GitHub, materially lowering the barrier to exploitation. No patched firmware version is identified in the available data; the CVSS 4.0 score of 8.9 with E:P reflects unauthenticated network exploitability with a confirmed public exploit.
Remote code execution in kotaemon (Cinnamon) versions through 0.12.0 allows unauthenticated attackers to run arbitrary commands via the check_connection endpoint, which insecurely deserializes attacker-supplied YAML/JSON. By setting the __type__ field to subprocess.check_output with chosen arguments, an attacker instantiates arbitrary Python objects and executes OS commands with the application's process privileges. Publicly available exploit code exists (VulnCheck advisory and upstream issue), and the CVSS 4.0 base score is 9.3, though there is no public exploit identified as actively exploited.
Unauthenticated device takeover of Puwell IP Cameras (firmware 2.x through 4.x) is possible by sending protocol-conforming packets to TCP port 23456 and abusing the unvalidated Session field in the vendor's proprietary control protocol. Remote attackers with no credentials can view live video, drive pan/tilt motors, activate audio, and reboot the camera. Publicly available exploit code exists (disclosed by VulnCheck), and the CVSS 4.0 base score of 9.3 reflects network-reachable, no-interaction access with high confidentiality, integrity, and availability impact; there is no CISA KEV listing indicating active exploitation at this time.
Unauthenticated arbitrary file access in the Easy Integration for Dropbox WordPress plugin before 2.2.0 lets remote attackers list, download, and upload files across the site's connected Dropbox account and harvest the connected-account and administrator email addresses. Several file-management AJAX actions are registered for logged-out users but skip authorization checks (CWE-862), turning the plugin into an open proxy to the linked cloud storage. Publicly available exploit code exists and a vendor patch is released, though EPSS estimates exploitation probability at only 0.14% (4th percentile).
Unauthenticated arbitrary file read in OpenCode Studio before 2.4.4 lets remote attackers pull other users' intermediate audio, video, and subtitle artifacts directly from the GET /api/tmp/:tmpFile and GET /api/music/:fileName endpoints, and delete any rendered video via the unauthenticated DELETE /api/short-video/:videoId endpoint. Reported by VulnCheck and rated CVSS 4.0 9.3, the flaw exposes both confidentiality and integrity of user job data with no login required. Publicly available exploit code exists, though there is no public exploit identified as being used in active attacks.
Authenticated remote code execution in FlowiseAI Flowise (versions ≤ 3.1.2, npm packages flowise and flowise-components) arises from a vm2 JavaScript sandbox escape reachable through the AgentAsTool, ChatflowTool, and ExecuteFlow nodes, which still run untrusted code in the deprecated in-process vm2 sandbox (useSandbox: false). An attacker who can edit a chatflow injects code via an unvalidated baseURL URL-hash fragment and abuses moment's CVE-2022-24785 path-traversal (whose fix is bypassable inside the sandbox) to break out of vm2 and run arbitrary commands as the Flowise service account, fully compromising the host. A complete working exploit is published in the elttam/GitHub advisory, but the flaw is not in CISA KEV.
Authenticated remote code execution in FlowiseAI Flowise 3.1.2 and earlier lets any logged-in user escape the vm2 sandbox and run arbitrary OS commands on the host. The MySQL/Postgres/SQLite Record Manager and MySQL/Agent Memory nodes expose an unfiltered additionalConfig input passed directly into the TypeORM DataSource constructor, whose entities/subscribers/migrations options can load attacker-supplied JavaScript files. A full public reproduction (including a root reverse-shell payload) was published in the elttam advisory, and the vendor fixed it in 3.1.3.
Remote code execution in Perspective 5.0.0 exposes any network-reachable PolarsVirtualServer backend to arbitrary OS command execution via Python eval() injection. The server passes client-supplied expression strings to eval() with only __builtins__={} cleared - a well-known insufficient sandbox - enabling attackers to traverse Python's loaded class hierarchy to reach subprocess.Popen through crafted TableValidateExprReq or TableMakeViewReq protobuf messages. A public exploit is confirmed by VulnCheck, and five vulnerabilities were disclosed simultaneously in the researcher's blog post, suggesting a broader attack surface in this release. No KEV listing is identified, but the published PoC substantially lowers the exploitation barrier.
Property injection via the unauthenticated POST /api/v1/prediction/:id endpoint in Flowise allows remote unauthenticated attackers to overwrite session-critical fields (chatId, sessionId, chatHistory) and inject arbitrary values into the $flow.* template variable system of any public chatflow. Flowise versions up to and including 3.1.2 are affected; the fix was released in 3.1.3. Publicly available exploit code exists in the form of detailed curl-based proof-of-concept commands embedded in the public GitHub Security Advisory GHSA-6vh2-wg4h-4vwj, though active exploitation has not been confirmed by CISA KEV.
Remote unauthenticated file disclosure in perspective-dev/perspective 5.0.0 allows any network attacker to read arbitrary server-side files by injecting literal `../` path traversal segments into HTTP request URLs targeting the CWD static file handler. The sanitization routine strips only query-string parameters, leaving path-based traversal sequences intact and enabling escape from the configured asset root to retrieve sensitive files such as system credentials and application secrets. A publicly available proof-of-concept exploit exists per VulnCheck and researcher disclosure; combined with a wildcard Access-Control-Allow-Origin header on all responses, the vulnerability also enables cross-origin exfiltration through attacker-controlled web pages without any victim interaction.
Missing admin authorization on the embedding management API in Odysseus allows any authenticated non-admin user to overwrite or delete the server-wide embedding backend configuration, redirecting all subsequent embedding operations - including chat messages, RAG queries, memory entries, and vault text - in plaintext to an attacker-controlled URL. All deployments running any version prior to commit bf325f6 are affected. A public exploit and detailed write-up are available, and the CVSS 4.0 score of 8.7 (PR:L) reflects the low barrier to exploitation for any account holder.
Flowise's patch for CVE-2025-8943 is fully bypassed in versions up to and including 3.1.2, allowing unauthenticated remote code execution on default deployments via the npm_config_yes environment variable. The prior mitigation blocked the -y and --yes flags on npx and denied four specific environment variable names by exact string match, but npm natively reads its configuration from any npm_config_* prefixed variable, making npm_config_yes=true semantically equivalent to --yes. Any attacker who can submit a Custom MCP stdio server configuration - which requires no authentication on default Flowise deployments - can force npx to auto-install and execute an arbitrary package as the Flowise server process. No public exploit code has been identified at time of analysis, though the bypass technique is fully documented in the public GHSA advisory GHSA-xc48-889x-5qmw, making independent weaponization trivial.
Stored cross-site scripting in Open WebUI 0.10.0-0.10.2 allows any authenticated user to craft a math block that causes a KaTeX RangeError (stack overflow from deeply nested braces), forcing the KatexRenderer.svelte error fallback to inject unescaped HTML directly into the DOM via Svelte's `{@html}` directive. Any user who subsequently views the message - including administrators - executes attacker-controlled JavaScript on the Open WebUI origin, enabling session token theft from localStorage and full account takeover. A detailed, weaponizable proof-of-concept is publicly documented in the vendor GHSA advisory, including demonstrated administrator session exfiltration; no CISA KEV listing has been identified at time of analysis.
Unauthenticated remote denial-of-service in Perspective 5.0.0 crashes the server process by exploiting missing field validation in the VirtualServer protocol dispatcher. Attackers send syntactically valid but semantically incomplete protobuf messages - such as ViewToArrowReq without a viewport or MakeTableReq without a data field - triggering Rust unwrap() calls on None values at nine distinct code sites, each causing an immediate SIGABRT process abort. No public exploit is confirmed actively exploited (no CISA KEV listing), but a publicly available proof-of-concept exists via a researcher blog post, and the attack requires no authentication against a network-accessible endpoint.
Remote code execution in LAMP Rapid Development Platform (dromara lamp-cloud) through version 5.6.2 allows low-privileged authenticated attackers to inject arbitrary Groovy code into message template script fields processed by the GlueFactory component, resulting in OS command execution on the backend server with the privileges of the Java process. The GlueFactory compiled and ran these scripts via GroovyClassLoader with no sandboxing, AST restrictions, or class whitelisting in place. A publicly available exploit exists via GitHub issue #408, and CVSS 4.0 rates this 8.7 with full confidentiality, integrity, and availability impact on the vulnerable system.
Unauthenticated SSRF with non-blind response reflection and OAuth2 secret exfiltration in Flowise affects all versions through 3.1.2. The OAuth2 token refresh endpoint is intentionally whitelisted from authentication but issues server-side HTTP POST requests to a credential-stored URL without SSRF controls, allowing any caller who knows a credential UUID to redirect the server to an attacker-controlled host and receive the full response body. A working proof-of-concept was confirmed against the flowiseai/flowise:latest container, with the exploit also exfiltrating client_secret and refresh_token values in the outbound POST body to the attacker server. No public exploit is independently confirmed as widespread, but the PoC is detailed and functional.
Cross-tenant billing manipulation in Flowise's enterprise API allows any authenticated user to perform unauthorized Stripe subscription operations against other organizations by supplying an arbitrary victim subscriptionId to the /update-subscription-plan and /update-additional-seats endpoints. All Flowise enterprise deployments running versions prior to 3.1.3 are affected, with impact including unauthorized plan downgrades, seat-count inflation (inflating victim billing), and service disruption across tenants. No public exploit code or CISA KEV listing exists at time of analysis, but the vulnerability is mechanically straightforward given knowledge of a target organization's Stripe subscription identifier.
Broken access control in Flowise's GET /api/v1/upsert-history API endpoint exposes the entire server-wide upsert history - exceeding 100MB per response - to any authenticated user, leaking sensitive infrastructure credentials including Qdrant server URLs, collection names, and vector pipeline configuration across all tenants and workspaces. The vulnerability is confirmed in flowise <= 3.1.2 and publicly documented in GHSA-fr6g-7cq8-fg82 with a working curl-based proof-of-concept, meaning any account holder on a multi-tenant deployment can harvest cross-tenant vector store configuration for reconnaissance or targeted follow-on attacks against exposed backends. Vendor-released patch flowise@3.1.3 is confirmed available and addresses missing workspace-scoping enforcement across multiple API controllers.
OAuth token exchange in Open WebUI 0.8.0-0.10.x enables full, silent account takeover when ENABLE_OAUTH_TOKEN_EXCHANGE=True because the endpoint accepted provider access tokens minted for any OAuth client without verifying the issuing client identity. The endpoint validated tokens exclusively via the provider's userinfo endpoint, which confirms token validity but never returns the client a token was issued to, allowing an attacker who captures a victim's token from any co-registered application to exchange it for a valid Open WebUI session - including administrator sessions with no role gating. A proof-of-concept is confirmed by the upstream advisory; no active exploitation is recorded in CISA KEV, and the CVSS 8.1 score reflects high confidentiality and integrity impact tempered by a required victim interaction step.
Unauthorized permanent deletion of chat history in Open WebUI 0.10.x allows any authenticated write-collaborator on a shared folder to destroy the folder owner's chats, messages, and entire subfolder subtree via the DELETE /api/v1/folders/{id} endpoint. The flaw stems from a split authorization check that enforced ownership for root folders but accepted write-grant access for subfolders, while the cascade deletion itself ran under the owner's identity - meaning the collaborator's lower-privilege check granted them the owner's destructive reach. No public exploit has been identified at time of analysis, and exploitation requires a non-default configuration, but the impact is irreversible data destruction with no recovery path.
PHP code injection in the Create Block Theme WordPress plugin (before 2.10.0) enables a multisite subsite administrator to execute arbitrary server-side code by exploiting insufficient output escaping when the plugin writes user-supplied text into generated PHP pattern files. The vulnerability leverages a capability boundary mismatch unique to WordPress multisite: subsite admins hold the capability gating pattern file generation but are denied the capability normally required for PHP file editing, creating an unintended privilege escalation path to full remote code execution. A public proof-of-concept is available via WPScan, though EPSS sits at 0.15% (5th percentile), indicating exploitation is currently targeted rather than widespread.
Command injection in H3C NX15 firmware V100R017 permits network-accessible, authenticated attackers to execute arbitrary operating system commands via the /api/esps API endpoint by manipulating the reload.reload_config function parameter. The vulnerability, classified as CWE-77 (Command Injection), carries a CVSS 4.0 score of 7.3 and affects this specific H3C networking device firmware version. A public proof-of-concept exploit - titled 'service_add_root_rce' - has been published to GitHub, indicating root-level code execution is achievable; no vendor patch has been identified at time of analysis.
Command injection in H3C NX15 firmware V100R017 allows authenticated remote attackers with high privileges to execute arbitrary OS commands by supplying a maliciously crafted value in the `esps.apcm.version` argument of a DELETE request to the `/api/esps` API endpoint. The exploit has been publicly disclosed on GitHub, raising the risk for exposed devices with reachable management interfaces. No active CISA KEV listing exists, but the publicly available proof-of-concept lowers the bar for motivated attackers who already hold administrative credentials.
Command injection in H3C NX15 firmware V100R017 allows authenticated remote attackers to execute arbitrary OS commands via the `workMode` parameter in the `/api/esps` IPv6 WAN configuration endpoint, likely yielding root-level device takeover based on the published PoC repository name. A public proof-of-concept exploit is available on GitHub (E:P confirmed in the CVSS 4.0 vector), significantly lowering the skill bar for anyone who already holds administrative credentials. No vendor patch has been identified at time of analysis, and no CISA KEV listing exists, indicating no confirmed widespread active exploitation.
Command injection in H3C NX15 V100R017 allows authenticated remote attackers to execute arbitrary OS commands as root via the /api/esps management endpoint. The vulnerability exists in the Add function's handling of the esps.filter.url parameter, which is passed unsanitized to a system command (CWE-77). A public proof-of-concept exploit demonstrating root-level remote code execution is available on GitHub, elevating real-world risk beyond the theoretical - though exploitation requires high-privilege credentials, and no confirmed active exploitation (CISA KEV) has been identified at time of analysis.
Server-Side Request Forgery in Open WebUI versions 0.9.6 through 0.10.x allows any authenticated user to exfiltrate HTTP responses from internal network services - including cloud instance metadata endpoints and container-local APIs - by submitting a crafted URL that triggers unvalidated sub-resource requests through the Playwright browser loader. The `SafePlaywrightURLLoader` component validated only the top-level navigation request; all subsequent requests issued by page JavaScript bypassed the address check entirely, and the resulting DOM content was returned directly to the requester via the normal web-search or RAG ingestion pipeline. No public exploit or CISA KEV listing is confirmed at time of analysis, though a proof-of-concept was reported against version 0.10.2; the vulnerability is limited to the non-default Playwright loader configuration.
Command injection in GL.iNet AX1800 router firmware up to version 4.8.3 allows a low-privileged authenticated remote attacker to execute arbitrary OS commands via the `remove_rule` RPC endpoint. The vulnerable parameter `args.id` in `/usr/share/gl-ngx/oui-rpc.lua` is passed unsanitized to a shell command, enabling full device takeover. No public KEV listing exists, but a proof-of-concept exploit is publicly available on GitHub, meaningfully lowering the barrier to exploitation.
Cross-workspace OAuth2 credential isolation failure in Flowise prior to version 3.1.3 enables two distinct attack classes: authenticated users can initiate OAuth2 flows against credentials owned by other workspaces, and - more critically - unauthenticated attackers can forge OAuth2 callbacks to overwrite tokens or trigger token refreshes for any credential system-wide by exploiting a whitelist that bypasses all authentication on the /callback and /refresh endpoints. The root cause is that all three OAuth2 handlers query the Credential table by credential ID alone, omitting the workspaceId isolation enforced elsewhere in the codebase. No public exploit has been identified at time of analysis, and the issue is fixed in Flowise 3.1.3.
SSRF protection bypass in Flowise (npm/flowise ≤ v3.1.2) allows complete circumvention of all IPv4 CIDR deny rules via IPv4-mapped IPv6 addresses, rendering the SSRF fix introduced in v3.0.13 for CVE-2026-31829 entirely ineffective. An attacker who controls DNS for a hostname referenced in a Flowise chatflow HTTP component can set a AAAA record to `::ffff:169.254.169.254` or any RFC1918 target; Flowise resolves the address, the `isDeniedIP()` kind mismatch silently skips all IPv4 CIDR checks, and the request reaches cloud IMDS endpoints or internal services. A publicly available proof-of-concept script (poc_ssrf_bypass.js) confirms the bypass against ipaddr.js@2.2.0; no CISA KEV listing has been identified at time of analysis.
Missing authorization on the `/api/v1/files` endpoint in Flowise allows any authenticated API key holder within an organization to enumerate and permanently delete files belonging to other workspaces. The route is guarded only by a plan-level feature gate (`feat:files`) with no `checkPermission` enforcement, meaning an API key scoped to an unrelated permission such as `tools:view` has full read and delete access to organization-wide file storage. Publicly available exploit code exists in the form of a fully reproducible curl-based proof-of-concept included in the GitHub Security Advisory GHSA-wp74-f5hh-5f3r. The fix in version 3.1.3 disables the endpoint entirely rather than adding proper authorization.
Denial of service in Perspective 5.0.0 allows low-privileged remote attackers to render the server permanently unresponsive by submitting a crafted TableMakeViewReq message containing expression columns with unbounded for or while loop constructs. Because the Tornado IOLoop evaluates the expression once per table row with no iteration cap, deadline enforcement, or cancellation mechanism, a single malicious request stalls the entire event loop and blocks all connected clients. A publicly available proof-of-concept exploit exists, and the vulnerability is part of a batch of five CVEs disclosed against this version.
Cross-workspace IDOR in Flowise's OpenAI Assistants Vector Store API allows authenticated users of one workspace to access, use, and manipulate another workspace's stored OpenAI credentials. Flowise versions up to and including 3.1.2 pass the client-supplied `credential` query parameter directly to a database lookup (`findOneBy({ id: credentialId })`) with no ownership check against the caller's `workspaceId`, violating the multi-tenant isolation guarantee. An attacker with a valid Flowise account and `assistants:*` permissions can cause direct financial harm to victim workspaces via unauthorized OpenAI API billing and can read, modify, or delete the victim's vector stores and files. No public exploit code or CISA KEV listing is identified at time of analysis.
Flowise's DELETE /api/v1/chatflows/:id endpoint fails to enforce RBAC boundaries between flow resource types, allowing authenticated workspace members to delete flows they are not permitted to manage. Users holding only agentflows:delete can permanently destroy CHATFLOW resources, and users holding only chatflows:delete can destroy AGENTFLOW resources, in the same workspace. All Flowise installations prior to 3.1.3 are affected; no public standalone exploit tool exists, but the GHSA advisory (GHSA-p5w8-m249-4r4v) supplies a verbatim curl reproduction demonstrating the issue with minimal effort.
Server-side request forgery in Open WebUI (pip/open-webui versions 0.9.0 through 0.10.x) allows any authenticated low-privilege user to reach internal cloud metadata endpoints, loopback-bound admin surfaces, and VPC-internal APIs by encoding IPv4 addresses inside the NAT64 well-known prefix `64:ff9b::/96`. The SSRF filter evaluates only whether the literal IPv6 address is globally routable - which NAT64 addresses are, by design - without unwrapping the embedded IPv4 destination before deciding to allow or block the request. Full response bodies, including AWS IAM role credentials from the instance metadata service, are returned directly to the caller. A proof-of-concept exists confirming exploitation against the unmodified v0.10.2 code path; no active exploitation in the wild has been confirmed by CISA KEV at time of analysis.
Denial of service in FasterXML jackson-core's non-blocking (async) JSON parser allows unauthenticated network attackers to exhaust JVM heap and CPU by submitting JSON containing arbitrarily long number tokens that bypass the maxNumberLength constraint. Affected deployments are those using the async parser API - particularly reactive frameworks such as Spring WebFlux - running com.fasterxml.jackson.core:jackson-core 2.15.0-2.18.5 or 2.19.0-2.21.0, or tools.jackson.core:jackson-core 3.0.0-3.0.x. Publicly available exploit code exists (PoC JUnit test published in GHSA-72hv-8253-57qq); the vulnerability is not listed in the CISA KEV catalog at time of analysis.
SQL injection in the Database for Contact Form 7, WPforms, Elementor forms WordPress plugin (versions before 1.5.5) exposes the underlying WordPress database to unauthorized read access by any user holding a specific capability that defaults to administrators but can be explicitly delegated to lower-privileged roles. The CVSS scope-change rating (S:C/C:H) reflects that a successful injection reaches beyond the plugin itself into the shared WordPress database, potentially exposing all stored form submissions, user data, and other sensitive records. Publicly available exploit code exists per WPScan; however, EPSS at 0.16% (5th percentile) and absence from CISA KEV indicate no confirmed widespread active exploitation at time of analysis.
Stored cross-site scripting in the Brizy WordPress plugin before 2.8.19 allows any authenticated user with Contributor role or above to plant persistent XSS payloads via unsanitized featured-image focal-point coordinates submitted through an AJAX action. When a higher-privileged user (Editor or Administrator) later opens the affected post for review, the injected script executes silently in their browser session, enabling session hijacking or unauthorized administrative actions. A publicly available exploit exists per WPScan; the vendor has released a fix in version 2.8.19.
Stored Cross-Site Scripting in the PowerPress Podcasting plugin by Blubrry (WordPress) before version 11.16.11 allows any authenticated user holding the Contributor role to inject and persist arbitrary JavaScript via unsanitized Podcast Episode settings fields. The injected payload executes in the browsers of higher-privileged users - including editors and administrators - who view the affected content, enabling session hijacking, credential theft, or unauthorized administrative actions. A publicly available proof-of-concept exists per WPScan; no active exploitation is confirmed by CISA KEV, and the EPSS probability stands at a low 0.15%, suggesting opportunistic rather than widespread exploitation at this time.
Server-Side Request Forgery in the Visualizer WordPress plugin before 4.0.6 allows any authenticated Contributor-level user to pivot through the WordPress server and reach link-local instance-metadata endpoints (e.g., 169.254.169.254), returning the full response to the attacker. On cloud-hosted WordPress deployments (AWS, GCP, Azure), this enables non-blind exfiltration of IAM credentials and other instance metadata, potentially leading to full cloud account compromise. A publicly available proof-of-concept exploit exists; exploitation probability is currently low (EPSS 0.14%, 3rd percentile) but the concrete cloud-credential impact makes this a material priority for cloud-hosted sites.
Session fixation in Ghost Admin (v2.2.0-v6.54.0) allows an attacker who can plant a known session identifier in a victim's browser - via a secondary vulnerability on the same domain - to hijack an authenticated Ghost Admin session after the victim logs in. The root cause is that Ghost Admin's login flow did not call session regeneration, leaving the pre-login session ID valid post-authentication. Exploitation is chained and non-trivial, but the upstream fix (v6.54.1) is confirmed and straightforward to apply. No public exploit code and no CISA KEV listing identified at time of analysis.
Path traversal in Ghost CMS theme upload (CWE-22) allows an authenticated staff-level user to write arbitrary files outside the designated uploads directory, potentially altering the behavior of the entire Ghost installation. Affected versions span v0.10.0 through v6.54.0 of the npm/ghost package - a wide range covering essentially all modern deployments. No public exploit code or CISA KEV listing exists at time of analysis; however, the CVSS Scope:Changed metric reflects that a successful write can affect components beyond the theme storage boundary, elevating the real-world impact above the moderate base score suggests.
Catastrophic regex backtracking in Open WebUI 0.9.6-0.10.x allows any authenticated user to permanently stall a Uvicorn event-loop worker by supplying a crafted pattern to the built-in knowledge-search tool. The vulnerable `grep_knowledge_files` tool compiles attacker-supplied patterns with Python's unbounded `re` engine against attacker-uploaded file content, with no timeout anywhere on the execution path; a 30-character subject string measured at 74 seconds of CPU and a 40-character string extrapolates to roughly one day. No CISA KEV listing exists, but a complete proof-of-concept procedure is published in the GitHub security advisory GHSA-2f54-p244-32q6, making exploitation straightforward for any credential holder.