Insecure Deserialization

Unauthenticated PHP Object Injection in the Ultimate Maps by Supsystic WordPress plugin (all versions before 1.5.0) lets remote attackers pass attacker-controlled serialized data into a PHP unserialize() call, instantiating arbitrary PHP objects. If a usable POP (property-oriented programming) gadget chain is present in the plugin, WordPress core, or any other active plugin, this can escalate to remote code execution, file operations, or database compromise. Reported by Patchstack and assigned CVSS 9.8; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.

Unauthenticated PHP object injection affects the Easy Google Maps WordPress plugin (vendor Supsystic) in all versions up to and including 1.13.0, letting remote attackers submit arbitrary serialized PHP objects that the application deserializes. Reported by Patchstack and rated CVSS 9.8, the flaw can escalate to remote code execution, data theft, or full site takeover when a suitable property-oriented programming (POP) gadget chain is present in the plugin, WordPress core, or another active extension. No public exploit is identified at time of analysis, and the issue is not listed in CISA KEV.

Unauthenticated PHP Object Injection in the RegistrationMagic WordPress plugin (versions <= 6.0.9.7) allows remote attackers to inject crafted serialized PHP objects that are deserialized by the application without validation. Depending on the POP gadget chains available in the plugin, WordPress core, or other installed plugins, this can escalate to arbitrary file operations, SQL injection, or remote code execution. Reported by Patchstack with a CVSS 9.8; no public exploit identified at time of analysis and no CISA KEV listing, so exploitation is not confirmed in the wild.

PHP Object Injection in the OptionTree WordPress plugin (versions <= 2.7.3) enables authenticated administrators to submit crafted serialized PHP data through the plugin's Editor interface, triggering dangerous deserialization that can culminate in arbitrary code execution on the host server. The CVSS vector (PR:H) confirms that exploitation is gated behind WordPress administrator credentials, constraining the immediate threat surface. No public exploit code or active exploitation has been identified at time of analysis.

Unauthenticated PHP Object Injection in the FundEngine WordPress fundraising/donation plugin (slug wp-fundraising-donation) affects all versions up to and including 1.7.9, letting a remote attacker with no authentication inject a crafted serialized PHP object into an application deserialization sink. Given the CWE-502 root cause and the PR:N/UI:N vector, a successful attack can pivot to remote code execution, data theft, or full site takeover when a suitable POP gadget chain is reachable. Reported by Patchstack and rated CVSS 9.8, with no public exploit identified at time of analysis and no CISA KEV listing.

PHP Object Injection in the Essential Real Estate WordPress plugin (≤ 5.3.3) by g5theme allows low-privileged authenticated users to pass a crafted serialized PHP object through a vulnerable unserialize() call, potentially triggering arbitrary code execution if a usable POP (Property-Oriented Programming) gadget chain exists within the WordPress installation. The CVSS 8.8 score reflects full confidentiality, integrity, and availability impact - realistic in WordPress environments where co-installed plugins routinely supply gadget chains. No public exploit code or active exploitation (CISA KEV) has been identified at the time of analysis.

Unsafe deserialization in Progress ShareFile Storage Zones Controller v5.12.5 and below exposes the controller host to arbitrary code execution by any low-privileged user holding write access to a connected network share. Rooted in CWE-502 (Deserialization of Untrusted Data), the flaw processes attacker-controlled file metadata without integrity validation, yielding full host compromise with high confidentiality, integrity, and availability impact. No public exploit code has been identified at time of analysis, and the vulnerability is not currently listed in the CISA Known Exploited Vulnerabilities catalog.

Arbitrary file deletion leading to remote code execution in the Podlove Podcast Publisher WordPress plugin (all versions through 4.5.3) allows authenticated contributors to destroy critical server files and fully compromise the WordPress installation. The root cause is a PHP deserialization flaw in the shownotes REST API that activates a native POP chain via GenerationGuard::__destruct(), invoking wp_delete_file() on an attacker-controlled path - enabling deletion of wp-config.php to force WordPress into reinstallation mode. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, though the POP chain is explicitly mapped in the CVE with source code references, indicating high confidence in exploitability.

Privilege escalation in Dell Wyse Management Suite (WMS) versions prior to 2605.0.2 allows a low-privileged local attacker to fully compromise the host system through improper deserialization of untrusted data. The vulnerability carries a CVSS 7.8 High score with full confidentiality, integrity, and availability impact scoped to the vulnerable system. No public exploit code has been identified and EPSS places this at the 0th percentile for near-term exploitation likelihood; however, SSVC rates the technical impact as total, meaning successful exploitation results in complete system compromise for any attacker already holding local access.

Remote code execution in Apache Shindig (all versions) is reachable via the project's REST API, where deserialization of attacker-controlled input allows server-side arbitrary code execution. The vulnerability requires high-privilege API access (CVSS PR:H), limiting opportunistic exploitation, but every deployed instance is permanently exposed because the Apache Software Foundation has retired the project and will not release a fix. No public exploit or KEV listing has been identified at time of analysis, but the combination of RCE impact and no-patch status makes any continued deployment a long-term liability.

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.

Unauthenticated PHP object injection in the miniOrange Headless Single Sign On WordPress plugin (versions 1.6 and earlier) lets remote attackers pass attacker-controlled serialized data into a PHP unserialize() call, enabling property-oriented programming (POP) gadget chains that can lead to remote code execution, data theft, or site takeover. The flaw carries a CVSS 9.8 rating with a fully remote, no-authentication, no-interaction vector and was reported by Patchstack; there is no public exploit identified at time of analysis and it is not listed in CISA KEV. Because SSO plugins sit on the authentication path, a successful exploit can compromise the entire WordPress site.

PHP Object Injection in the Car Rental Manager WordPress plugin (versions ≤ 1.3.9, by MagePeople Team) enables authenticated editor-level users to supply malicious serialized PHP payloads that are deserialized without validation, potentially triggering arbitrary code execution on the host server. The CVSS 7.2 score reflects the high-privilege prerequisite (PR:H), yet all three impact dimensions — confidentiality, integrity, and availability — score High, meaning successful exploitation can yield full environment compromise. No public exploit has been identified at time of analysis, and active exploitation has not been confirmed by CISA KEV.

Unauthenticated SQL injection and remote code execution in Ash Framework (ash-project/ash) are achievable by any caller who can reach a keyset-paginated endpoint: the cursor deserializer accepts pre-interned Ash expression structs that bypass query filter guards, yielding SQL injection on AshPostgres deployments or in-process arbitrary code execution on ETS and Simple data layers. All ash versions 1.17.0 through 3.31.2 are exposed across both impact paths. No independently released exploit tooling is known at time of analysis, but the upstream fix commit contains a working proof-of-concept that reproduces the exact forged cursor technique, substantially shortening the path from disclosure to weaponization.

Unsafe deserialization in Apache Airflow 3.0.0 through 3.3.0 allows any DAG author to achieve arbitrary code execution in the Scheduler and API server by placing a crafted value in an operator's executor_config field. The serialization layer reconstructed exception nodes by calling import_string() on an attacker-controlled class name with no allowlist, enabling import and invocation of arbitrary callables such as subprocess.check_output or builtins.eval. Both affected components hold the metadata database credentials and JWT signing secret, making full infrastructure compromise a realistic outcome. No public exploit has been identified at time of analysis, but no non-default configuration is required. This is a distinct sink from CVE-2026-33264, meaning deployments that already patched that earlier advisory remain fully vulnerable and must upgrade again to apache-airflow 3.3.1.

Arbitrary code execution in Fujitsu Research's OneCompression (onecomp) Python library 1.2.0 is triggered when a victim loads a crafted PyTorch checkpoint file via the library's QuantizedModelLoader API, which unconditionally invokes Python's pickle machinery. The root cause is the hardcoded use of torch.load with weights_only=False in load_quantized_model_pt(), allowing an attacker-supplied checkpoint to embed malicious __reduce__ methods that execute arbitrary Python - including OS commands - in the context of the loading process. No public exploit code has been identified at time of analysis, though a patched version (1.2.1) is available on PyPI per the VulnCheck advisory.

Remote code execution and scheduler-process disruption in Apache Airflow 3.3.0 stems from unguarded deserialization of task instance `next_kwargs` during the scheduler's unconditional `awaiting_input` sweep, a code path introduced as part of the 3.3.0 human-in-the-loop task rewrite. Any authenticated DAG author who can influence task state through the task execution API can supply a crafted payload that causes arbitrary module import and object instantiation inside the scheduler process, or terminate the scheduler job entirely. No public exploit has been identified at time of analysis, but a vendor-released patch exists in 3.3.1; deployments that previously patched CVE-2026-58076 are still vulnerable through this distinct code path and must upgrade.

Unsafe deserialization in Apache Airflow 3.3.0's Task SDK allows an authenticated DAG author to cause arbitrary module imports inside the scheduler process. By controlling a task instance's `next_kwargs` via the task execution API, an attacker can inject a crafted callback path that the scheduler's unconditional `awaiting_input` timeout sweep deserializes by re-running the `SyncCallback` constructor - triggering an import of the named module in the scheduler's process space. Because `SyncCallback` is itself an Airflow class, it bypasses the `allowed_deserialization_classes` allow-list, making tightening that setting ineffective. No public exploit code or CISA KEV listing has been identified at time of analysis, but the CVSS score of 8.8 reflects the severity of the potential scheduler process compromise.

Insecure deserialization in SonicWall Global Management System (GMS) 9.5.1 (Build 9510.1044) and earlier enables a local attacker who can interact with the affected service to perform unauthorized actions resulting in full compromise of confidentiality, integrity, and availability. The root cause is CWE-502: the service deserializes attacker-controlled objects without adequate validation, allowing manipulation of application logic or execution of unintended code paths. No public exploit or CISA KEV listing has been identified at time of analysis; EPSS places exploitation probability in the 18th percentile, indicating low current exploitation interest despite a high CVSS score.

Unsafe deserialization of untrusted data in Adobe Lightroom Classic (versions ≤15.4.1) enables arbitrary code execution in the context of the authenticated user when a victim opens a specially crafted file. Classified as CWE-502, this file-format exploit carries a CVSS 3.1 score of 8.6 with changed scope (S:C), indicating impact extends beyond the Lightroom process itself to broader user-accessible system resources. No public exploit identified at time of analysis and no CISA KEV listing; Adobe has released a fix in version 15.5 via security bulletin APSB26-94.

Remote code execution in Microsoft Office SharePoint allows an attacker authenticated with low privileges to execute arbitrary code over a network via unsafe deserialization of user-controlled data. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) confirms full confidentiality, integrity, and availability impact with no user interaction required. No public exploit code has been identified at time of analysis, and SharePoint is not currently listed in the CISA KEV catalog based on available data.

Remote code execution in Microsoft Office SharePoint exploits unsafe deserialization of attacker-controlled data over the network. An authenticated attacker with low-level network access can submit a crafted serialized payload that SharePoint deserializes without sufficient validation, resulting in full compromise of confidentiality, integrity, and availability. No public exploit has been identified at time of analysis, but the low attack complexity and high impact across all three security properties make this a critical remediation priority.

Remote code execution in Microsoft Office SharePoint enables any authenticated low-privileged user to execute arbitrary code on the server by submitting maliciously crafted serialized data over the network. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) confirms the attack requires no user interaction, low complexity, and only a standard SharePoint account - making this straightforward to weaponize within any organization whose SharePoint is network-accessible to internal users or external authenticated parties. No public exploit code or CISA KEV listing is identified at time of analysis, though SharePoint deserialization vulnerabilities have historically attracted rapid weaponization.

Remote code execution in Microsoft Dynamics 365 on-premises is achievable by any authenticated low-privileged user via a crafted deserialization payload sent over the network, yielding full confidentiality, integrity, and availability compromise of the affected host. The root cause is CWE-502 (Deserialization of Untrusted Data), a class of vulnerability historically weaponized effectively in .NET-based enterprise applications through gadget chains. No public exploit code or CISA KEV listing was identified at the time of analysis, but the combination of low attack complexity, low privilege requirement, and high CIA impact makes this a credible, high-priority remediation target for organizations running Dynamics 365 on-premises.

Remote code execution in Microsoft SharePoint Server allows a network-authenticated attacker with low-level privileges to execute arbitrary code by exploiting unsafe deserialization of attacker-controlled data. Both SharePoint Server 2019 and the Subscription Edition are confirmed affected, with patches available from Microsoft. No public exploit code or CISA KEV listing has been identified at time of analysis, but the low complexity and full-triad impact (C:H/I:H/A:H) make this a high-priority patching target for enterprise environments.

Remote code execution in Microsoft SharePoint allows any authenticated, low-privileged network attacker to execute arbitrary code on the server by exploiting unsafe deserialization of attacker-controlled data (CWE-502). Three on-premises SharePoint Server product lines are confirmed affected - Enterprise Server 2016, Server 2019, and Server Subscription Edition - with fixed builds available from Microsoft. No public exploit code has been identified at time of analysis, but the low attack complexity and precedent of prior SharePoint deserialization CVEs being rapidly weaponized (e.g., CVE-2019-0604) make this a high-priority patching target for any organization running on-premises SharePoint.

Remote code execution in Microsoft SharePoint Server exposes organizations to full system compromise via deserialization of attacker-controlled data submitted over the network. Versions across three SharePoint Server editions (Subscription Edition, 2019, and Enterprise 2016) are confirmed affected, all requiring only a low-privileged authenticated account to exploit. No public exploit code or CISA KEV listing is identified at time of analysis, but the low attack complexity and high impact across confidentiality, integrity, and availability make this a critical-priority remediation item for any enterprise SharePoint deployment.

Remote code execution in Microsoft SharePoint Server allows any authenticated network attacker to execute arbitrary code by submitting a malicious serialized object payload to vulnerable endpoints. Three major SharePoint versions are affected - SharePoint Server 2016, 2019, and Subscription Edition - all running build versions below their respective patched thresholds. No public exploit code has been identified at time of analysis, but the low privilege requirement (any valid SharePoint account) and low attack complexity make this a high organizational priority, particularly given SharePoint's widespread enterprise deployment footprint.

Remote code execution in Microsoft SharePoint Server affects authenticated network users through unsafe deserialization of attacker-controlled data. Affected versions span SharePoint Server 2019, SharePoint Enterprise Server 2016, and SharePoint Server Subscription Edition - all running build numbers below the patched releases issued by Microsoft. An attacker with a valid low-privilege account can send a crafted payload over the network to trigger arbitrary code execution on the server without any user interaction, achieving full compromise of confidentiality, integrity, and availability. No public exploit code or CISA KEV listing is identified at time of analysis, but the low-complexity, network-reachable attack surface makes this a high-priority patching target.

Remote code execution in Microsoft High Performance Computing (HPC) Pack allows an unauthorized network attacker to run arbitrary code by submitting maliciously crafted serialized data that the product deserializes without validation (CWE-502). The flaw carries a CVSS 9.8 and requires no authentication or user interaction per the vector. A vendor patch is available; no public exploit has been identified at time of analysis.

Unauthenticated remote code execution in Dassault Systèmes SIMULIA Execution Engine (Release 2023 through Release 2026) allows a network attacker to run arbitrary code on the server by submitting a malicious serialized object that the application deserializes without validation. The flaw carries a maximum CVSS 3.1 base score of 10.0 and requires no privileges or user interaction, making any exposed instance fully compromisable. No public exploit code has been identified at time of analysis and it is not listed in CISA KEV, but the CWE-502 root cause combined with a network attack vector makes it a high-priority patching target.

Remote code execution via unsafe Java deserialization affects Red Hat Infinispan's session replication path, where the JBoss Marshalling River unmarshaller processes replicated session data from cluster peers with no class allowlist or filtering. Any attacker with adjacen-network access to the Infinispan cluster replication channel can inject a crafted serialized payload exploiting standard Java gadget chains, achieving arbitrary code execution on every cluster node that deserializes the replicated data. No public exploit has been identified at time of analysis, and this vulnerability has not been added to the CISA KEV catalog, though its adjacency requirement limits blast radius to attackers already positioned on the cluster network.

Unauthenticated remote code execution affects Feast (the open-source ML feature store), where user-defined functions stored in the registry are serialized with Python's 'dill' library and deserialized without validation. In default configurations a remote attacker can store a malicious UDF and achieve unauthenticated code execution on the feature server; an authenticated attacker can bypass authorization during deserialization to run code on the registry server, enabling cross-tenant data access and lateral movement. Rated CVSS 9.9 with a scope change; no public exploit has been identified at time of analysis, and it is not listed in CISA KEV. Feast is bundled in Red Hat OpenShift AI (RHOAI), which is the reporting vendor's affected product.

PHP object injection in the Newsletters WordPress plugin (all versions before 4.16) permits unauthenticated remote attackers to supply arbitrary serialized PHP objects through a public-facing form, bypassing class restrictions entirely. If a suitable PHP gadget chain is present in the WordPress environment - commonly introduced by co-installed plugins or PHP libraries - this can escalate to remote code execution, data exfiltration, or full site compromise. A publicly available exploit has been confirmed by WPScan; however, EPSS stands at 0.16% (5th percentile), indicating limited observed mass exploitation at time of analysis despite the public PoC.

Remote code execution in ZenML 0.94.6 allows any attacker with write access to a shared artifact store to plant a malicious cloudpickle payload that executes arbitrary system commands when a legitimate user or pipeline materializes the tampered artifact. The root cause is unsanitized deserialization via cloudpickle.load() in CloudpickleMaterializer without any integrity verification of the stored artifact.pkl file before loading. No public exploit code has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the attack is conceptually straightforward for any attacker with artifact store write access in a multi-user ZenML deployment.

Denial of service in the Go implementation of Apache Fory allows unauthenticated remote attackers to crash affected services by sending crafted serialized data containing malformed type metadata, triggering an uncaught Go runtime panic. Affected versions span 0.16.0 through 1.5.0 (exclusive), while all non-Go language implementations remain unaffected. No public exploit code or active exploitation (CISA KEV) has been identified; the EPSS score of 0.18% (8th percentile) corroborates low current exploitation activity despite the high CVSS base score.

Heap type confusion in the Apache Fory C++ deserialization engine (versions 0.14.0 up to but not including 1.5.0) lets a crafted payload bypass type-compatibility checks during polymorphic smart-pointer deserialization, so an object of an incompatible type is handled as its declared base type. Because CWE-502 untrusted-data handling here corrupts memory rather than merely mis-parsing values, an attacker who controls serialized input can trigger undefined behavior ranging from denial of service to arbitrary code execution. This is rated CVSS 9.8 and is fixed in 1.5.0; there is no public exploit identified at time of analysis and EPSS is low at 0.21%.

Out-of-bounds heap read in Apache Fory C++ versions 0.14.0 through 1.4.x allows attackers supplying crafted deserialization payloads to trigger information disclosure or denial of service. The flaw resides specifically in the tagged integer fast-path deserializer and only manifests when the application processes structs with tagged integer fields. No public exploit or active exploitation has been identified at time of analysis, and a vendor-released patch is available in version 1.5.0.

PHP Object Injection in the Ajax Search Lite WordPress plugin before 4.14.5 lets unauthenticated remote attackers pass untrusted serialized data into a PHP unserialize() sink, and where a suitable POP gadget chain exists in a co-installed plugin or theme, this escalates to remote code execution. Reported by WPScan with publicly available exploit code, it carries a CVSS 9.8 rating but a low EPSS of 0.22% (13th percentile), and is not listed in CISA KEV. A vendor patch is available in version 4.14.5.

Remote code execution in Microsoft Azure Service Bus lets an already-authorized (PR:L) attacker send maliciously crafted serialized data that the service deserializes without validation (CWE-502), executing attacker-controlled code across the network. The scope-changed CVSS 9.9 rating reflects that code execution can break out of the caller's authorization boundary into the underlying managed-service host, threatening confidentiality, integrity, and availability of the messaging infrastructure. There is no public exploit identified at time of analysis, but the near-maximal severity and cloud-hosted, multi-tenant nature of the platform make this a high-priority issue.

PHP Object Injection in the AI ANN WordPress theme (by AxiomThemes) affects all versions up to and including 1.29.0, allowing unauthenticated remote attackers to inject crafted serialized PHP objects that are deserialized by the theme. When a suitable POP (property-oriented programming) gadget chain is present in the theme, WordPress core, or an active plugin, this can escalate to remote code execution, arbitrary file operations, or data compromise. Reported by Patchstack; no public exploit identified at time of analysis, though the CVSS 9.8 rating reflects the unauthenticated, network-reachable nature of the flaw.

PHP Object Injection in the Agricola WordPress theme (versions ≤ 1.21.0 by AxiomThemes) lets unauthenticated remote attackers inject crafted serialized PHP objects that are deserialized by the application, and with a suitable POP gadget chain this can escalate to arbitrary file operations, SQL manipulation, or remote code execution. Rated CVSS 9.8 and disclosed by Patchstack (EUVD-2026-53878), it requires no authentication or user interaction. No public exploit identified at time of analysis and it is not listed in CISA KEV.

PHP Object Injection in the Agora WordPress theme (by AncoraThemes) affects all versions up to and including 1.9, allowing remote unauthenticated attackers to inject serialized PHP objects that are deserialized by the application. Because exploitation requires no authentication and no user interaction over the network, a successful attack can lead to full compromise (arbitrary code execution, data theft, or site takeover) when a suitable gadget chain is present in the theme or its plugin ecosystem. Reported by Patchstack (EUVD-2026-53996); no public exploit identified at time of analysis and the issue is not listed in CISA KEV.

PHP Object Injection in the AncoraThemes 'Advice' WordPress theme (versions up to and including 1.18.0) lets unauthenticated remote attackers pass attacker-controlled serialized data into an unsafe PHP deserialization sink (CWE-502). Because a suitable POP (property-oriented programming) gadget chain in the theme or a co-installed plugin can then be triggered, this can escalate to arbitrary file operations, data disclosure, or remote code execution. Rated CVSS 9.8; reported by Patchstack, with no public exploit identified at time of analysis.

Unauthenticated PHP Object Injection in the Adrena WordPress theme (AncoraThemes) affects all versions up to and including 1.2.14, allowing remote attackers with no authentication to inject crafted serialized PHP objects that are deserialized by the theme. Exploitation can lead to full compromise (confidentiality, integrity and availability all High) when a suitable gadget chain is present in the WordPress core, an active plugin, or another theme. This flaw carries a CVSS 9.8 rating and was disclosed by Patchstack; no public exploit code has been identified and it is not listed in CISA KEV, so there is no public exploit identified at time of analysis.

Unauthenticated PHP Object Injection in the Accalia WordPress theme (by AncoraThemes) affects all versions up to and including 1.5.3, allowing remote attackers to inject crafted serialized PHP objects that are deserialized by the application. When a suitable POP (property-oriented programming) gadget chain is present in the theme, its plugins, or WordPress core, this can lead to remote code execution, data disclosure, or site takeover. The issue was reported by Patchstack and carries a CVSS 9.8; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.

Unauthenticated PHP Object Injection in the Abogado WordPress theme (by AncoraThemes) affects all versions up to and including 1.18, allowing remote attackers to inject crafted serialized PHP objects without authentication. If a suitable POP (property-oriented programming) gadget chain is present in the theme, its bundled plugins, or WordPress core, this can escalate to arbitrary file operations, SQL injection, or remote code execution. Reported by Patchstack; no public exploit identified at time of analysis and the flaw is not listed in CISA KEV.

Insecure deserialization in the Abelle WordPress theme (ThemeREX) versions 1.22 and earlier lets unauthenticated remote attackers inject crafted PHP objects that the application deserializes, enabling PHP Object Injection. Because attacker-supplied serialized data reaches unsafe unserialize() logic without authentication, an adversary can potentially achieve remote code execution, data tampering, or full site compromise depending on available gadget chains in WordPress core, the theme, or co-installed plugins. There is no public exploit identified at time of analysis, but the flaw carries a CVSS 9.8 rating reflecting network-reachable, unauthenticated, high-impact exploitation.

PHP Object Injection in the A.Williams (Alisha Williams) WordPress theme by AxiomThemes affects all versions up to and including 1.3.1, allowing remote unauthenticated attackers to inject crafted serialized PHP objects into an unsafe deserialization sink. When a suitable POP gadget chain is present in the theme or co-installed plugins, this can escalate to arbitrary file operations, SQL injection, or remote code execution. No public exploit identified at time of analysis, and the vulnerability is not listed in CISA KEV; the 9.8 CVSS reflects theoretical worst-case impact rather than confirmed active exploitation.

Unauthenticated PHP Object Injection in the 69 Clothing WordPress theme (versions up to and including 1.2.11.1) lets remote attackers submit crafted serialized data that is unsafely deserialized, potentially triggering property-oriented programming (POP) gadget chains for code execution, data theft, or file manipulation. Reported by Patchstack and tracked as EUVD-2026-53989, it carries a critical CVSS 9.8 with no authentication required. There is no public exploit identified at time of analysis, but the network-reachable, unauthenticated nature makes it a high-priority patching target for any WordPress site running this theme.

PHP Object Injection in the WPBruiser {no- Captcha anti-Spam} WordPress plugin (versions ≤ 3.1.43) allows remote unauthenticated attackers to inject crafted serialized objects that are deserialized by the plugin, enabling arbitrary object instantiation and, when combined with a suitable POP gadget chain, code execution or data compromise. The flaw carries a CVSS 9.8 (AV:N/AC:L/PR:N/UI:N) and is reported by Patchstack (EUVD-2026-53983). No public exploit code was identified at time of analysis and it is not listed in CISA KEV, so there is no confirmed active exploitation.

PHP Object Injection in the Export User Data WordPress plugin (versions up to and including 2.2.6) allows attackers to inject crafted serialized objects that are deserialized by the plugin, potentially leading to remote code execution, data theft, or site takeover when a suitable POP gadget chain is present. Reported by Patchstack (EUVD-2026-53980) and rated CVSS 9.8, though the Patchstack title labels it a 'Subscriber' issue, implying a low-privileged account is actually required. There is no public exploit identified at time of analysis, and it is not listed in CISA KEV.

PHP Object Injection in Jeg Kit for Elementor (WordPress plugin, versions <= 3.2.10) allows authenticated attackers holding Author-level WordPress privileges to pass unsanitized input through PHP's deserialization mechanism, potentially triggering a Property-Oriented Programming (POP) chain present in the environment. If a suitable POP chain exists - contributed by the plugin itself, Elementor, or any co-installed dependency - the attacker can achieve remote code execution, arbitrary file manipulation, or full data disclosure on the WordPress host. No public exploit or CISA KEV listing has been identified at time of analysis, though Patchstack has formally catalogued the issue.

PHP Object Injection in the Ajax Search Lite WordPress plugin (versions ≤ 4.14.4) lets unauthenticated remote attackers pass attacker-controlled serialized data into a PHP unserialize() call, enabling object instantiation that - when paired with a suitable gadget chain in the plugin or wider WordPress runtime - can lead to remote code execution, data theft, or site takeover. Reported by Patchstack and tracked as EUVD-2026-53942, it carries a CVSS of 9.8 (fully unauthenticated network vector). No public exploit is identified at time of analysis, and it is not listed in CISA KEV.

Unsafe deserialization in Apache CXF's JMS transport allows any party able to publish to the service's JMS destination to achieve denial of service or, where a compatible deserialization gadget chain is present on the application classpath, remote code execution within the CXF process. All Apache CXF versions prior to 4.2.3, 4.1.8, and 3.6.12 are affected when the JMS transport is in use. No public exploit code or CISA KEV listing has been identified at time of analysis, though the vulnerability class (CWE-502 with unrestricted ObjectInputStream) is well-understood and tooling such as ysoserial makes it routinely exploitable wherever gadget libraries are present.

Remote code execution on the Jenkins controller is achievable by attackers holding Agent/Connect permission via a JEP-200 deserialization filter bypass in the Remoting library (agent.jar/remoting.jar). Jenkins 2.575 and earlier, and LTS 2.568.1 and earlier, include a Remoting version (3384.v60d89463d9e0 and earlier, except the backport 3355.3357.v931d3c992987) that fails to apply the JEP-200 class filter to a fallback deserialization code path, allowing crafted serialized Java objects to reach classes on the Jenkins core classpath that are not blocked by the pre-JEP-200 denylist. No public exploit or CISA KEV listing has been identified at time of analysis, but the primitive - controller-side code execution triggered from an agent - represents a critical trust-boundary violation in Jenkins' controller-agent architecture.

PHP Object Injection in Cotonti CMS's Comments plugin grants any authenticated member a deserialization primitive reachable via two default-accessible sinks, with a working POP chain already demonstrated by the researcher. The `ci` POST parameter in CreateAction.php and the `cb` parameter in EditAction.php are both base64-decoded and passed to `unserialize()` without an `allowed_classes` restriction, allowing instantiation of any class loaded in the PHP runtime. A proof-of-concept using Cotonti's built-in MySQL_cache class was confirmed to trigger attacker-controlled SQL INSERT operations via `__destruct()->flush()`; further impact including RCE is contingent on additional gadget chains available in a given installation. No public exploit code has been released and no CISA KEV listing exists at time of analysis.

Unsafe pickle deserialization in Hugging Face PEFT's LoRA-GA and CorDA initialization modules allows arbitrary code execution when a victim loads a malicious cache or covariance file. The affected code paths in corda.py (lines ~102 and ~163) and loraga.py (line ~101) call torch.load() without weights_only=True, bypassing the safe-loading wrapper that PEFT enforces elsewhere in the codebase. An attacker who can supply or substitute a pre-computed LoRA-GA or CorDA cache file - for example via a shared model repository or poisoned download - achieves full code execution in the victim's ML environment upon initialization. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.

Insecure deserialization (CWE-502) in Apache Lucy affects all versions of this retired full-text search engine library, allowing an attacker who can supply crafted serialized data to a Lucy-backed application to corrupt reconstructed object state and potentially achieve code execution or logic abuse during deserialization. Because Apache Lucy is retired, the ASF has explicitly declined to ship a fix, so exposure is permanent for any deployment still using it. There is no public exploit identified at time of analysis and the flaw is not listed in CISA KEV.

Unauthenticated remote code execution in MaxSite CMS is possible because the application passes attacker-controlled serialized data from the maxsite_comuser cookie directly into PHP's unserialize() without validation or class allowlisting. Any remote attacker can send a single crafted HTTP request carrying a malicious serialized PHP object to trigger property-oriented programming (POP) gadget chains and execute arbitrary code. The flaw was reported by VulnCheck and a vendor patch is available (MaxSite CMS 109.6); no public exploit code or CISA KEV listing is identified at time of analysis, though the CVSS 4.0 score of 9.3 reflects trivially triggerable, high-impact exploitation.

Deserialization of untrusted data in NVIDIA Dynamo for Linux (versions 0 through v1.1.0) exposes unauthenticated remote attackers to denial-of-service conditions and data integrity compromise. The flaw is rooted in CWE-502 - unsafe handling of externally supplied serialized objects - and carries a CVSS 8.2 score driven by a fully unauthenticated, low-complexity network attack vector. No public exploit code and no active exploitation have been identified at time of analysis, but the absence of authentication and configuration prerequisites makes the attack surface broad for any internet-accessible Dynamo deployment.

Remote code execution in kotaemon (Cinnamon) versions through 0.12.0 allows unauthenticated attackers to run arbitrary commands via the check_connection endpoint, which insecurely deserializes attacker-supplied YAML/JSON. By setting the __type__ field to subprocess.check_output with chosen arguments, an attacker instantiates arbitrary Python objects and executes OS commands with the application's process privileges. Publicly available exploit code exists (VulnCheck advisory and upstream issue), and the CVSS 4.0 base score is 9.3, though there is no public exploit identified as actively exploited.

Deserialization of untrusted data in TUBITAK BILGEM's eta-otp-lock (all versions before 1.0.4) enables object injection leading to full system compromise on affected hosts. The attack requires local access and user interaction with a malicious serialized payload, resulting in high confidentiality, integrity, and availability impact (CVSS 7.8). TR-CERT has confirmed the issue under advisory TR-26-0730; a vendor patch exists at version 1.0.4, and no public exploit code or CISA KEV listing has been identified at time of analysis.

Deserialization of untrusted data in Canon PRISMAproduction version 6.5 and earlier enables adjacent-network attackers to achieve arbitrary code execution without credentials. The CVSS 4.0 vector (AV:A/AC:H/PR:N) indicates exploitation requires physical or logical network adjacency and elevated attack complexity, but successful exploitation yields full confidentiality, integrity, and availability compromise of the host. No public exploit code has been identified at time of analysis, and no CISA KEV listing is present; Canon PSIRT has published an advisory (cp2026-007) acknowledging the issue.

Remote code execution in ComfyUI v0.23.0 (and all prior 0.x releases) lets unauthenticated attackers run arbitrary Python by abandoning the LoadTrainingDataset node to torch.load a malicious pickle. Because the upload and prompt-queue endpoints require no authentication, an attacker who can reach the web interface can upload a crafted shard_*.pkl file and trigger deserialization to execute commands as the ComfyUI process user. VulnCheck reported the flaw and a vendor fix exists; there is no public exploit identified at time of analysis, though the technique (pickle __reduce__ abuse) is trivial to reproduce.

PHP Object Injection in the Kirki WordPress plugin before 6.0.13 enables a two-stage attack where unauthenticated users store malicious serialized PHP objects, which are then deserialized when an administrator reviews the stored data in the WordPress admin panel. With a suitable gadget chain present on the site - from another installed plugin or an outdated WordPress core - this can escalate to full remote code execution on the hosting server. A publicly available proof-of-concept exists per WPScan, though EPSS remains low (0.22%, 13th percentile) and CISA has not listed this in KEV, suggesting no confirmed widespread in-the-wild exploitation at time of analysis.

Remote code execution in IBM WebSphere Application Server 9.0 and 8.5 allows an authenticated attacker to run arbitrary code by delivering a malicious serialized Java object through the SOAP/JMX connector, which the server deserializes unsafely (CWE-502). An attacker with low-level credentials who can reach the management connector can achieve full compromise of the application server process. IBM has released a fix; there is no public exploit identified at time of analysis and the CVE is not listed in CISA KEV.

Remote code execution in SGLang (versions up to and including 0.5.15) allows unauthenticated attackers to run arbitrary commands by abusing the /load_lora_adapter_from_tensors endpoint, which deserializes attacker-supplied base64-encoded pickle payloads. The framework's SafeUnpickler relies on an incomplete denylist that can be bypassed, so a crafted pickle stream reaches dangerous reduce logic and executes OS commands on the serving host. Rated CVSS 9.8 with SSVC total technical impact and marked automatable; no public exploit has been confirmed and EPSS is a modest 0.65% (48th percentile), so widespread automated exploitation is not yet evidenced.

Remote code execution in SGLang (versions up to and including 0.5.15) allows attackers to run arbitrary code on the inference server by abusing the /update_weights_from_disk endpoint, which falls back to torch.load(..., weights_only=False) and thus deserializes attacker-controlled pickle streams embedded in .bin model-weight files. Because SGLang's HTTP serving API is typically exposed without authentication, an attacker able to reach the endpoint and influence the loaded weights path can achieve code execution as the serving process. This is a CWE-502 deserialization flaw rated CVSS 9.8; a vendor security advisory (GHSA-wf98-gv64-5wrf) and a public technical disclosure exist, though EPSS remains low (0.26%, 18th percentile) and it is not in CISA KEV - no public exploit identified at time of analysis beyond the disclosure write-up.

Remote code execution in IBM webMethods Integration (on-prem) 10.15 and 10.11 allows an unauthenticated network attacker to run arbitrary code by submitting maliciously crafted serialized data that the platform deserializes without validation (CWE-502). Because the CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N with full CIA impact (9.8 Critical), exploitation requires no credentials and no user interaction. There is no public exploit identified at time of analysis and the CVE is not listed in CISA KEV, but the vendor (IBM) has released a patch, indicating a confirmed, fixable flaw.

Second-order PHP code execution in e107 CMS before version 2.3.8 lets an attacker who already holds out-of-band write access to the database plant a crafted payload in the user_prefs column, which is later fed to eval() when that user's preferences load. The e_array::unserialize() handler validates only that the stored string begins with 'array' before evaluating it, so any account whose preferences are materialized triggers arbitrary PHP execution. Reported by VulnCheck with a vendor patch available; no public exploit identified at time of analysis, and it is not listed in CISA KEV.

Unauthenticated OS user-account creation in Gladinet CentreStack before 17.3 lets remote attackers abuse an insecure deserialization path in GSNamespace.dll to add arbitrary local Windows accounts. By posting a crafted base64-encoded XML StorageConfigure value to the exposed jsonimportuserbyupn/jsonimportuserbyupnex/japiimportuserbyupn endpoints, an attacker (no credentials, per CVSS PR:N) drives InternalImportAdUserByUPN() to call NetUserAdd with attacker-chosen credentials and to create arbitrary server directories. No public exploit identified at time of analysis and it is not in CISA KEV, but the same product family has a prior history of actively exploited flaws, so weight this accordingly.

PHP object injection in the BuddyPress plugin for WordPress (all versions through 14.5.0) allows authenticated users with subscriber-level access or higher to deserialize attacker-controlled data through XProfile textbox fields, which can escalate to remote code execution when a usable POP gadget chain exists in the WordPress stack. The flaw stems from bp_unserialize_profile_field() calling @unserialize() on user-supplied profile data without the allowed_classes safeguard. There is no public exploit identified at time of analysis, and it is not listed in CISA KEV; the moderate CVSS of 7.5 reflects the dependency on an available gadget chain (high attack complexity).

Remote code execution in the Aimy Captcha-Less Form Guard plugin for Joomla (versions 18.0 through 20.0) allows unauthenticated attackers to run arbitrary PHP by submitting a forged 'clfgd' form field that the plugin deserializes, triggering PHP object injection. Any unpatched Joomla site running this plugin is exposed to full server compromise over the network without authentication or user interaction. There is no public exploit identified at time of analysis and the flaw is not listed in CISA KEV, but the CWE-502 root cause and maximal CVSS 4.0 score (10.0) make this a critical-priority issue.

Denial-of-service and cache-integrity corruption in Apache Traffic Server (8.0.0-8.1.9, 9.0.0-9.2.14, 10.0.0-10.1.3) allows remote unauthenticated attackers to crash the proxy or corrupt its internal state by abusing how on-disk cache fields and object lifetimes are deserialized and managed. The flaw is a CWE-502 untrusted-deserialization class issue tied to the disk cache subsystem; there is no public exploit identified at time of analysis and it is not listed in CISA KEV. The CVSS 4.0 score of 8.3 is driven by high availability impact and low integrity impact with no confidentiality exposure.

Remote code execution in Koollab LMS 5.3.2 lets an authenticated attacker chain SQL injection (CWE-89) and PHP object injection through the manual mark assessment endpoint to poison data reaching unserialize(), drop a webshell into a web-accessible path, and run arbitrary commands on the host. The chained SQLi-to-deserialization-to-webshell path yields total system compromise (CVSS 9.9, scope change). There is no public exploit identified at time of analysis, EPSS is low (0.30%), and CISA SSVC currently rates exploitation as none.

Remote code execution in Koollab LMS allows authenticated attackers to chain SQL injection with unsafe deserialization, ultimately executing arbitrary commands on the server. The vulnerability is reachable via the assessment overall answer endpoint and permits writing a webshell to a publicly accessible location. No active exploitation (KEV) or public exploit code has been confirmed at this time.

Remote code execution in Koollab LMS allows authenticated attackers to exploit SQL injection and unsafe deserialization through the assessment reinforcement endpoint, resulting in webshell upload and full server compromise. The vulnerability, tracked as CVE-2026-63232, requires low-privileged access but leads to complete takeover of the server. No public exploit or active exploitation has been identified at time of analysis.

Pre-authentication unsafe deserialization in IBM WebSphere Application Server 9.0 and 8.5 traditional allows remote unauthenticated attackers to execute arbitrary code or bypass authentication. CVSS 9.8 indicates critical severity with low attack complexity and no user interaction, though no public exploit code or active exploitation has been identified at time of analysis.

Remote code execution in IBM WebSphere Application Server 8.5 and 9.0 (traditional) allows an unauthenticated network attacker to run arbitrary code by sending crafted serialized data that the server deserializes without validation (CWE-502). The flaw carries a CVSS 9.8 rating with a network attack vector and no authentication or user interaction required, though SSVC records exploitation as none observed and no public exploit was identified at time of analysis. EPSS is low at 0.37% (29th percentile), indicating that active, widespread exploitation has not yet materialized despite the maximal technical impact.

Unauthenticated remote code execution in 3DEXPERIENCE Station Launcher App from Release R2023x through R2026x allows attackers to execute arbitrary commands on affected systems without any authentication. The flaw stems from deserialization of untrusted data (CWE-502) and carries a maximum CVSS 10.0 score. No active exploitation or public exploit code is reported at time of analysis, though the network‑accessible attack surface presents significant risk.

Remote code execution in Apache Axis2/Java through 2.0.0 arises from unsafe deserialization of Java objects in the optional Tribes clustering component, allowing unauthenticated remote attackers with network access to the clustering port to execute arbitrary code via crafted serialized payloads. The vulnerability is only exploitable when clustering is explicitly enabled, which is off by default. No active exploitation or public exploit code has been observed; the issue is resolved by upgrading to version 2.0.1, which removes the entire clustering feature.

Low-privileged users can exploit a deserialization flaw in JFrog Artifactory's package handling to potentially execute arbitrary code, compromising system confidentiality, integrity, and availability. The vulnerability is triggered under specific repository conditions. At time of analysis, no public exploit or active exploitation has been confirmed.

Remote code execution in JetBrains TeamCity before 2026.1.3 and 2025.11.7 allows unauthenticated attackers to execute arbitrary code via deserialization of untrusted data in the agent polling protocol. The vulnerability carries a CVSS 9.8 score and poses immediate risk to any exposed TeamCity instance. No public exploit or active exploitation has been confirmed at the time of analysis.

An authenticated PHP Object Injection vulnerability in the Fluent Forms Pro Add On Pack plugin for WordPress (versions ≤6.2.6) allows a user with Subscriber-level privileges to inject a malicious serialized PHP object via deserialization of untrusted input. If a suitable POP chain is present and the user update integration is enabled with a mapped user meta field, the attacker can change user passwords and ultimately take over administrator accounts. Public exploit code is available, but the EPSS score (0.38%) suggests low real-world exploitation probability and the vulnerability is not listed in CISA's KEV.

Pre-authentication remote code execution in Open Identity Platform OpenAM (openam-auth-webauthn) before 16.1.2 arises from an incomplete fix to the earlier deserialization flaw GHSA-6c99-87fr-6q7r: the ObjectInputFilter guarding WebAuthn authenticator deserialization short-circuits to ALLOWED for any object at stream depth greater than 1, so only the root class is constrained while the entire nested object graph is unchecked. An attacker who reaches the WebAuthn login path with a chosen userHandle can supply a stream rooted at AuthenticatorImpl with a gadget chain nested inside, achieving RCE when a suitable gadget is on the classpath. No active exploitation is listed in CISA KEV and no standalone public exploit is identified, though the vendor's fix commit ships a test demonstrating nested-gadget execution; EPSS is 0.89% (57th percentile).

Deserialization type confusion in seroval.fromJSON() allows remote code execution in applications that process untrusted JSON with plugins enabled. Versions prior to 1.5.3 are affected. No public exploit is available, but a private reproducer confirms the issue.

Remote code execution in Microsoft 365 Copilot allows an authenticated attacker to run arbitrary code over the network by supplying maliciously crafted serialized data (CWE-502). The flaw carries a CVSS 9.9 rating driven by a scope change and full confidentiality, integrity, and availability impact, and because Copilot is a Microsoft-hosted cloud service, exploitation would affect the shared multi-tenant platform. No public exploit identified at time of analysis (CVSS exploit maturity is Unproven), but a vendor fix has been released via MSRC.

Deserialization of untrusted data in Johnson Controls victor video management software (versions 2.9 up to but not including 3.0) on Windows allows an adjacent-network attacker to trigger object injection (CAPEC-586) and achieve high impact on confidentiality, integrity, and availability. The CVSS 4.0 vector (AV:A/PR:N/UI:N) indicates unauthenticated exploitation is possible for an attacker positioned on the same local network segment, with no user interaction. There is no public exploit identified at time of analysis and it is not listed in CISA KEV.

PHP Object Injection in the Complianz WordPress plugin (all versions up to and including 7.5.0) allows an authenticated user with Administrator privileges to inject serialized PHP objects that the plugin later deserializes, enabling arbitrary object instantiation and potential remote code execution or data manipulation. The flaw stems from unsafe deserialization (CWE-502) and carries a CVSS 7.2 (High). No public exploit identified at time of analysis and the issue is not listed in CISA KEV; it was privately disclosed by Patchstack.