/

CVE-2026-24892

Severity:

HIGH RISK

(7.5)

Unsafe Deserialization in openITCOCKPIT Changelog Processing

CVE-2026-24892

Analyzed

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Latent Remote Code Execution Risk via PHP Object Injection

Severity:

HIGH RISK

(7.5)

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

openITCOCKPIT Community Edition 5.3.1 and earlier contains an unsafe PHP deserialization pattern when processing changelog entries, where serialized data influenced by application state is passed to unserialize() without class restrictions.

While no current endpoint injects PHP objects into this data flow, the unrestricted deserialization call creates a latent PHP object injection risk that could become exploitable after future code changes, plugins, or refactors, potentially enabling remote code execution.

Affected context

The vulnerability occurs in the openITCOCKPIT Community Edition changelog handling logic, where serialized changelog data derived from application state is deserialized using PHP's unserialize() without specifying allowed classes.

At present, the data path appears to only use benign scalar or array structures, and no exposed endpoint was identified that injects attacker-controlled objects into this path.

However, because the deserialization mechanism is generic and unconstrained, any future feature, plugin, or refactor that stores PHP objects in changelog entries could immediately expose this path to PHP object injection.

Exploit preconditions

  • Attack surface: Application features or plugins that write data into changelog entries and later trigger their deserialization.
  • Required access: Ability to influence application state that gets serialized into changelog data (e.g., by interacting with UI/API components that feed into changelog creation).
  • Trigger point: Invocation of unserialize() on changelog data containing attacker-controlled PHP objects, particularly objects of classes with dangerous magic methods (e.g., __wakeup, __destruct).
  • Why exploitation is possible: The deserialization logic does not restrict allowed classes or enforce a safe data schema, so if objects are ever introduced into this data path, an attacker could craft serialized payloads that leverage gadget chains for code execution or data manipulation.

Why this happens

The root cause is the use of PHP's unserialize() on data that is influenced by application state without constraining which classes may be instantiated or validating that the data matches a benign schema.

This aligns with CWE-502: Unsafe Deserialization, where serialized data is treated as trusted and deserialized into live objects that may execute logic via magic methods or other side effects.

Even though current usage may only involve primitive data, the pattern itself is insecure because it establishes a generic deserialization sink; once any code path stores objects in the serialized changelog data, the application would be susceptible to PHP object injection and potential remote code execution through existing gadget classes.

Potential impact

  • Remote code execution through gadget chains in existing or future PHP classes.
  • Arbitrary modification or deletion of monitoring configuration or changelog entries.
  • Unauthorized access to sensitive monitoring data or credentials present in memory or configuration.
  • Escalation of privileges within the monitoring environment if deserialized objects can manipulate authorization or session state.
  • Abuse of server resources, including denial of service, by triggering expensive or infinite operations during object construction or destruction.

General mitigation guidance

Mitigation should focus on eliminating unsafe deserialization patterns and constraining data formats used in changelog processing:

  • Replace PHP serialize()/unserialize() usage for changelog data with safe, data-only formats such as JSON, with explicit schema validation.
  • If deserialization is unavoidable, use mechanisms that restrict allowed classes (e.g., unserialize() with ['allowed_classes' => false]) and treat the result as pure data rather than executable objects.
  • Avoid storing full PHP objects in persistent or user-influenced storage; instead, persist only primitive fields required for business logic.
  • Design changelog storage to be append-only and data-centric, minimizing opportunities for executable behavior during loading or rendering.
  • Apply the principle of least privilege in the broader application so that, even if a deserialization bug is introduced later, the code has limited ability to impact the system or execute dangerous operations.

How teams detect issues like this

Detection revolves around identifying insecure deserialization sinks and monitoring for risky patterns over time:

  • Use static analysis or grep-based code scanning to find usages of unserialize() and flag those operating on data influenced by user or application state, especially without allowed_classes restrictions.
  • During code review, treat any introduction or modification of serialization logic (PHP objects being stored and later loaded) as a high-risk change, particularly in logging or changelog components.
  • Establish secure coding guidelines that prohibit generic object deserialization in favor of structured, data-only formats; enforce these guidelines via automated linters or CI policies.
  • Periodically review plugins, extensions, and new features for any code that writes objects into changelog or similar serialized fields, since these areas can silently convert a latent sink into an exploitable vulnerability.

Sources

SourceLink
github.comgithub.com/openITCOCKPIT/openITCOCKPIT/commit/975e0d0dfb79898568afbbfdba8f647d92612a69
github.comgithub.com/openITCOCKPIT/openITCOCKPIT/releases/tag/openITCOCKPIT-5.4.0
github.comgithub.com/openITCOCKPIT/openITCOCKPIT/security/advisories/GHSA-g83p-vvjm-g39x

Frequently asked

questions

Based on current analysis, no active endpoint was found that injects PHP objects into the affected deserialization path, so it appears latent rather than immediately exploitable. However, the unsafe pattern means that future changes could turn it into an active exploit path without further modifications to the deserialization code.

An attacker would need a way to influence data that becomes part of the serialized changelog entries, typically through authenticated access to UI or API functions that feed into the changelog. If those inputs are reachable without strong authentication, the effective access requirement could be quite low.

The most robust approach is to remove use of PHP unserialize() for changelog data entirely and migrate to a data-only format like JSON, combined with schema validation. Any remaining deserialization should explicitly disallow class instantiation and treat data as simple structures.

Preventive strategies include banning generic object deserialization in coding standards, using data-only serialization formats across the codebase, enforcing reviews for serialization-related changes, and running automated scans for unserialize() and similar APIs so unsafe patterns are caught before deployment.

Find out what's already
exploitable in your codebase.