/

CVE-2026-71981

Severity:

HIGH RISK

(8.8)

PHP Object Injection (CWE-502) in Cypht Logout Handler

CVE-2026-71981

Deferred

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Remote Code Execution

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Cypht contains a PHP object injection vulnerability in its logout handler, where attacker-controlled data from the back_query parameter is decoded and passed to PHP's unserialize() function without adequate restrictions.

An authenticated attacker who can reach the affected handler may provide a crafted serialized object graph, potentially triggering gadget-chain execution and arbitrary operating system commands as the web server process.

Affected context

The vulnerability occurs in Cypht deployments that expose the affected logout handler and process the back_query GET parameter through PHP deserialization. Risk is greatest when an authenticated user can submit request parameters to this endpoint and the application contains usable gadget chains in its runtime code or dependencies.

Exploit preconditions

  • Attack surface: The Cypht logout handler and its back_query GET parameter
  • Required access: Valid authentication sufficient to reach the affected handler
  • Trigger point: Processing the parameter during logout request handling
  • Why exploitation is possible: Attacker-controlled serialized data is decoded and passed to unserialize() without an allow-list, integrity check, or restrictive type policy

Why this happens

The underlying bug is unsafe deserialization of attacker-influenced data. PHP's unserialize() can reconstruct object instances and invoke serialization-related behavior, allowing unexpected object graphs to interact with application or dependency methods.

This maps to CWE-502: Deserialization of Untrusted Data, because data received through an HTTP request is treated as a trusted serialized object representation rather than as constrained, validated application state.

Potential impact

  • An attacker may execute arbitrary operating system commands
  • The web server process could be compromised
  • Application data and credentials may be exposed or altered
  • The attacker could establish persistence within the application environment
  • Additional internal systems may be reached if the process has excessive privileges

General mitigation guidance

Mitigation generally focuses on removing unsafe deserialization from request-processing paths and reducing the trust placed in client-controlled state.

Common defensive patterns include:

  • Replacing native object deserialization with narrowly defined scalar or structured-data formats
  • Using explicit schemas and strict type validation for redirect or navigation state
  • Applying integrity protection to state that must cross a trust boundary, with server-side verification before use
  • Enforcing authentication and authorization checks at the handler boundary
  • Restricting deserialization to documented classes through narrowly scoped policies where legacy compatibility is unavoidable
  • Running the web process with least privilege and limiting access to sensitive operating-system resources
  • Keeping dependencies and application components limited to the functionality required at runtime

How teams detect issues like this

Detection programs commonly look for:

  • Static-analysis findings involving unserialize() or equivalent deserialization APIs on request-derived data
  • Data-flow paths from GET, POST, cookie, or header inputs into object reconstruction functions
  • Code-review signals such as base64 decoding followed by deserialization without integrity verification
  • Missing class allow-lists, schema checks, or explicit type restrictions around serialized state
  • Web application logs showing unusual requests to logout handlers or repeated malformed back_query values
  • Policy enforcement that blocks unsafe deserialization APIs in web-facing request paths

Automated security review tools can help identify dangerous source-to-sink data flows, but findings should be validated against authentication boundaries and available runtime gadget chains.

Sources

SourceLink
github.comgithub.com/cypht-org/cypht/commit/e4aa2f34e33f9328e8c93514cc3966fc3d99925e
github.comgithub.com/cypht-org/cypht/pull/2073
github.comgithub.com/cypht-org/cypht/releases/tag/v2.12.2
vulncheck.comvulncheck.com/advisories/cypht-php-object-injection-rce-via-back-query-parameter

Frequently asked

questions

It can be exploited over the network when the affected logout handler is exposed and the attacker has the required authenticated access. Exploitability also depends on whether suitable gadget chains are available in the application or its dependencies.

Yes, the described attack requires an authenticated attacker who can submit requests to the affected handler and control the relevant parameter.

Avoid deserializing client-controlled PHP objects. Represent logout or redirect state with narrowly defined data, validate it against a strict schema, and use integrity protection when state must be supplied by the client.

Treat all request parameters as untrusted, prohibit unsafe deserialization in web-facing paths, review data flows into serialization APIs, and run the web process with minimal operating-system privileges.

Find out what's already
exploitable in your codebase.