Remote code execution in Zimbra Collaboration (ZCS) before 10.1.20 enables unauthenticated network attackers to execute arbitrary operating system commands as the Zimbra service account by sending specially crafted SMTP requests that trigger unsanitized input processing in the SNMP notification subsystem. Exploitation is conditional on the non-default zimbra-snmp package being installed and SNMP notifications being enabled, which meaningfully narrows the exposed population despite the CVSS 8.9 score. No public exploit code and no CISA KEV listing were identified at time of analysis.
Full site compromise in the Link Factory WordPress plugin stems from the plugin itself being a deliberate backdoor rather than a coding flaw. Marketed as a 'homepage sentence publisher', it silently exposes an operator-controlled REST API under /wp-json/link-factory/v1/ that grants the plugin's author covert command-and-control over any site that installs it. Publicly available exploit code exists (reported by WPScan); the endpoints require no WordPress authentication and are gated only by a detached Ed25519 signature tied to the operator's hardcoded public key, so the operator retains privileged access indefinitely.
Remote code execution in Velocity.js (npm 'velocityjs') versions <= 2.1.6 lets an attacker who controls template content reach the JavaScript Function constructor and run arbitrary code in the server process. The earlier CVE-2026-44966/GHSA-j658-c2gf-x6pq fix only filtered constructor/__proto__/prototype in the #set assignment target, leaving property-read expressions in references.ts unguarded, so this is a straightforward bypass. Publicly available exploit code exists (a working PoC is published in the GHSA advisory and was vendor-verified on v2.1.6); no confirmed active exploitation (not in CISA KEV).
Missing authentication on OpenChoreo's cluster-gateway (before 1.0.2 and 1.1.2) exposed caller-facing management APIs on the same externally reachable listener used for agent WebSocket traffic, letting network-reachable attackers hit /api/proxy/ and /api/exec/ without any credentials. In multi-cluster deployments this permits proxying the data-plane Kubernetes API and executing commands inside workload pods, effectively yielding cross-cluster control. No public exploit identified at time of analysis, but the GitHub Security Advisory (GHSA-qh9r-j7rp-4x2m) and CVSS 9.6 mark it as critical.
Remote command execution in Flowise <= 3.1.2 lets an authenticated user break out of the vm2/@flowiseai/nodevm JavaScript sandbox by abusing the /api/v1/node-custom-function endpoint. By passing attacker-controlled executablePath and args into puppeteer.launch(), the code reaches child_process.spawn() outside the sandbox, yielding arbitrary OS command execution as the Flowise process user (root in the official Docker image) and host file disclosure via Chromium's file:// handling. No public exploit is identified at time of analysis, but a vendor security advisory (GHSA-9gvv-qjj3-2p6g) and VulnCheck confirm the flaw; the CVSS 4.0 base score is 9.4.
Supply-chain backdoor in Fluent Forms Pro (Add-On Pack) 6.2.7 for WordPress was delivered as a tampered plugin build through a decommissioned update server, embedding malicious code (CWE-506) rather than a coding flaw. Any site that installed the poisoned 6.2.7 package gains a rogue license-sync PHP file that stands up an unauthenticated backdoor REST endpoint, creates a passwordless administrator, and drops persistent payloads that survive plugin removal. No CISA KEV entry or public exploit code is referenced, but the malicious build itself constitutes distributed attacker code, and VulnCheck plus the vendor (WPManageNinja) have publicly confirmed the incident.
Supply-chain compromise of the Ninja Tables Pro WordPress plugin (version 5.2.11) delivered a tampered build through a decommissioned vendor update server, embedding a backdoor that gives attackers full control of affected WordPress sites. Once installed, the rogue code stands up an unauthenticated REST API endpoint, plants a passwordless administrator account, and drops persistent PHP payloads that survive plugin removal. Reported by VulnCheck with a CVSS 4.0 base score of 9.3; no CISA KEV listing and no public exploit code identified at time of analysis, though the backdoor itself constitutes weaponized malicious code shipped to victims.
Predictable SM2 private-key and signing-nonce generation in the sm-crypto npm library (versions prior to 0.5.0) lets an attacker recover keys generated in Node.js. Because jsbn's SecureRandom checks window.crypto rather than Node's globalThis.crypto, the default sm2.generateKeyPairHex() falls back to seeding an ARC4 stream from Math.random() and the wall clock, so an adversary who observes a few Math.random() outputs and estimates the generation time can reconstruct private keys and forge signatures. Publicly available exploit code exists (reproduced end-to-end against the real npm packages), but no public exploit is identified as being used in active attacks and there is no CISA KEV listing.
Remote code execution in Flowise before 3.1.3 lets authenticated users abuse the Custom MCP node - when CUSTOM_MCP_PROTOCOL is set to stdio - to run arbitrary OS commands on the host. By manipulating environment variables (PYTHONWARNINGS, BROWSER) passed to python3 or leveraging node with the root working directory, an attacker bypasses input validation and achieves command execution as the Flowise service account. Reported by VulnCheck with a CVSS 4.0 score of 9.0; no public exploit is identified at time of analysis, though the technique is documented in detail in the vendor advisory.
Remote code execution in Flowise before 3.1.3 lets authenticated users escape the vm2 JavaScript sandbox and run arbitrary code on the host. By abusing a moment.js locale-validation weakness, an attacker supplies a forged String object whose match function defeats the path-traversal check, causing Flowise to load and execute an attacker-planted JavaScript file from the document store outside the sandbox. Reported by VulnCheck and fixed by the vendor; no public exploit or CISA KEV listing was identified at time of analysis, though the CVSS 4.0 base score of 9.0 reflects full compromise of confidentiality, integrity, and availability.
Remote code execution and SSRF in FlowiseAI Flowise before 3.1.3 stems from a bypassable regex-based Python code validator in the CSV and Airtable Agent nodes, letting attackers smuggle malicious pandas calls through the unauthenticated prediction API via prompt injection. Because the validator blocklists rather than sandboxes, unblocked functions such as pd.read_json() can be abused to exfiltrate local datasets, reach internal services (SSRF), or execute arbitrary code. No public exploit identified at time of analysis, and it is not listed in CISA KEV; the reporting vendor VulnCheck and a GitHub Security Advisory (GHSA-w7x8-q2gp-5cgg) document the issue.
Authenticated arbitrary Python code execution in FlowiseAI Flowise before 3.1.3 arises from the CSV Agent node's customReadCSV parameter, whose regex-based validator can be defeated with obfuscation to run attacker-supplied code inside an unsandboxed pyodide runtime with full host access. Any user able to build or edit a chatflow can escalate from application-level access to code execution on the server. No public exploit has been identified at time of analysis, and the issue is not listed in CISA KEV; a vendor patch exists in version 3.1.3.
Remote code execution in Flowise before 3.1.3 lets attackers run arbitrary Python on the host by abusing the Airtable Agent node. Crafted chatflow prompts carry obfuscated Python that slips past the pythonCodeValidator blocklist and executes inside an unsandboxed pyodide runtime with full access to the underlying OS. Reported by VulnCheck with a published GHSA advisory; no public exploit code is identified at time of analysis, and it is not listed in CISA KEV.
Missing authentication in OpenChoreo's cluster-gateway internal API lets any network-reachable caller invoke /api/proxy/, /api/exec/, and /api/wirelogs/ without a client certificate or token, exposing tenant Kubernetes Secrets and allowing workload mutation and arbitrary command execution across every connected data plane. All deployments before 1.0.3, 1.1.3, and 1.2.0-rc.2 are affected, and the fix introduces an opt-in --internal-mtls mode plus a dedicated internal CA. No public exploit has been identified at time of analysis, and the flaw is not listed in CISA KEV; risk is amplified because the internal listener effectively brokers cross-tenant, multi-cluster control-plane access.
OS command injection in OpenChoreo's Workflow Plane templates allows authenticated developers to execute arbitrary shell commands inside workflow pods by supplying malicious workflow parameters. Affected versions prior to 1.0.4, 1.1.4, and 1.2.0-rc.2 directly interpolated user-controlled parameters such as image-name, image-tag, app-path, and build-env into sh -c shell text rather than passing them through container.env, a classic CWE-78 pattern. Compounding the injection risk, affected privileged Podman templates lacked the hostUsers: false isolation setting, creating a credible path from workflow pod compromise to Kubernetes node-level impact. No public exploit has been identified at time of analysis, but the fix commits confirm the vulnerability mechanism.
Heap buffer overflow in PostgreSQL's to_char(timestamptz) function allows any authenticated database user to execute arbitrary code as the operating system account running the database process by supplying an excessively long POSIX timezone abbreviation. Affected versions span the actively maintained major release lines: PostgreSQL 14 through 18, with fixes available in 14.24, 15.19, 16.15, 17.11, and 18.5. No public exploit code has been identified at time of analysis, but the low attack complexity and broad deployment surface of PostgreSQL make this a high-priority patching target for any environment where untrusted or semi-trusted database users exist.
Authorization bypass in OpenChoreo's Kubernetes developer platform allows any authenticated user with a project-scoped grant to execute commands in and exfiltrate wirelogs from components belonging to entirely different projects within the same namespace. The root cause is that the `component:exec` and `wirelogs:view` API handlers in `exec.go` and `wirelogs.go` evaluate authorization using the attacker-controlled `project` query parameter rather than the authoritative `comp.Spec.Owner.ProjectName` field - a textbook CWE-639 insecure direct object reference. No public exploit or CISA KEV listing exists at time of analysis, but the CVSS 8.8 score and low-privilege network exploitation path make this a serious cross-tenant isolation failure in multi-project deployments.
Out-of-bounds write in the PostGIS address_standardizer extension through 3.7.0 allows a low-privileged database user to trigger memory corruption in the PostgreSQL server process by supplying a malicious rules table to the standardize_address() function. Missing bounds validation on the classification Type field in gamma.c permits values outside the valid range to be used as raw array indices into an internal output-link table, writing attacker-influenced data to adjacent memory. Publicly available exploit code demonstrates successful exploitation against managed cloud PostgreSQL environments including NeonDB and Supabase; no CISA KEV listing is present at time of analysis.
SQL injection in Saurus CMS Community Edition's admin panel grants authenticated administrators the ability to fully enumerate and extract data from the underlying database. The flaw resides in admin/db_data.php at line 509, where the table_name GET or POST parameter is passed unsanitized into a SHOW COLUMNS FROM SQL statement, enabling time-based blind, boolean-based blind, and error-based injection techniques that expose the full schema and can be chained to extract credential data. A publicly available proof-of-concept exploit has been published by VulnCheck; no patch has been identified at time of analysis.
Sandbox escape in Flowise's Python code execution layer (pythonCodeValidator.ts) allows authenticated low-privilege users to invoke native Pandas DataFrame methods - to_csv, to_json, pipe, and query - that the validator's denylist fails to restrict. All Flowise deployments prior to version 3.1.3 are vulnerable, with a CVSS 4.0 score of 8.6 reflecting high confidentiality and high integrity impact. A successful attacker can exfiltrate uploaded CSV data or write arbitrary files to the server filesystem; no public exploit has been identified at time of analysis, but the attack primitives are fully documented in the advisory.
Recursive operation authorization bypass in File Browser before v2.63.22 permits any authenticated user to copy, rename, or delete files they are explicitly denied access to, by initiating the operation on a permitted parent directory. The application's access-rule engine fails to evaluate descendant paths during bulk recursive traversal, defeating the entire isolation model for multi-user deployments. No public exploit code has been identified at time of analysis, but the CVSS 4.0 score of 8.6 reflects high confidentiality and integrity impact with low attack complexity.
Prototype pollution in Trigger.dev's run metadata API (versions 3.3.8 through 4.5.5) lets any authenticated tenant corrupt the shared Node.js webapp process's Object.prototype by supplying crafted path keys to the PUT /api/v1/runs/:runId/metadata endpoint. The root cause is the unsanitized use of attacker-supplied operation.key values passed directly to JSONHeroPath.set() in packages/core/src/v3/runMetadata/operations.ts without filtering __proto__, constructor, or prototype segments. A single exploiting tenant can corrupt Prisma ORM queries, poison Prometheus metric labels, break other tenants' worker authentication, and cause a process-wide denial of service - making this a multi-tenant isolation failure with scope-changed impact. No public exploit code or CISA KEV listing has been identified at time of analysis.
SQL injection in Pimcore's Block.php field loader, affecting versions 2026.1.0–2026.1.4 and all releases below 12.3.9, enables an authenticated editor-level user to exfiltrate arbitrary database content including password hashes via UNION-based injection. The vulnerability chains two incomplete fixes: a missing trailing `$` anchor in ClassDefinition.php regex validation permits malicious UIDs to pass input checks, and six unquoted `getClassId()` concatenations in Block.php execute the injected SQL when any data object of the malicious class is loaded. A working proof-of-concept is publicly documented in GitHub Security Advisory GHSA-2mhj-fhvg-v428, and vendor-released patches (2026.1.5 and 12.3.9) address both weaknesses.
Hard-coded SSH credentials embedded in Tenda CH, CP, and TX3 camera firmware across versions V21.x through V27.x expose all affected devices to remote authentication bypass, granting shell-level access to any attacker who obtains the static password. A GitHub-published proof-of-concept documents the exact credential and exploitation steps, significantly collapsing the barrier imposed by the CVSS 4.0 AC:H rating. No vendor-released patch has been identified at time of analysis, and no CISA KEV listing has been issued, though the public exploit makes this a credible near-term threat for network-exposed devices.
Cross-site scripting in SVGO's script-removal plugin exposes web applications that process untrusted SVG uploads to stored XSS attacks across all major version lines from 1.0.0 through 4.0.1. The removeScripts plugin (called removeScriptElement in v1-3) silently passes through namespace-prefixed script elements such as `<svg:script>` and performs case-sensitive JavaScript URI matching that attackers trivially bypass with mixed-case variants like `JavaScript:`. Applications serving SVGO-optimized SVGs to end users face cookie and session token theft; patches are available in versions 2.8.3, 3.3.4, and 4.0.2, with a public proof-of-concept included in the GitHub security advisory GHSA-2p49-hgcm-8545.
Template injection in Oh My Posh prior to 29.35.1 allows arbitrary operating system command execution as the victim user when the shell prompt renders inside a directory whose name contains a Go template expression. The `setStyle()` function in `src/segments/path.go` passes raw filesystem path components - including untrusted directory names - directly into `template.Render`, whose function map exposes a `cmd` helper that invokes `env.RunCommand`. A publicly available proof-of-concept demonstrates command execution and file writes across Linux, macOS, and Windows. No active exploitation is confirmed in CISA KEV, but the attack surface includes any developer who `cd`s into a maliciously named directory on a shared or attacker-influenced filesystem.
Server-side request forgery in Next AI Draw.io through 0.4.16 enables unauthenticated remote attackers to reach arbitrary internal HTTP services by exploiting a hostname validation bypass in the POST /api/parse-url endpoint. The validator inspects hostnames as string patterns only - without DNS resolution - allowing attackers to supply hostnames that pass the string check yet resolve to internal addresses, including cloud metadata endpoints such as the AWS IMDSv1 service. A publicly available proof-of-concept exists per VulnCheck; no CISA KEV listing has been identified at time of analysis.
File Browser versions 2.50.0 through 2.63.21 permit indefinite session persistence via expired JWT tokens when proxy authentication is configured with a non-default logout page, enabling an attacker who possesses any previously valid token to access protected routes and administrative endpoints beyond the token's expiration window. The authentication middleware intentionally waived JWT expiration under proxy-auth - since the proxy is expected to govern session lifetime - but failed to require the proxy to simultaneously assert the user's identity on each request, meaning a leaked or captured token could authenticate independently and indefinitely. No public exploit code has been identified at time of analysis; the fix commit and vendor security advisory are publicly available.
Resource exhaustion DoS in @anephenix/hub (npm) before 0.2.16 allows any unauthenticated remote client to exhaust server CPU and memory by opening WebSocket connections and ignoring all server RPC messages. Each connection triggers a 10ms setInterval polling loop and a heap entry in the RPC request queue; because the socket close handler never cancels these allocations, they accumulate without bound until the process becomes unresponsive. No active exploitation is confirmed (not in CISA KEV); vendor-released patch is available in v0.2.16.
Stack-exhaustion denial-of-service in node-tar (npm package `tar`) versions up to and including 7.5.20 allows unauthenticated remote attackers to terminate any Node.js process that lists or extracts selected members from an attacker-controlled archive. The vulnerable `mapHas` recursion in `filesFilter` overflows the call stack before any depth guard can execute, and the resulting `RangeError` is uncatchable by standard `try/catch` on async and streaming consumers - the dominant server-side usage pattern. A publicly available proof-of-concept demonstrates the crash using a payload of approximately 188 bytes gzipped; no active exploitation confirmed in CISA KEV at time of analysis.
Exponential parsing time in js-yaml 5.0.0 through 5.2.1 enables unauthenticated remote denial of service via a crafted YAML payload under 200 bytes. The parser's flow-collection logic re-parses nested flow-sequence keys rather than caching results, producing O(2^n) work per nesting level - approximately 30 levels suffices to stall a Node.js process for over two minutes on a single CPU. A functional proof-of-concept is published in the GHSA advisory; no special YAML features or non-default configuration options are required to trigger the flaw.
Arbitrary file deletion in filebrowser before 2.63.19 allows authenticated users holding only Create permission to delete files outside their authorized scope by abusing a race condition in the TUS resumable upload cache eviction path. An attacker swaps an ancestor directory for a symlink during the cache TTL window, redirecting an unguarded os.Remove() call to an out-of-scope target and completely bypassing ScopedFs scope guards and Perm.Delete permission checks - no Delete permission is required. No public exploit code or CISA KEV listing is identified at time of analysis; the AC:H and AT:P metrics in the CVSS 4.0 vector reflect the timing-dependent nature of the attack.
Administrator account deletion in phpList before 3.7.0-RC5 is exploitable via CSRF, allowing a remote attacker to permanently remove any non-self administrator account by tricking a logged-in super-administrator into loading a single crafted GET URL. The root cause is that the deletion endpoint in admins.php bypasses CSRF token validation when the token parameter is absent and the central verifyCsrfGetToken check is called with enforce=false, making the action trivially triggerable via an embedded image in an HTML email. A publicly available exploit is confirmed by VulnCheck; the vendor-released fix is v3.7.0-RC5, and no CISA KEV listing has been identified at time of analysis.
Out-of-bounds read in PostGIS before 3.7.0beta2 enables low-privileged database users to disclose server process memory or crash the PostgreSQL backend by passing malformed FlatGeobuf geometry data to the extension's property metadata decoder. The decoder validates that a string length prefix is present but omits a bounds check confirming the string body falls within the supplied buffer before materializing it as a SQL-visible value, creating both a memory disclosure and denial-of-service path. A publicly available exploit demonstrates successful memory disclosure against managed PostgreSQL platforms including NeonDB and Supabase; exploitation is not confirmed in CISA KEV but the public proof-of-concept and multi-tenant exposure substantially elevate real-world risk.
Incomplete credential redaction in Flowise before 3.1.3 exposes fully decrypted secrets via the authenticated GET /api/v1/credentials/:id endpoint, allowing any user with credentials:view permission to retrieve database connection URLs containing embedded passwords, Google Cloud service account JSON files with RSA private keys, and AWS access keys in plaintext. The root cause is a server-side redaction function that only masks schema fields declared with type 'password', leaving string-typed fields - routinely used for sensitive credential values - untouched in the plainDataObj API response. No public exploit code or CISA KEV listing has been identified at time of analysis, but the low-complexity, low-privilege, network-accessible nature of this flaw makes it an immediate priority for any organization running shared or multi-user Flowise workspaces.
Three concurrent design flaws in Etherpad's `/tokenTransfer` device-pairing endpoint (ep_etherpad-lite 2.6.0-3.0.0) enable persistent authorship impersonation: transfer UUIDs never expire, can be redeemed unlimited times, and the GET handler echoes the raw author token in the JSON response body - defeating the HttpOnly cookie boundary that was introduced specifically to keep the token out of JavaScript reach. Any attacker who obtains the UUID through realistic disclosure channels (browser history, intercepted QR code, server log, third-party plugin) can assume the victim's full read/write author identity indefinitely, re-authenticate on demand, and extract the cleartext token for replay against other endpoints. A working proof-of-concept is included in the advisory; no exploitation has been confirmed by CISA KEV at time of analysis.
Uncontrolled resource consumption in vLLM's OpenAI-compatible completions endpoint allows any authenticated API client to exhaust CPU, memory, async scheduling capacity, and engine request slots with a single crafted request. Affected versions span 0.19.0 through 0.25.x; the issue is fixed in 0.26.0. No public exploit code has been identified and CISA has not listed this in KEV, but the attack is trivially constructable by any client with a valid API credential.
Flowise before 3.1.4 exposes stored third-party API credentials (OpenAI, ElevenLabs) through a missing authorization check in the unauthenticated text-to-speech endpoint, enabling financial abuse at the chatflow owner's expense. The `/api/v1/text-to-speech/generate` endpoint is whitelisted from authentication and fetches any chatflow by UUID without verifying its `isPublic` status, allowing any network-reachable attacker with a valid chatflow UUID to generate unlimited TTS audio billed to the victim. A public proof-of-concept is included in the GHSA advisory; no CISA KEV listing exists at time of analysis.
Race condition in vLLM's prompt embedding loader allows concurrent API requests to bypass the sparse tensor invariant guard introduced for CVE-2025-62164, permitting an invalid sparse tensor to reach `tensor.to_dense()` and cause availability disruption. Affected deployments span versions 0.20.2rc0 through 0.25.x and are limited to instances with `enable_prompt_embeds` explicitly enabled. No public exploit code or CISA KEV listing exists at time of analysis; the fix is confirmed in v0.26.0.
Cache-poisoning XSS and open redirect in Etherpad (ep_etherpad-lite 2.1.0-3.0.0) stem from unsanitized reflection of the attacker-controlled `x-proxy-path` HTTP request header into admin HTML/JS/CSS assets and into a 302 Location target. The most severe vector is cache-poisoning: because no `Vary: x-proxy-path` header was emitted, a CDN or shared reverse proxy caches a single attacker-crafted response and serves the injected script to every authenticated admin who subsequently loads `/admin/index.html`, requiring no further attacker involvement. The timeslider redirect independently allows open redirect via protocol-relative URL injection (`//evil.example`). No CISA KEV listing is confirmed; a working PoC curl command is published in the GitHub advisory GHSA-fjgc-3mj7-8rg8.
Terminal escape sequence injection in Oh My Posh prior to version 29.35.1 allows an attacker who controls a Git repository or filesystem directory name to silently execute arbitrary ANSI/OSC escape sequences in a victim's terminal on every prompt render, without any user action beyond navigating to the attacker-influenced directory. The `write(s rune)` function in `src/terminal/writer.go` emitted attacker-controlled content — including Git commit subjects, author names and emails, upstream URLs, and working directory path components — verbatim to the terminal output buffer without stripping C0/C1 control characters such as ESC (0x1b), BEL (0x07), CSI, and OSC sequences. A publicly available proof-of-concept demonstrates OSC 52 clipboard overwrite and OSC 0 window title hijacking; no public exploit identified as confirmed actively exploited per CISA KEV at time of analysis.
Remote code execution in the QA Analytics (QA Heatmap Analytics) WordPress plugin through version 5.2.0.0 lets unauthenticated attackers inject and execute arbitrary code on the hosting server, per a Patchstack advisory. The flaw is a CWE-94 code injection carrying a maximum CVSS 10.0 rating with a network attack vector requiring no privileges or user interaction. No public exploit has been identified at time of analysis, but the pre-auth nature and trivial complexity make it a top-tier patching priority for any WordPress site running the plugin.
Unauthenticated arbitrary code execution affects the WordPress plugin WP BASE Booking (of Appointments, Services and Events) in all versions up to and including 6.3.0, reported by Patchstack and classified as CWE-94 code injection. A remote attacker with no authentication can cause attacker-controlled code to execute on the hosting server, yielding full compromise of the site and its data. There is no public exploit identified at time of analysis and no CISA KEV listing, but the maximal CVSS rating and unauthenticated network vector make this a high-priority patch.
Authentication bypass in the Priority Portal Generator add-on for Priority ERP (developed by Soft Solutions) lets remote unauthenticated attackers reach protected portal functionality and, because of a scope change, the underlying ERP data it fronts. The maximum CVSS 10.0 rating reflects network reach, no privileges, and high confidentiality and integrity impact. Reported to Israel's INCD; no public exploit identified at time of analysis and no vendor-released patch identified at time of analysis.
Security-restriction bypass in IBM i (the operating system for IBM Power servers, formerly OS/400) versions 7.3 through 7.6 lets a remote attacker abuse improper validation of user-controlled addresses to elevate privileges and cross a security boundary. Vendor scoring rates this a maximum-severity, unauthenticated network flaw (CVSS 10.0, scope-changed), though there is no public exploit identified at time of analysis and EPSS exploitation probability is low (0.33%). IBM published a fix, and CISA's SSVC framework currently marks exploitation as 'none' with a 'total' technical impact.
Flowise's cloud billing API exposes a broken access control flaw at the GET /api/v1/organization/customer-default-source endpoint, enabling any authenticated user to retrieve payment and profile data belonging to arbitrary other customers by manipulating the customerId query parameter. Versions up to and including 3.1.2 are affected; the server authenticates the session but performs no ownership check on the requested customer object, returning full Stripe customer records - including email, balance, currency, and invoice metadata - for any valid customerId supplied. A proof-of-concept is publicly documented in GitHub security advisory GHSA-2364-jh4q-m9vm, and the predictable Stripe-format customer ID scheme (cus_XXX) makes systematic enumeration practical for any registered user.
Cross-tenant authorization bypass in Trigger.dev before 4.5.6 lets a caller holding a valid API key for one project act on another project's deployment. Because CreateDeploymentBackgroundWorkerServiceV4.call() looks up the deployment by friendlyId with no environmentId/tenant predicate, an attacker can attach an attacker-controlled background worker to a victim project's deployment and force it from BUILDING to DEPLOYING. No public exploit identified at time of analysis; the flaw is an insecure-direct-object-reference (IDOR) affecting the deployments API.
Privilege escalation in IBM i (7.3, 7.4, 7.5, 7.6) lets a remote, authenticated attacker gain elevated privileges by abusing improper validation of pointers read from Java-controlled addresses, giving full compromise of the affected component and a scope-changing impact beyond it. IBM assigned a critical CVSS 9.9 (S:C) despite requiring low privileges. No public exploit identified at time of analysis, and CISA SSVC records exploitation status as none, so this is a patch-worthy critical without evidence of active abuse yet.
Remote code execution in IBM Documentation Offline 1.0.0 through 1.4.1 allows an attacker to run arbitrary code by abusing improper control of file paths (CWE-73). The flaw is reachable over the network without authentication or user interaction per the vendor-assigned CVSS 9.8 vector, giving an attacker full read/write/execution impact on the host. No public exploit has been identified at time of analysis, and the issue is not listed in CISA KEV.
Account takeover via broken authentication in the Cartify Multipurpose WooCommerce WordPress theme (versions <= 1.3.0.1) lets an unauthenticated remote attacker authenticate as an arbitrary user, including administrators, without valid credentials. Reported by Patchstack and rated CVSS 9.8, the flaw stems from an authentication logic error (CWE-288) that permits identity assertion through an alternate path. No public exploit identified at time of analysis, and it is not listed in CISA KEV.