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.
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.
Command injection in the ATE (Automatic Test Equipment) module across ten Tenda camera and hub models allows a remote unauthenticated attacker to execute arbitrary OS commands on affected devices. The vulnerable function CAte::HandleCmd in the Kylin binary fails to sanitize user-supplied input before passing it to a system command interpreter (CWE-77), granting full device compromise. A proof-of-concept exists on GitHub (E:P in the CVSS 4.0 supplemental metrics) and no KEV listing is present at time of analysis, though the unauthenticated network vector and PoC availability elevate near-term exploitation risk.
Hard-coded credential exposure in the FL-100 transcranial brain stimulation device enables any attacker within Bluetooth range to bypass authentication entirely and manipulate neurostimulation parameters across every deployed unit simultaneously. The credential is universally shared across all FL-100 devices manufactured under both the Flow Neuroscience and Halo Neuroscience brands, meaning a single credential disclosure event compromises the entire installed base at once. No public exploit code has been identified at time of analysis and active exploitation is not confirmed by CISA KEV, but the zero-privilege, zero-complexity authentication bypass presents a credible patient safety risk in clinical and home-use therapeutic environments.
Authenticated SQL injection in Zohocorp ManageEngine Password Manager Pro (before build 13232) and ManageEngine PAM360 (before build 8552) allows a network-authenticated attacker with low-level privileges to read, modify, or delete sensitive database contents. Given that Password Manager Pro is a privileged credential vault and PAM360 is a privileged access management platform, successful exploitation could expose every managed credential, secret, and privileged session record stored within the system. No public exploit code or CISA KEV listing has been identified at the time of analysis, but the severity and target sensitivity make this a high-priority patching candidate.
Authentication bypass in ManageEngine Password Manager Pro (all versions before 13232) and PAM360 (all versions before 8551) allows low-privileged network attackers to forge SAML assertions and gain unauthorized elevated access, including administrative sessions, within these enterprise credential vaults. The flaw stems from improper cryptographic signature verification of SAML responses (CWE-347), enabling token manipulation that the service provider cannot detect. Vendor patch is available; no public exploit code has been confirmed at time of analysis, but the crown-jewel nature of PAM platforms - storing all privileged enterprise credentials - makes this a high-priority remediation regardless of current exploitation status.
Integer wraparound in PostgreSQL's tsvector and tsquery full-text search functions allows an unprivileged database user to trigger an undersized heap allocation and subsequently write out-of-bounds, with potential for arbitrary code execution as the operating system user running the database process. All supported major release lines are affected - versions prior to 18.5, 17.11, 16.15, 15.19, and 14.24 - and the vulnerability closely mirrors CVE-2026-6473, which addressed a similar integer overflow class in the same subsystem. No public exploit code or CISA KEV listing has been identified at time of analysis, though the CVSS 8.8 rating with full High C/I/A impact reflects the worst-case consequence of successful exploitation.
Heap buffer overflow in PostgreSQL's pg_dump backup utility across all active major versions enables an authenticated database user with object creation privileges to execute arbitrary code as the operating system account running pg_dump. The attacker plants a crafted database object containing an excessively long function transform list, then waits for pg_dump to process that object during a backup operation, triggering CWE-122 heap corruption. No public exploit has been identified at time of analysis, but the clear trigger path and widely deployed target surface make this a meaningful operational risk for organizations relying on pg_dump for backup automation.
Heap buffer overflow in PostgreSQL's pg_stat_statements extension (major version 18, minor versions 18.0 through 18.4) allows any authenticated database user to execute arbitrary code as the operating system account running the PostgreSQL service by submitting crafted SQL queries containing array constants. The CVSS vector (AV:N/AC:L/PR:L/UI:N) indicates low-complexity network exploitation requiring only a valid database credential, with full confidentiality, integrity, and availability impact on the database host. No public exploit code has been identified at time of analysis, and this CVE is not currently listed in the CISA KEV catalog.
Heap buffer overflow in PostgreSQL's plperl extension allows a database function owner to execute arbitrary code as the OS-level user running the database server by crafting a function body that returns a tied hash. Affected versions span the four active PostgreSQL major release lines prior to 18.5, 17.11, 16.15, 15.19, and 14.24. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
Heap buffer overflow in PostgreSQL's regexp engine allows any authenticated database user to execute arbitrary code as the operating system user running the database process. The flaw is triggered by specially crafted text that survives input validation but undergoes unanticipated data growth during internal round-trip conversion through the pg_wchar encoding layer, overflowing a heap-allocated buffer during regular expression evaluation. All active PostgreSQL branches are affected - versions prior to 18.5, 17.11, 16.15, 15.19, and 14.24 - with no public exploit or CISA KEV listing confirmed at time of analysis.
Remote code execution in PostgreSQL's portal/cursor subsystem allows any authenticated database user to execute arbitrary code as the OS-level process owner (typically 'postgres') by re-creating a named cursor with an incompatible result type. All actively supported major branches are affected - versions prior to 14.24, 15.19, 16.15, 17.11, and 18.5. No public exploit or active exploitation has been identified at time of analysis, but the low attack complexity and minimal authentication requirement (any valid login) make this a critical patch priority for the ubiquitous open-source RDBMS.
Remote code execution in PostgreSQL 18.x (all minor versions before 18.5) is achievable by any authenticated object creator through a type confusion flaw in pg_restore_attribute_stats(), which conflates range and multirange values to corrupt memory and gain code execution as the OS user running the database process. The CVSS 8.8 score reflects a low-privilege, low-complexity network exploit path with full confidentiality, integrity, and availability impact. No public exploit code or active exploitation has been identified at the time of analysis, but the RCE primitive combined with the low privilege bar makes this a high-priority patch target for all PostgreSQL 18 deployments.
Type confusion in PostgreSQL's 'internal' pseudo-type enforcement enables any authenticated database user to execute arbitrary code as the operating system user running the database process. The vulnerability arises because access controls blocking SQL-layer callers from invoking C-language functions that accept 'internal' arguments contained coverage gaps, allowing a crafted function call to corrupt memory and achieve OS-level code execution. Fixed versions are PostgreSQL 18.5, 17.11, 16.15, 15.19, and 14.24; no public exploit or CISA KEV listing has been identified at time of analysis.
Integer wraparound in 32-bit builds of PostgreSQL's PL/Tcl and PL/Perl procedural language extensions enables an authenticated object creator to provoke an undersized heap allocation and perform an out-of-bounds write via a crafted function body, ultimately achieving arbitrary code execution as the OS user running the database process. PostgreSQL versions before 18.5, 17.11, 16.15, 15.19, and 14.24 across active major release branches are affected. This is a recurrence of the class of integer arithmetic flaws previously addressed by CVE-2026-6473, indicating an incomplete prior remediation; no public exploit or CISA KEV listing has been identified at time of analysis.
Code injection in PostgreSQL's pg_dump, pg_dumpall, and pg_restore (plain-format mode) allows a malicious superuser of an origin database server to embed arbitrary OS-level commands into a dump file, which execute on the restoring client's operating system account when psql processes the dump. This is a confirmed bypass of the CVE-2025-8714 patch: the \unrestrict meta-command introduced by that fix is itself exploitable via psql meta-command input expansion, negating the protection that \restrict was intended to provide. No public exploit has been identified at time of analysis, but the high CVSS score (8.8) and full RCE impact make this urgent for any organization that accepts and restores PostgreSQL dumps from external or untrusted sources.
Heap-based buffer overflow in IBM i 7.3 through 7.6 enables remote authenticated attackers to execute arbitrary code with full confidentiality, integrity, and availability impact. The vulnerability carries a CVSS 3.1 base score of 8.8 and is network-accessible with low attack complexity, making it a high-priority remediation target for IBM Power Systems environments. No public exploit code or active CISA KEV-listed exploitation has been identified at time of analysis; a vendor patch is available via IBM's support portal.
Heap out-of-bounds write in rsync 3.2.5 through 3.4.x allows remote unauthenticated attackers to corrupt heap memory by supplying a crafted files-from entry to any exposed rsync daemon module. Critically, the flaw is exploitable against read-only daemon modules - a configuration commonly treated as a safe exposure boundary - by providing a path containing both an interior and trailing backslash, causing add_implied_include() to under-size its destination buffer and write one attacker-controlled byte past the allocation end. No public exploit has been identified at time of analysis, though the CVSS 4.0 score of 8.8 reflects the unauthenticated network attack vector and high availability impact.
Remote code execution via integer wraparound in PostgreSQL's fuzzystrmatch contrib module allows any authenticated database user to corrupt memory and execute arbitrary code as the operating system account running the database server. All maintained PostgreSQL branches are affected: versions before 18.5, 17.11, 16.15, 15.19, and 14.24. No public exploit code and no CISA KEV listing have been identified at time of analysis, but the RCE impact, low attack complexity, and network accessibility establish this as a high-priority patching target.
Remote code execution in IBM i 7.3 through 7.6 is achievable by any authenticated network attacker via an out-of-bounds write (buffer overflow) triggered over the network. The vulnerability requires only low-level credentials, making it accessible to any valid user account on an internet- or network-exposed IBM i system. No public exploit code or CISA KEV listing has been identified at time of analysis, but the vendor has confirmed the flaw and released a patch via IBM Support.
SQL injection in PostgreSQL's EXTRACT() expression deparse enables a database object owner to escalate privileges and execute arbitrary SQL with superuser rights. Affected across the active PostgreSQL release tree - versions before 14.24, 15.19, 16.15, 17.11, and 18.5 - the flaw is triggered when deparse consumers such as pg_dump or psql's \sf command process a hostile object definition crafted by a low-privilege but authenticated database user. No public exploit code or CISA KEV listing exists at time of analysis; however, the superuser privilege-escalation impact and broad reach of affected deparse consumers make this a high-priority upgrade, particularly for multi-tenant or shared PostgreSQL environments.
Remote code execution in IBM i 7.3 through 7.6 is possible for any authenticated remote attacker who can manipulate an untrusted search path used by privileged system components. The CVSS 8.8 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) confirms network accessibility with minimal privilege prerequisites and no user interaction, yielding full confidentiality, integrity, and availability impact. Vendor patch is available; no public exploit code or CISA KEV listing has been identified at time of analysis.
Type confusion in PostgreSQL's 'refint' contrib module enables any low-privileged database user with object creation rights to execute arbitrary code as the operating system user hosting the PostgreSQL service. Affected are all active PostgreSQL branches prior to versions 18.5, 17.11, 16.15, 15.19, and 14.24. Notably, the fix was silently committed to the PostgreSQL git repository under the subject 'refint: Remove plan cache.' without a CVE assignment, meaning vulnerable installations may have remained unpatched far longer than typical because administrators had no security signal to act on. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
Out-of-bounds heap write in rsync 3.0.1 through 3.4.x allows a malicious sender to corrupt adjacent heap memory by crafting an argument list that exactly fills the argv allocation in read_args(), causing the trailing NULL terminator to land one slot beyond the allocation boundary. Any rsync client performing a pull operation against an attacker-controlled or compromised server is exposed; heap corruption at this boundary can produce a crash (high availability impact) or potentially a write-what-where condition depending on heap layout. No public exploit code and no CISA KEV listing have been identified at time of analysis; rsync maintainers designated v3.5.0 a major security release, confirming patch availability.
Out-of-bounds write in rsync 3.0.0 through 3.4.x enables remote memory corruption when a peer sends file entries with the FLAG_HLINKED flag set against a receiver with hard-link preservation disabled. The missing F_SUM field in the file_struct layout permits writes beyond the allocated structure boundary, corrupting adjacent heap or stack data and likely causing denial-of-service or potentially enabling code execution. Vendor-released patch v3.5.0 is available; no public exploit or CISA KEV listing has been confirmed at time of analysis.
Privilege escalation in the Service Finder Booking WordPress plugin (versions 6.2 and below) allows any authenticated subscriber-level user to elevate their privileges within the application, resulting in full confidentiality, integrity, and availability impact. The flaw is network-exploitable with low complexity and requires only a valid subscriber account, making it accessible to any registered user on affected sites. No public exploit code or CISA KEV listing has been identified at time of analysis, though the CVSS 8.8 score reflects the high-impact potential once a low-privileged account is obtained.
Privilege escalation in Budibase's public role-assignment API allows an app-scoped builder to grant themselves or other users builder access - or arbitrary data-plane roles - across any app in a shared tenant. Versions prior to 3.39.24 are affected; the CVSS score of 8.8 (PR:L) reflects that a low-privilege authenticated account is sufficient, with no user interaction or elevated complexity required. No public exploit or CISA KEV listing is identified at time of analysis, but the vulnerability is straightforwardly reproducible given the published commit diff and GHSA advisory detail.
Path traversal in IBM i versions 7.3 through 7.6 enables a low-privileged remote authenticated attacker to bypass object-level access controls and gain unauthorized read, write, or disruptive access to arbitrary system objects. The CVSS 8.8 rating reflects full C/I/A impact across a network-accessible attack surface requiring only low privilege - consistent with IBM's own report as originating vendor and the EUVD advisory. No public exploit code has been identified and this vulnerability is not listed in CISA KEV; EPSS at 0.36% (29th percentile) indicates low current exploitation activity, though a vendor patch is now confirmed available.
Heap corruption and potential remote code execution in Elasticsearch's native ML inference engine can be triggered by any user holding the low-privilege ML model upload and deploy permission. By crafting a model that embeds an operation computing a memory address from an attacker-controlled offset, a low-privileged authenticated user can cause the native inference subprocess to read and write outside its allocated heap, reliably crashing that process or, under controlled heap layout conditions, executing arbitrary code within it. No active exploitation or public proof-of-concept has been identified at time of analysis, but the CVSS 8.8 rating, network-accessible vector, and explicit RCE potential in the vendor description place this in the urgent-remediation tier for any organization running Elasticsearch with ML features delegated to non-admin users.
PHP Object Injection in the Booking Activities WordPress plugin (versions ≤ 1.18.4) exposes sites to potential remote code execution through unsafe deserialization of attacker-controlled data. The CVSS vector (PR:N, UI:R) indicates exploitation requires no authentication but does require some form of user interaction, suggesting the attack surface likely involves a front-end booking form or link that a visitor triggers. Depending on available PHP class chains (POP chains) in the WordPress environment, impact can reach full confidentiality, integrity, and availability compromise. No public exploit or CISA KEV listing has been identified at time of analysis.