Insecure Deserialization

Unauthorized remote code execution is possible in Microsoft Dataverse through deserialization of untrusted data, scored 9.8 under CVSS 3.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Because the vector carries PR:N and UI:N, the vulnerable deserialization path can be reached by remote attackers without authentication, user interaction, or special configuration. No public exploit code has been identified at time of analysis (E:U) and there is no confirmed active exploitation; the principal constraint on real-world risk is that Dataverse is a Microsoft-operated cloud service, so the official fix (RL:O) is applied server-side by Microsoft and exposure is largely bounded to the pre-patch window.

Unauthenticated remote code execution affects IBM Security Verify Access 10.0 through 10.0.9.2 and IBM Verify Identity Access 11.0 through 11.0.3 - including their containerized editions - through deserialization of untrusted data, allowing an attacker who can reach the affected service to run arbitrary code on the system. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, base 9.8) confirms the flaw is network-reachable and requires no authentication, privileges, or user interaction, so any exposed, unpatched instance should be considered directly exploitable; the only real gating factors are running an affected build and whether the vulnerable endpoint is network-accessible. No public exploit code or confirmed active exploitation has been identified at time of analysis, but a vendor patch is available and the pre-authentication nature of the issue places it in the highest remediation priority tier.

Remote code execution is achievable in IBM Security Verify Access 10.0 through 10.0.9.2 and IBM Verify Identity Access 11.0 through 11.0.3, including their container editions, because the affected services deserialize untrusted data received over the network. The flaw is reachable without authentication and without user interaction (CVSS 3.1 base 9.8, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), allowing an attacker who can reach the vulnerable endpoint to run arbitrary code with the privileges of the affected process. There is no public exploit identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV), but a vendor patch is available and the only practical barrier to exploitation is network reachability of the exposed service.

PHP object injection in the MainWP Child plugin through version 6.2.1 allows unauthenticated remote attackers to fully compromise confidentiality, integrity, and availability, though exploitation requires user interaction and a viable PHP gadget chain. The vulnerability is a deserialization of untrusted data (CWE-502) issue with a CVSS 3.1 base score of 8.8, rated high risk. No public exploit code or active exploitation has been identified at time of analysis.

Unauthenticated remote code execution in SGLang versions through v0.5.20 arises from unsafe pickle deserialization in the ZMQ message decoder, which processes PickleWrapper payloads via pickle.loads() without type allowlisting or authentication. While default single-node deployments bind the ZMQ control channel to loopback, remote exploitation becomes possible when data-parallel attention is enabled and --dist-init-addr is set to a non-loopback address. Disabling SGLANG_USE_PICKLE_IPC does not eliminate the risk because the msgpack code path still reaches pickle.loads(), and no public exploit code has been identified at time of analysis.

PHP object injection in the WordPress plugin Uncanny Automator - AI + Automation for WordPress (all versions up to and including 7.6.1.1) lets an authenticated attacker with Subscriber-level access or above pass attacker-controlled data into an unserialize() sink via recipe trigger meta, and a POP chain present in Uncanny Automator itself escalates that into deletion of arbitrary files on the server. Exploitation is conditional rather than trivial: it additionally requires at least one supported third-party integration plugin (PeepSo, MailPoet, WPForms, and similar) to be co-installed and a recipe to be configured so that attacker-supplied input is stored as trigger meta - a combination of prerequisites that is why the assessed vector is AC:H and the plugin's real-world exposure is best characterized as a genuine but conditional risk rather than a mass-exploitation emergency. No public exploit code and no confirmed active exploitation were identified at time of analysis.

PHP object injection in The Events Calendar WordPress plugin (all versions through 6.17.4, published by Liquid Web / StellarWP) allows an attacker to pass crafted serialized data into a deserialization code path and instantiate arbitrary PHP objects, which can escalate to code execution, data theft or full site compromise if a usable POP gadget chain exists in the plugin, WordPress core or any other installed theme/plugin. The supplied CVSS vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) describes a remote, unauthenticated, no-interaction attack, but the advisory does not name the vulnerable endpoint, and comparable Patchstack object-injection findings frequently require at least a low-privilege authenticated session; our independent assessment therefore keeps the same impact ratings while treating exploitability as high-complexity (AC:H). There is no CISA KEV listing and no public exploit identified at time of analysis, so the practical risk is driven by whether a reachable gadget chain is present on a given WordPress installation rather than by confirmed active exploitation.

PHP object injection in the WordPress plugin Unlimited Elements For Elementor (Free Widgets, Addons, Templates) through version 2.0.19 lets an authenticated low-privilege user pass attacker-controlled data into an unsafe PHP deserialization path, resulting in high confidentiality, integrity, and availability impact per the vendor-assigned CVSS 3.1 score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Exploitation requires a logged-in WordPress account with at least low privileges on a site running an affected plugin version, and no end-user interaction is needed; realistic exploitation further depends on the presence of a usable POP gadget chain in the plugin, Elementor, or WordPress core, which is not confirmed by the available data. No public exploit code and no confirmed active exploitation were identified at time of analysis, so exposure is driven primarily by sites that permit self-registration or retain low-privilege accounts they do not tightly control.

Authenticated remote code execution in the @backstage/plugin-techdocs-node package shipped with the Backstage developer portal framework allows a user who can register or influence an SCM-backed documentation source to execute arbitrary code on the TechDocs backend host. The flaw (CWE-502, CVSS 8.8, vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) arises because mapping-style markdown_extensions entries in a committed mkdocs.yml were not sanitized, letting an attacker name Python callables such as subprocess:Popen or os:system that MkDocs then imports and instantiates during documentation generation. Exploitation requires a valid account and an instance that performs server-side TechDocs generation of attacker-controlled sources, so risk is highest where generation runs with backend credentials, filesystem access, or internal network reachability; no public exploit code has been identified at time of analysis and there is no confirmed active exploitation (CISA KEV).

Remote code execution in LMCache multiprocess (distributed) mode allows unauthenticated attackers to execute arbitrary code as the LMCache process user by sending a crafted msgpack message with extension code 1 to the ZeroMQ ROUTER transport (default TCP port 5555). The flaw occurs because DeviceIPCWrapper.Deserialize calls pickle.loads on untrusted data before the request handler runs; official container images run as root, amplifying impact. Network exploitation requires the operator to have configured a routable --host for multi-node deployments (default binds to localhost), and no public exploit code has been identified at time of analysis.

Unauthenticated remote code execution in Manacle Multi-Tenant ERP allows attackers to execute arbitrary code or manipulate application data through unsafe deserialization of user-controlled input (CWE-502). The vulnerability (CVE-2026-107104) is rated critical with a CVSS 4.0 score of 9.3 and requires no privileges or user interaction to exploit (PR:N/UI:N). No public exploit or active exploitation is known at time of analysis, but the high impact to confidentiality and integrity, combined with network reachability, makes this a high-priority risk.

Unauthenticated PHP object injection in the String Locator WordPress plugin (versions before 2.6.8) lets an attacker store a crafted serialized PHP object in a database row via the plugin's database editor, with no authentication required (PR:N per the assessed vector). The payload only fires when a site administrator subsequently opens and saves that row in the editor, which is the UI:R precondition, and it escalates to remote code execution, arbitrary file deletion, or sensitive data disclosure only if a suitable POP gadget chain exists in another installed plugin or component, which is why our independent assessment rates attack complexity as High (AC:H) despite the raw CVSS 8.8 vector using AC:L. Publicly available exploit code exists, but the two gating conditions (an admin save action plus a usable gadget chain) meaningfully reduce real-world exploitability, and no CISA KEV listing confirms active exploitation.

Deserialization of untrusted cache data in IBM Langflow OSS 1.0.0 through 1.12.2 can execute attacker-controlled code with the privileges of the Langflow service process, but only for an attacker who has already obtained two things: the Langflow server secret and write access to the backing Redis instance used as the application cache. Because both prerequisites are effectively gated - the server secret is a trusted signing/trust value and Redis is normally bound to localhost or a private, authenticated network - this is not exploitable by an anonymous remote attacker against a default deployment, which is why the practical risk is lower than the 7.5 base score suggests. No public exploit code has been identified at time of analysis and the issue is not listed as confirmed actively exploited (CISA KEV).

Deserialization of untrusted data in NVIDIA Model-Optimizer (CVSS 3.1 base score 7.8) allows an attacker who supplies a crafted model artifact to achieve code execution, data tampering, denial of service, and information disclosure on the machine that loads it. The assessed vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) shows the severity comes from full loss of confidentiality and integrity once the payload runs, but the attacker must first get the victim to open or deserialize the malicious artifact in a local processing environment, so there is no remote, zero-interaction path. No public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV, so this is a credible but priority-setting issue for ML/AI pipelines that ingest third-party models rather than an emergency remote-exploitation case.

Unauthenticated remote code execution in the web interface of HPE Networking ClearPass Policy Manager allows an attacker who can reach that interface over the network to run arbitrary code on the appliance. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) confirms no authentication, no user interaction, and low attack complexity, with full confidentiality, integrity, and availability impact - a genuine high-priority vulnerability rather than a high-CVSS-but-low-risk artifact. No public exploit identified at time of analysis; the practical limiting factor is network exposure of the ClearPass web interface, so deployments reachable from the internet or broad internal networks are at direct risk while those restricted to isolated management networks or behind VPN/firewall controls are substantially less exposed.

Hydra 1.3.4 through 1.3.5 and the 1.4.0.dev line prior to 1.4.0.dev9 can execute attacker-chosen code when an application runs Hydra's instantiate() on configuration an attacker can influence, because the callable blacklist added for CVE-2026-68508 is name-based and can be sidestepped via wrappers, aliases, dispatch helpers, or deferred invocation. The CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, score 7.8) indicates no attacker privileges are required but a victim application must actually instantiate untrusted or externally sourced config, which is why user interaction is scored; the flaw is CWE-184 (Incomplete List of Disallowed Inputs) and is best understood as an incomplete fix rather than a new class of bug. There is no public exploit identified at time of analysis and the issue is not in CISA KEV, and vendor-released patches exist in Hydra 1.3.6 and 1.4.0.dev9. Applications that only ever instantiate developer-authored, trusted configuration are not exposed, and the vendor explicitly documents the blocklist as a best-effort defense-in-depth stopgap rather than a security boundary.

Insecure deserialization in the TrueLayer Magento 2 Plugin's Psr16CacheAdapter component allows an attacker who already has write access to the Magento cache backend (Redis or Memcached) to achieve arbitrary code execution via crafted PHP objects. The flaw arises from PHP's unserialize() being called without class restrictions, and exploitation requires both cache-write capability-obtainable through local filesystem access or an exposed cache service-and the presence of a usable gadget chain in the deployed Magento/Adobe Commerce environment. Although rated CVSS 7.5, real-world risk is materially lower because the attack preconditions are stringent; no public exploit code has been identified at time of analysis, and the issue is not confirmed as actively exploited.

Unauthenticated PHP object injection in the Haaken WordPress theme affects all versions up to and including 1.5, allowing remote attackers to supply crafted serialized data to an unserialize() sink without any prior authentication (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H, base 8.1). The conditional nature of the risk is captured by the AC:H rating: full impact (remote code execution or data compromise) generally depends on a usable POP gadget chain being present in the theme, WordPress core, or another installed plugin, so exposure is limited to sites actually running this theme at an affected version. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, and several vectors beyond the single Patchstack advisory reference (EUVD-2026-93080) remain unpublished.

Unauthenticated PHP Object Injection in the GDPR Framework By Data443 WordPress plugin through version 2.5.0 allows remote attackers to pass crafted serialized data to a PHP unserialize() path, potentially achieving full confidentiality, integrity, and availability impact if a usable gadget chain is reachable. The CVSS vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (9.8) confirms network-reachable, low-complexity, unauthenticated exploitation with no user interaction; the only prerequisite is an active vulnerable plugin installation. No public exploit code or CISA KEV entry was identified at time of analysis, though reliable code execution depends on the presence of a gadget chain in the plugin, WordPress core, or other loaded components.

PHP object injection in the WP Spell Check WordPress plugin, affecting all versions up to and including 12.1, allows an attacker who already holds administrator-level privileges to pass attacker-controlled data into PHP's deserialization routine and instantiate arbitrary objects. Successful object injection can lead to high-integrity and high-confidentiality impact - including code execution, file manipulation, or privilege abuse - depending on whether a usable POP gadget chain exists in the plugin or the surrounding WordPress environment, which the available data does not confirm. With a CVSS 3.1 base score of 7.2 (High) and PR:H in the vector, the practical attack surface is limited to trusted high-privilege users; no public exploit identified at time of analysis and no vendor-released patch identified at time of analysis.

PHP object injection in the VK Google Job Posting Manager WordPress plugin (versions through 1.3.1) allows an authenticated low-privilege user to submit crafted serialized input that the plugin deserializes without validation, permitting object injection that can escalate to arbitrary code execution, file manipulation, or sensitive data exposure where a usable gadget chain exists in the plugin or its loaded libraries. Per the CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8), the flaw is network-reachable with low complexity, requires only low-level authentication, and needs no user interaction, resulting in high confidentiality, integrity, and availability impact. No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV; reliability of full code execution depends on an unconfirmed PHP POP gadget chain, so successful exploitation is most plausible against sites where subscribers or other low-privilege accounts can be created or reached.

PHP object injection in the WordPress plugin Simple Event Planner (PressTigers) through version 1.5.7 lets an authenticated low-privileged user pass crafted serialized data to a plugin endpoint that is deserialized without validation, potentially leading to arbitrary object instantiation and, if a usable gadget chain exists in the plugin or surrounding WordPress codebase, to full remote code execution. The flaw is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and requires a valid low-privilege session - it is not exploitable unauthenticated - with no public exploit identified at time of analysis. Sites that permit open subscriber registration are the most exposed, since any registered user can reach the vulnerable code path.

PHP object injection in the WordPress plugin Sunshine Photo Cart (all versions through 3.7.1) allows an attacker who already holds a high-privilege authenticated WordPress account to submit crafted serialized data to a plugin endpoint, potentially achieving object injection with high confidentiality, integrity and availability impact. The CVSS 3.1 vector (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) rates this 7.2 and confirms the attacker must be authenticated with elevated privileges (PR:H), which excludes anonymous internet users and is the primary limiting factor; no user interaction is required. No public exploit code has been identified at time of analysis, and there is no confirmed evidence of active exploitation (not listed in CISA KEV) - realistic impact depends on a usable PHP gadget chain being present in the plugin or the hosting stack, which is not confirmed by the available data.

PHP object injection in the WordPress plugin WP Ultimate Exporter (Smackcoders Inc.) affects all versions up to and including 3.0, allowing an attacker who already holds a high-privilege authenticated account on the target site to submit crafted serialized PHP data to a plugin endpoint and instantiate arbitrary objects. Successful exploitation depends on a usable POP gadget chain being present in the plugin, WordPress core, or a loaded library; without one, the flaw may only yield object injection rather than full code execution. No public exploit code or confirmed active exploitation was identified at time of analysis, and the principal barrier is the CVSS PR:H prerequisite, which limits realistic abuse to privileged insiders or attackers who have already compromised an administrative account.

Authenticated attackers with high privileges can exploit a PHP Object Injection vulnerability in Product Feed PRO for WooCommerce (versions up to 13.5.7) to potentially execute arbitrary code, delete files, or perform other malicious actions. The flaw stems from deserialization of untrusted data (CWE-502), and successful exploitation hinges on the presence of a reachable POP gadget chain in the targeted site's code; without such a chain, impact may be limited. No public exploit code or active exploitation has been identified at time of analysis, and the CVSS score is 7.2 (High).

Object injection in the WordPress plugin Advanced Post Manager (all releases through version 4.5.5) lets remote attackers push attacker-controlled serialized data into PHP's unserialize() routine, potentially instantiating arbitrary objects and, where a usable POP gadget chain exists, achieving code execution with full confidentiality, integrity and availability impact. The NVD vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) treats the flaw as unauthenticated and network-reachable, whereas our independent assessment raises attack complexity to High because real-world impact hinges on a reachable gadget chain in the plugin, WordPress core or another active plugin; no public exploit identified at time of analysis and there is no CISA KEV entry for this CVE.

Remote code execution in dormakaba evolo Service (all versions) allows an unauthenticated network attacker to execute arbitrary code as SYSTEM via a .NET deserialization flaw, per a 9.8 CVSS vector. The service is typically deployed on internal access-control administration hosts, so exploitation generally requires access to the management network segment, and pre-auth reachability is asserted by the CVSS vector rather than the description. No CISA KEV entry or public exploit was identified at time of analysis; EPSS is 0.29% (20th percentile), while SSVC rates exploitation as none and technical impact as total.

Deserialization of attacker-controlled JSON in plugin-capable Seroval releases 0.12.0 through 1.6.1 lets a remote unauthenticated attacker cause a plugin-produced callable to be invoked unexpectedly through native Promise settlement, resulting in arbitrary code execution in applications that pass untrusted input to the library's fromJSON path. The root cause is a thenable type-confusion defect (CWE-843) that bypasses the Promise resolver remediation shipped in 1.5.3 for CVE-2026-59940 because the dangerous invocation happens inside the native Promise resolution procedure after deserialization rather than in the resolver itself. CVSS is rated 9.8, and no public exploit code was identified at time of analysis; vendor-released patch: Seroval 1.6.2.

Deserialization of untrusted schema data in Apache Directory LDAP API 2.1.0 through 2.1.8 lets a rogue, compromised, or pre-TLS man-in-the-middle LDAP server return a crafted schema object when a Java client calls loadSchema(), potentially executing arbitrary code inside the client process. The flaw is remotely reachable without credentials (CVSS vector PR:N) and vendor patches are available in 2.1.9, but exploitation requires the victim application to initiate a schema-loading connection to an endpoint the attacker controls or can impersonate, which is why the assessed vector raises attack complexity to High (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) even though the published base score is 9.8 under AC:L. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and EPSS remains low at 0.39% (30th percentile), with SSVC recording Exploitation: none, Automatable: yes, Technical Impact: total.

Remote code execution in DHIS2 Core versions 2.42.0 through before 2.42.5.1 and 2.43.0 through before 2.43.0.1 allows an authenticated attacker with high privileges to execute arbitrary code via unsafe Java deserialization. The vulnerability is remotely reachable but requires PR:H credentials, limiting exploitation to insiders or attackers who have already compromised an administrative account; no public exploit has been identified at time of analysis. Vendor fixes are available in versions 2.42.5.1, 2.43.0.1, and 2.44.

Privileged local attackers who can control Foreman configuration data can chain server-side template injection with insecure deserialization through the foreman-rake initialization logic in /usr/share/foreman/config/settings.rb to execute arbitrary code on Red Hat Satellite 6.19 for RHEL 9 hosts, resulting in full host compromise and downstream supply chain risk. The assessed CVSS 3.1 vector (7.7, AV:L/AC:L/PR:H/UI:R/S:C/C:H/I:H/A:H) confirms the attack is local and authenticated with high privileges plus a user-interaction component, so it is not remotely or unauthenticated reachable against a default deployment and real exposure is largely confined to compromised or malicious privileged operators. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; Red Hat has published errata RHSA-2026:74503 addressing it.

PHP object injection in the Icegram WordPress plugin through version 3.1.31 allows an authenticated attacker holding only low-level (Contributor-equivalent) privileges to pass crafted serialized data into an unsafe PHP deserialization path, with the potential to trigger a gadget chain that yields high confidentiality, integrity, and availability impact. The flaw is network-reachable, low complexity, and requires no victim interaction (CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8), and because the vulnerable component is a widely deployable WordPress plugin, any site allowing self-service or delegated content roles expands its exposure surface. No public exploit code has been identified at time of analysis, and there is no CISA KEV listing for this CVE; exploitation depends on an attacker first obtaining a low-privileged account on the target site.

PHP object injection in the Hide Shipping Method For WooCommerce plugin (versions up to and including 1.5.4) allows an authenticated user with Editor-level or higher privileges to trigger deserialization of untrusted data on WordPress sites that also run WooCommerce, potentially leading to remote code execution, arbitrary file access, or data manipulation if a suitable gadget chain exists in the plugin, core, or other installed components. The CVSS 3.1 vector (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, score 7.2) confirms the attack is network-reachable and requires no user interaction, but the high privilege prerequisite substantially limits exposure. No public exploit identified at time of analysis, no confirmed in-the-wild exploitation, and no fixed plugin version is listed in the available Patchstack advisory.

Authenticated administrators holding a specific queue-management privilege on Kiteworks Email Protection Gateway (versions before 9.5.0) can submit a crafted serialized object to the cluster management interface that is deserialized without sufficient validation, resulting in arbitrary code execution in the context of the gateway service account. The CVSS 3.1 vector (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, 7.2) makes clear this is not reachable by unauthenticated users, standard users, or admins lacking the queue-management entitlement, and no user interaction is required once a suitably privileged account exists. No public exploit code has been identified at time of analysis, no confirmed active exploitation (CISA KEV) has been reported, and vendor-patched versions are available.

Deserialization of untrusted data in Kiteworks Core before 9.5.0 can escalate to remote code execution on the appliance, but only as a secondary, chained weakness rather than a standalone attack. The issue is not exploitable in isolation: an attacker must first obtain a way to influence the data that Core deserializes, which in practice means chaining a separate flaw (for example one of the file-write or injection issues in the same CISA CSAF batch, va-26-274-01) or leveraging an existing foothold. No public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV, and although the base score is 8.1, the local/config-adjacent reachability (AV:L), high attack complexity (AC:H) and the mandatory data-influence precondition materially lower real-world risk; the CVSS vector indicates no privileges are required (PR:N), but exploitation is not remotely self-contained.

PHP object injection in the ThemeHigh 'Extra Product Options For WooCommerce | Custom Product Addons and Fields' plugin through version 3.3.8 allows an authenticated user holding the WooCommerce shop_manager role or higher to pass a crafted serialized payload into a deserialization sink, enabling arbitrary PHP object instantiation that can escalate to code execution or data tampering if a usable gadget chain exists in the surrounding WordPress/WooCommerce stack. The issue is rated CVSS 7.2 (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), reflecting high impact but a high-privilege, backend-only prerequisite rather than unauthenticated exposure. There is no public exploit identified at time of analysis, and the plugin has not been confirmed as exploited in the wild; exploitation additionally requires WooCommerce to be installed and active and the plugin to remain at a vulnerable version.

PHP object injection in the Photo Gallery by 10Web WordPress plugin (versions up to and including 1.8.46) allows an authenticated user with Contributor-level privileges to pass crafted serialized data into a plugin code path that calls unserialize(), which under CVSS 3.1 scores 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Successful exploitation can corrupt or disclose data and, if a usable PHP gadget chain exists in the plugin, WordPress core, or another active plugin, can escalate to arbitrary code execution on the web server; no user interaction is required once the low-privileged account exists. At the time of analysis there is no CISA KEV listing and no public exploit code identified, and authentication as Contributor or higher is a firm prerequisite, so exposure is concentrated on sites that grant Contributor+ roles to untrusted users or leave open registration enabled.

PHP object injection in the WordPress plugin Nested Pages (wp-nested-pages, by Hook & Filter) in versions up to and including 3.3.2 lets an attacker who holds at least a Contributor-level account on the affected site submit crafted serialized data that is passed to PHP's unserialization logic, which can lead to arbitrary object instantiation and, where a usable POP gadget chain exists, to code execution, data theft, or full site compromise. The reported base score of 9.8 (AV:N/AC:L/PR:N/UI:N) is inconsistent with the vendor's own 'Contributor PHP Object Injection' designation; the authoritative assessment re-scores the issue as AV:N/AC:H/PR:L/UI:N, reflecting that a low-privileged authenticated WordPress account is a hard prerequisite and that RCE depends on gadget availability rather than being guaranteed. No public exploit code was identified at time of analysis and there is no CISA KEV listing, so this is not confirmed as actively exploited; exploitation is realistically limited to sites where open registration or loosely managed Contributor accounts give an outsider a foothold.

PHP object injection in the Schema & Structured Data for WP & AMP plugin (all versions up to and including 1.66) lets an authenticated attacker with a Contributor-level WordPress account feed crafted serialized input into a plugin deserialization path, and the vendor's CVSS 3.1 vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8 High) rates that as low-complexity, network-reachable and capable of full confidentiality, integrity and availability impact once a usable POP gadget chain is available in the plugin, WordPress core or another installed component. Authentication is mandatory and there is no unauthenticated route, but no user interaction is required after the attacker holds a qualifying account; the practical exposure therefore depends on whether the site permits open registration or loosely manages Contributor roles. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, so the primary risk is post-authentication privilege escalation rather than opportunistic mass exploitation.

PHP object injection in Page Builder by SiteOrigin (siteorigin-panels) version 2.36.0 and earlier allows an authenticated WordPress user holding high privileges - an Administrator or the Editor-level role implied by the advisory - to supply crafted, serialized content through the page-builder editor that the plugin then deserializes, yielding high confidentiality, integrity and availability impact (CVSS 3.1 7.2, AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H). Because the flaw is a CWE-502 deserialization issue, weaponization into full remote code execution depends on a usable PHP POP gadget chain being present in the plugin, WordPress core, or another installed component, so the practical worst case is conditional rather than guaranteed. There is currently no evidence of active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis, but the high-privilege authentication prerequisite is the main barrier to mass abuse, not the technical difficulty - low-privilege or anonymous users cannot reach it.

Authenticated low-privilege users can exploit a deserialization flaw in the MediaWiki Wikibase extension (versions 1.43, 1.45, and 1.46) to potentially execute arbitrary code, but exploitation is gated by high attack complexity, a specific precondition, and victim interaction. The vulnerability (CWE-502) allows untrusted serialized data to be processed, leading to code execution in non-executable files. A proof-of-concept exploit may exist (CVSS 4.0 E:P), but there is no confirmed active exploitation (not in CISA KEV).

Unauthenticated remote code execution affects LightLLM through 1.2.0 when it is deployed in visual_only (multimodal/vision) mode, which exposes an RPyC inference service that performs no authentication and unpickles the arguments passed to its remote_infer_images method. Any attacker who can reach that visual RPyC port can send a crafted object whose __reduce__ method runs on the server, achieving code execution with the privileges of the LightLLM service account and resulting in high confidentiality, integrity, and availability impact (CVSS 4.0 base 9.3; independently assessed as CVSS 3.1 AV:N/AC:L/PR:N/UI:N with high C/I/A). Text-only LightLLM deployments do not expose the affected service, no public exploit code has been identified at time of analysis, and real-world exposure hinges on whether the visual RPyC port is bound to an untrusted-reachable interface rather than to localhost or an isolated network.

Unauthenticated PHP object injection (CWE-502) in the WordPress plugin Booking Activities, affecting versions through 1.18.7.1, allows remote attackers to reach plugin endpoints and pass attacker-controlled data into PHP unserialize() with no authentication or user interaction required (CVSS 3.1 9.8, AV:N/AC:L/PR:N/UI:N). Potential impact includes code execution, file read/write, or denial of service, but real-world severity depends on the presence of a usable POP gadget chain in the plugin, WordPress core, or another loaded plugin/theme. No public exploit code or confirmed active exploitation was identified at time of analysis.

PHP object injection in the Themefic Ultimate Addons for Contact Form 7 WordPress plugin (versions through 3.5.51) allows an authenticated user holding the Editor role to feed crafted serialized data into a plugin code path that calls PHP's unserialize, which can lead to code execution, file operations, or data tampering if a viable POP gadget chain exists in the plugin or elsewhere on the site. The issue is network-reachable and needs no user interaction, but exploitation is access-gated by the Editor-privilege prerequisite, and no public exploit code has been identified at time of analysis; EPSS data was not provided.

PHP object injection in the WordPress plugin Content Egg through version 6.3.1 allows an attacker who holds the Shop manager role to trigger unsafe deserialization of attacker-controlled data, potentially leading to full site compromise. The vulnerability is network-reachable with low attack complexity and requires no user interaction, but the PR:H rating in the CVSS vector means a valid authenticated account at the Shop manager privilege level is a prerequisite, and meaningful code-execution impact further depends on the presence of a usable PHP POP gadget chain in Content Egg or another loaded plugin or theme. No public exploit code has been identified at time of analysis, and there is no indication that the flaw is being actively exploited in the wild.

Authenticated Contributor-level users can exploit a PHP Object Injection vulnerability in Themify Builder versions up to and including 7.8.1. The flaw, caused by unsafe deserialization (CWE-502), allows an attacker with a Contributor account to inject a serialized PHP object, potentially leading to remote code execution or full site compromise if a usable PHP gadget chain exists in the WordPress installation. The vendor-assigned CVSS score is 8.8 (High), and no public exploit code has been identified at the time of analysis.

PHP object injection in the Implecode eCommerce Product Catalog plugin for WordPress (3.6.0 and earlier) allows an authenticated attacker holding a high-privilege custom role to feed crafted serialized data into PHP's unserialize(), enabling arbitrary object instantiation that can escalate to remote code execution where a usable POP gadget chain exists in loaded code. Rated CVSS 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), it carries full confidentiality, integrity and availability impact, but is access-gated: the high-privilege custom role requirement (PR:H) means anonymous and low-privileged users cannot reach the vulnerable path, so this is a genuine but access-gated risk rather than an internet-wide exposure. No public exploit identified at time of analysis.

PHP object injection in WP ERP 1.17.9 and earlier allows an authenticated high-privilege user to execute arbitrary code or otherwise compromise a WordPress site via deserialization of untrusted input in the plugin's custom role functionality. The CVSS 3.1 base score is 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), reflecting network reachability, no user interaction, and high confidentiality, integrity, and availability impact, but the flaw is gated behind a high-privilege prerequisite (PR:H). No public exploit identified at time of analysis; exploitation also requires a reachable POP gadget chain.

PHP object injection in the quantumcloud Conversational Forms for ChatBot WordPress plugin (versions through 1.5.0) lets any authenticated Subscriber-level user reach full confidentiality, integrity, and availability impact, matching the High 8.8 CVSS 3.1 score (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The attack is remote, low-complexity, and requires no user interaction, but real-world severity depends on whether WordPress core or other installed plugins supply a usable PHP POP gadget chain that turns object injection into code execution or destructive file/database operations. No KEV or public-exploit signal was present in the supplied intelligence, so active exploitation is not confirmed from this data.

PHP object injection in the WordPress plugin DesignSetGo 2.8.0 and earlier allows an authenticated user with Contributor-level access to submit a crafted serialized payload, which the plugin then deserializes, potentially leading to data theft, file manipulation, or remote code execution depending on which PHP gadget chains are reachable in the site's loaded code. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8) confirms remote, low-complexity exploitation requiring only a low-privileged authenticated account and no user interaction, and the impact is assessed as high across confidentiality, integrity, and availability - though the practical outcome depends on the presence of a usable gadget chain. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV (not confirmed actively exploited); no EPSS score was supplied, but the self-registerable nature of the Contributor role on many sites keeps the real-world risk elevated.

PHP object injection in the WordPress plugin Go Live Update Urls (Mat Lipe) version 7.0.8 and earlier allows an authenticated attacker holding at least the Contributor role to pass crafted serialized data that the plugin deserializes, potentially leading to full confidentiality, integrity, and availability impact on the affected site if a usable PHP gadget chain is present in the plugin, WordPress core, or another installed theme/plugin. The vulnerability is network-reachable with low attack complexity, requires only low-privileged authentication (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H = 8.8 High) and no user interaction; exploitation additionally depends on the availability of a viable POP gadget chain, a common but not universal precondition. At the time of analysis there is no public exploit identified and no confirmation of active exploitation (not listed in CISA KEV), and no vendor-released fixed version is confirmed in the available data. Risk triage should treat this as a high-priority issue for any site running the vulnerable plugin where Contributor accounts are easily obtainable (for example, open self-registration).

PHP object injection in Kadence WooCommerce Email Designer (versions up to and including 1.5.19.1) lets an authenticated account holding the WooCommerce 'Shop manager' role pass attacker-controlled serialized data into a PHP unserialize() path, potentially leading to arbitrary file manipulation, data disclosure, or remote code execution if a suitable property-oriented programming gadget chain exists in the loaded codebase. The flaw carries a CVSS 3.1 base score of 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), so it is network-reachable without user interaction but is firmly privilege-gated behind high-privilege store management access rather than anonymous exploitation. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the practical ceiling of impact depends on which gadget chains are present alongside the plugin.

PHP object injection in the Responsive Slider Gallery WordPress plugin (versions up to and including 1.5.5) lets an authenticated Editor-level user pass crafted serialized data into an unsafe unserialize() call, potentially triggering arbitrary object instantiation and, given a usable POP gadget chain, file manipulation or remote code execution. The CVSS 3.1 vector (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, 7.2) confirms network reachability and full confidentiality, integrity, and availability impact, but the high-privilege prerequisite excludes anonymous or subscriber-level attackers. No public exploit code has been identified at time of analysis and the vulnerability is not reported as actively exploited (no CISA KEV entry); the plugin's limited deployment footprint further narrows the exposed population.

PHP object injection in the 10Web Booster WordPress plugin (versions up to 2.33.6) allows an authenticated Contributor to inject a malicious PHP object, potentially leading to remote code execution if a suitable gadget chain is present. The vulnerability is network-exploitable, requires no user interaction, and has a CVSS score of 8.8, but exploitation depends on the availability of a POP chain within the plugin or other installed components. No public exploit code has been identified at time of analysis.

PHP object injection in the WordPress plugin SEO Plugin by Squirrly SEO (through version 14.2.5) allows an authenticated attacker with only Contributor-level access to feed crafted serialized data into PHP's unserialize(), which can escalate to remote code execution, arbitrary file operations, or SQL injection if a usable POP gadget chain is reachable in the plugin, WordPress core, or another installed plugin. The flaw scores CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), so it is a genuine high-priority issue, but the practical blast radius depends on two prerequisites: the site must permit untrusted or self-registered Contributor accounts, and a viable gadget chain must exist. No public exploit code has been identified at time of analysis and the vulnerability is not known to be actively exploited (not in CISA KEV); it is not exploitable by fully unauthenticated visitors.

PHP object injection in Cost of Goods for WooCommerce versions up to 3.5.2 allows an authenticated attacker with the WooCommerce Shop Manager role to submit crafted data that is unsafely deserialized, potentially achieving full confidentiality, integrity, and availability impact. The issue is rated CVSS 7.2 (High) and requires PR:H, so exploitation is limited to trusted staff or attackers who already control a Shop Manager account; no public exploit code or CISA KEV entry is present in the provided data. Successful exploitation further depends on a reachable POP gadget chain in the plugin, WooCommerce, WordPress core, or another installed plugin.

PHP object injection in the Minimum and Maximum Quantity for WooCommerce plugin (versions up to and including 2.1.2) lets an authenticated user holding Author-level privileges or higher feed attacker-controlled serialized data into an unsafe PHP deserialization path on WordPress sites that also run WooCommerce. Per the assessed CVSS 3.1 vector (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, base 7.2), impact is rated full across confidentiality, integrity and availability, but the high-privilege prerequisite (PR:H) excludes anonymous visitors and typical subscriber/customer accounts, and meaningful impact additionally depends on a usable PHP object-injection gadget chain being present in the plugin, WooCommerce, or WordPress core. No public exploit identified at time of analysis, and the issue is not confirmed actively exploited (not in CISA KEV).

PHP object injection in the Music Player for WooCommerce WordPress plugin (versions 1.9.1 and earlier) lets an authenticated user who holds the WooCommerce 'Shop manager' capability pass attacker-controlled serialized data into PHP's object deserialization path, which under the right conditions can lead to full compromise of the site's confidentiality, integrity, and availability. The issue requires WooCommerce to be installed and active, and the CVSS 3.1 base score of 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) is driven by the complete C/I/A impact typical of exploitable object injection but is tempered by the elevated PR:H role requirement and by the practical need for a reachable PHP gadget chain. No public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (not listed in CISA KEV), so real-world risk is concentrated on sites where shop-manager accounts are broadly distributed or not tightly controlled.

Unauthenticated remote code execution affects Digiwin EasyFlow .NET, which deserializes attacker-supplied serialized content on the server without validating the incoming type information (CWE-502). Any network-reachable instance can be compromised by a remote attacker with no credentials and no user interaction, per the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H) and the independent assessment (CVSS 3.1 9.8, S:U/C:H/I:H/A:H), yielding full confidentiality, integrity, and availability impact. No public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV; practical exposure is instead bounded by whether the EasyFlow .NET service is internet-facing and by the product's predominantly regional (Taiwan) install base, though the attacker must first know or discover the endpoint that accepts the serialized payload.

Arbitrary code execution in WatchGuard Fireware OS is possible through its SAML single sign-on session daemon (samld), which deserializes session files it is asked to load without adequately validating their contents. The attacker must already be authenticated with high privileges (CVSS 4.0 vector PR:H) and must already be able to write files on the appliance, since the vector's AT:P metric and the description both indicate a required prior condition - this is a second-stage, post-foothold vulnerability rather than a standalone remote compromise. Exploitation yields code execution in the security context of the samld service, with high confidentiality, integrity and availability impact to that service but no demonstrated impact on subsequent systems (SC:N/SI:N/SA:N); no public exploit code and no confirmed active exploitation were identified at time of analysis.

Unauthenticated remote code execution affects ModelTC LightLLM through version 1.2.0 when it is run in a multimodal deployment configuration, which starts an embed-cache RPyC service bound to all network interfaces with pickle deserialization enabled. Because the service performs no authentication and accepts attacker-controlled serialized objects through its exposed cache methods, any remote party that can reach the RPyC port can execute arbitrary code with the privileges of the LightLLM service (CVSS 4.0 base score 9.3; AV:N/AC:L/AT:N/PR:N/UI:N with high confidentiality, integrity, and availability impact). Exposure is configuration-dependent: non-multimodal deployments do not start this service, and instances whose port is bound to loopback or blocked by firewall rules on the host or network are not remotely reachable. No public exploit code has been identified at time of analysis, and the issue has been reported publicly by VulnCheck (also tracked in the project's GitHub issue #1596), so the primary risk is rapid weaponization against internet-facing multimodal inference deployments that have not been patched or isolated.

Remote code execution in LightLLM through 1.2.0 allows unauthenticated attackers to run arbitrary code on the host when the server is launched with the --enable_profiling flag, because that flag starts a router profiler service that exposes an RPyC listener with pickle deserialization enabled and no authentication (CVSS 4.0 base 9.3; CWE-502). The flaw is not reachable in a default deployment since profiling must be explicitly enabled, but once it is on, any network-reachable attacker can push crafted serialized objects onto the profiler command queue and gain high-integrity, high-availability code execution without credentials or user interaction (PR:N/UI:N). There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV, so exposure is currently driven by the non-default profiling configuration and network reachability of the RPyC port rather than by active exploitation.

Denial of service in MobilityDB 1.3.0 and earlier allows an authenticated PostgreSQL database user with the MobilityDB extension installed to crash the backend process - and thereby terminate all sessions on that instance - by supplying a crafted Well-Known Binary (WKB) payload with a negative length field. Exploitation requires only a valid low-privileged database login (CVSS AV:N/PR:L) and the ability to invoke a binary input path such as ttextFromBinary, ttextFromHexWKB, COPY ... BINARY, or binary-protocol parameters; no public exploit code has been identified at time of analysis. Vendor patches are available in MobilityDB v1.3.1 and v1.2.2.

Deserialization of untrusted data in the GluonTS model-loading component allows arbitrary OS command execution with the privileges of the loading process when a victim loads a crafted serialized model directory in versions before 0.17.0. The flaw is scored 8.4 under CVSS 4.0 (assessed as CVSS 3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), meaning no authentication is required but exploitation is local and depends on a user actively loading the malicious model artifact; the attacker must first place that artifact in the victim's load path (untrusted model hub, shared directory, or compromised pipeline), and environments that only load self-generated trusted models are not affected. AWS has released a fix in GluonTS 0.17.0 (upstream PR #3304, '[Security] Resolve security issue for torch.load'), and no public exploit code and no confirmed active exploitation were identified at time of analysis; EPSS data was not provided for this CVE.

Authenticated remote code execution in Octopus Server allows any user whose role grants permission to edit an Environment or a Project to store specifically crafted JSON on that object, which the server then deserializes insecurely and executes as arbitrary code inside the Octopus Server process. Exploitation requires a valid account and that specific edit permission but no user interaction and no non-default configuration, and it delivers full loss of confidentiality, integrity, and availability to the deployment platform; the practical threat comes from malicious insiders, over-provisioned users, or attackers who have already compromised an account holding Environment/Project edit rights. No public exploit code has been identified at time of analysis, and the vendor has published advisory SA2026-10 covering the issue.

PHP object injection in the ConvertPlus WordPress plugin (all versions through 3.6.3) allows any authenticated attacker at Subscriber level or above to reach the cp_display_preview_modal AJAX action, bypass its nonce guard simply by omitting the cp_admin_page_nonce parameter (the isset() check fails open and no capability check is performed), and inject a second attacker-controlled [smile_modal] shortcode via the style parameter that ultimately feeds attacker-supplied base64-decoded bytes into maybe_unserialize() with no allowed_classes restriction. The object-injection primitive is inert by itself - ConvertPlus ships no usable POP gadget chain - so real impact such as arbitrary file deletion, sensitive data disclosure, or code execution requires a separate installed plugin or theme that provides a compatible chain. No public exploit code or confirmed active exploitation was identified at time of analysis, and the assessed vector (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8) reflects the low-privilege login requirement and the strong third-party gadget-chain dependency rather than automatic compromise.

Arbitrary code execution in Google Cloud Application Integration (versions prior to 2026-06-28) allows an authenticated user holding only standard permissions to run code on shared, multi-tenant production servers by crafting a JavaScript Task script that bypasses the platform's built-in parameter guards and reaches an unsafe deserialization path. The CVSS 4.0 base score is 9.4, and because the flaw breaches the tenant trust boundary the subsequent-system metrics are also High, meaning other customers on the same shared infrastructure are exposed rather than just the attacker's own tenant. Authentication is required (CVSS vector PR:L), there is no public exploit identified at time of analysis, and Google remediated the issue entirely server-side on 28 June 2026, so no customer action is needed and the vulnerability is no longer exploitable against the managed service.

Deserialization of untrusted data in MONAI's auto3dseg utility (monai/auto3dseg/utils.py) allows arbitrary code execution when algo_from_pickle() is called on an attacker-supplied .pkl file: the function reads the raw file bytes and hands them to pickle.loads() without any source or content validation, so any object defining __reduce__ runs in the victim application's context. Exploitation is conditional rather than remote-against-a-service: an attacker must first deliver a malicious pickle (model exchange, shared storage, or a pipeline input) and the victim's code must invoke this specific function, and per the authoritative assessment the vector is local with user interaction required (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) rather than unauthenticated network exploitation. A working proof-of-concept is documented in the upstream GitHub advisory GHSA-89gg-p5r5-q6r4 (publicly available exploit code exists), but there is no confirmed active exploitation (CISA KEV).

Arbitrary code execution in MONAI versions prior to 1.6.0 occurs when a crafted .npy or .npz file is loaded through the NumpyReader class, which hardcodes numpy.load with allow_pickle=True. An unauthenticated attacker who can place a malicious file on a path the victim opens can trigger pickle deserialization, leading to full compromise of confidentiality, integrity, and availability. Exploitation requires user interaction (the victim must load the file) and the attack vector is local; no public exploit code has been identified at time of analysis.

Deserialization of attacker-controlled pickle data in MONAI's Auto3DSeg module (monai/auto3dseg/utils.py) lets code run inside any process that calls algo_from_pickle() on a file the attacker can supply or substitute, with full read/write/execute impact on that process and its data. Versions before 1.6.0 are affected (pip package monai < 1.6.0, CPE cpe:2.3:a:project-monai:monai); the vulnerable pickle.loads() at line 321 fires before any isinstance or key checks, so no special configuration flag is needed to reach the sink. The exposure is conditional rather than remote: the vector is local (AV:L) with passive user interaction (UI:P) - a victim, typically a medical-imaging or ML pipeline exchanging algorithm bundles or model checkpoints, must load the crafted .pkl file, and no authentication is required on the loading side (PR:N) - scored 8.5. There is no evidence of confirmed active exploitation (no CISA KEV entry), but publicly available exploit code exists: the upstream advisory ships a working proof-of-concept, and users who upgraded to v1.5.2 believing GHSA-89gg-p5r5-q6r4 fixed this remain fully vulnerable because that earlier patch was never actually implemented in the code.

Local code execution in MONAI 1.6.0 and all released versions allows an authenticated low-privileged local attacker to run arbitrary code as another user by writing a malicious pickle file to a shared or world-writable MONAI cache directory (e.g., /tmp/monai_cache, HPC scratch, ~/.cache/monai). The victim must subsequently run a PersistentDataset pipeline that caches MetaTensors (the default in MONAI >= 1.0), which forces torch.load(weights_only=False) and pickle.loads on the poisoned file. No vendor-released patch identified at time of analysis; no public exploit identified at time of analysis.

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

Heap out-of-bounds reads in pgPointcloud through 1.2.5 allow an authenticated PostgreSQL user who can supply or store pcpatch values to copy bytes from adjacent backend heap memory into a persisted patch, enabling information disclosure or a backend crash (CVSS 4.0 base 7.2, CWE-125). The defect lives in dimensional patch WKB deserialization, where an attacker-controlled dimension size field is trusted without being validated against the remaining buffer length; exploitation requires a valid database session, the pgPointcloud extension installed, and the ability to insert or construct pointcloud-typed values. No public exploit code has been identified at time of analysis, the issue is not in CISA KEV, and an upstream fix is available via pull request 388.

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

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

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

Crafted DNS traffic parsed by the nDPI 5.1.0 deep-packet-inspection library can terminate the hosting process wherever that code runs on a strict-alignment CPU (ARM, MIPS, SPARC and similar) or in an UndefinedBehaviorSanitizer/fuzzing build, because the DNS dissector and the serializer deserialization path dereference byte buffers at arbitrary packet offsets through uint16_t/uint32_t/uint64_t pointers without any alignment check. The flaw is remotely reachable and unauthenticated (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5), but impact is limited to availability - process termination, no confidentiality or integrity loss - and the decisive precondition is the build/CPU target: mainstream x86-64 release builds silently tolerate the misaligned load and generally will not crash. It is not listed in CISA KEV and no public exploit identified at time of analysis, although the upstream fix PR does ship fuzz corpus inputs (issue3213_trigger1-3) that reproduce the fault, and EPSS data was not available for this record.

PHP Object Injection in the Reycob Product Import Export plugin (versions up to and including 2.3.0) allows an authenticated attacker with the WooCommerce 'Shop manager' role or higher to submit crafted serialized data, potentially achieving arbitrary code execution if a suitable POP gadget chain is present in the loaded PHP codebase. The vulnerability is network-exploitable (CVSS 3.1: 7.2 HIGH, AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) and requires no user interaction, but the high-privilege requirement limits exploitation to trusted roles. No public exploit code or active exploitation has been identified at the time of analysis.

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

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

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

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

Denial of service in FasterXML jackson-databind allows unauthenticated remote attackers to exhaust CPU resources by submitting crafted JSON that triggers quadratic complexity in forward-reference resolution for @JsonIdentityInfo object IDs. The attack requires the application to deserialize attacker-influenced JSON into a collection or map configured with @JsonIdentityInfo; a shallow document with N forward references defined in reverse order causes O(N^2) identity comparisons during deserialization. This is a conditional availability risk-only applications using identity-enabled deserialization on untrusted input are exposed-and no public exploit code has been identified at time of analysis, though a vendor patch is available.

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

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

Authenticated remote code execution in openEQUELLA releases before 2026.1.0 lets any logged-in non-guest user execute arbitrary code on the server by sending a crafted serialized Java object to the HTTP invoker endpoint at /invoker/*. The flaw is a denylist bypass: the class-name filter in PluginAwareObjectInputStream is evaded by wrapping a malicious payload inside a java.security.SignedObject, whose inner stream is handled by a separate ObjectInputStream that never applies the denylist, ultimately routing into a JNDI lookup sink. No public exploit identified at time of analysis and the vulnerability is not in CISA KEV; the practical barrier is only the low-privilege account requirement (PR:L per the assessed CVSS:3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, scored 8.7 under CVSS 4.0), which is trivial to satisfy on instances that permit self-registration or broad SSO/LDAP provisioning.

Unauthenticated remote code execution in SolarWinds Observability Self-Hosted (CVSS 8.8) allows attackers on an adjacent network to execute arbitrary code via deserialization of untrusted data, but only when the deployment is configured to use a specific non-default communication mode. Default-configured instances are not exploitable, and the adjacent-network attack vector (AV:A) further narrows the exposed population. No public exploit code has been identified at time of analysis, and no credentials or user interaction are required once the mode is enabled and reachable.

Remote code execution in Softaculous Virtualizor before 3.2.9 Patch 9 (and the 3.0.0 line) allows unauthenticated remote attackers to execute arbitrary commands as root by exploiting a PHP object injection flaw in the billing module handler, where untrusted serialized data in the billing_data POST field is passed to unserialize() without allowed_classes restrictions. Publicly available exploit code exists. Our assessment rates this 9.8 on CVSS 3.1 (AV:N/AC:L/PR:N/UI:N), while the vendor's CVSS 4.0 score is 9.2 (AC:H), reflecting the dependency on a reachable POP chain; no authentication or user interaction is required.

Authenticated code execution in Sentry's relocation import worker lets a user with a valid account on an affected instance run arbitrary code in the worker process by uploading a crafted relocation archive. Only instances that have explicitly enabled the relocation (backup import/export) feature are exposed, since that feature is disabled by default in self-hosted installations; affected versions run from 23.11.0 up to but not including 26.7.0, which contains the fix. Severity is high (7.7 under CVSS 4.0), requires authenticated access and a non-default feature flag, and no public exploit has been identified at time of analysis.

Deserialization-based code execution is possible in MISP because PHP's phar stream wrapper is left registered in both the web entry point (app/webroot/index.php) and the console entry point (app/Console/cake.php), so any filesystem call on a caller-influenced path that resolves to a phar archive silently triggers an unserialize() of attacker-controlled metadata, or can reach executable code inside an uploaded phar under a relocated application root. The vendor's fix (commit 08fa755b6) simply unregisters the wrapper at startup, confirming that nothing in MISP, vendored CakePHP, or runtime libraries legitimately uses phar archives. Real-world risk is lower than the 7.7 CVSS 4.0 score suggests: the vector requires authentication (PR:L - a valid MISP account) and High attack complexity (AC:H), because no MISP/CakePHP/library code natively feeds a caller-influenced path into a phar-resolving operation, so a separate path-influence bug must be chained and no public exploit code has been identified at time of analysis.