Severity:

HIGH RISK

(7.2)

Unsafe Deserialization / PHP Object Injection

CVE-2026-3452

Analyzed

Vulnerability type

Category:

Unsafe Deserialization / PHP Object Injection

CWE:

CWE-502

Impact:

Remote Code Execution by authenticated administrator via unsafe PHP deserialization

Severity:

HIGH RISK

(7.2)

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

Concrete CMS below version 9.4.8 contains a PHP object injection vulnerability where attacker-controlled serialized data can be stored in the Express Entry List block configuration and later passed to unserialize() without restrictions.

An authenticated administrator who can configure this block may achieve remote code execution when the application processes the malicious serialized payload.

Affected context

This vulnerability occurs in Concrete CMS installations using versions below 9.4.8 that make use of the Express Entry List block.

The risk is present when:

  • Administrators can configure the block and set the columns (or related) configuration parameter, and
  • The stored configuration is later read and passed to PHP's unserialize() in a context where application classes with dangerous magic methods are available.

It primarily affects environments where administrators might be untrusted or where admin credentials could be phished, stolen, or abused by insiders.

Exploit preconditions

  • Attack surface: Web application administrative interface for managing Concrete CMS blocks.
  • Required access: High-privilege, authenticated administrator-level access capable of adding or editing Express Entry List blocks and their configuration.
  • Trigger point: Rendering or processing of the Express Entry List block where the stored columns parameter (or related configuration) is passed into unserialize() at runtime.
  • Why exploitation is possible: The application trusts serialized data stored in block configuration and invokes unserialize() without:
  • Class whitelisting or disallow lists,
  • Integrity checks (e.g., signatures, MAC),
  • Or strict data shaping to ensure only primitive types are handled.

This enables construction of PHP objects whose magic methods or destructors can be abused for code execution or other side effects.

Why this happens

The root cause aligns with CWE-502: Deserialization of Untrusted Data and the PHP-specific pattern of object injection.

Concrete CMS stores block configuration values that can contain serialized PHP data and later passes these values to unserialize() as if they were trustworthy.

Because the deserialization call is:

  • Applied to data that can be influenced by an administrator,
  • Performed without limiting which classes may be instantiated, and
  • Executed in an environment where some classes may have side-effectful magic methods,

it becomes possible to craft serialized payloads that instantiate gadget objects and trigger unintended behavior, including remote code execution.

Conceptually, this is an insecure design where configuration data (a data channel) is allowed to carry executable object graphs (a control/behavior channel).

Potential impact

  • Remote code execution in the context of the Concrete CMS PHP process.
  • Execution of arbitrary PHP or system commands via gadget chains, depending on available libraries and environment.
  • Complete compromise of the Concrete CMS instance, including reading or modifying content and configuration.
  • Lateral movement within the hosting environment if the web server account has access to other applications or data.
  • Installation of backdoors, web shells, or malicious plugins through the compromised admin interface and filesystem access.

General mitigation guidance

Effective mitigation focuses on eliminating unsafe deserialization patterns and reducing the trust boundary around configuration data:

  • Replace unserialize() on user- or admin-supplied data with safer serialization formats (e.g., JSON or other typed, structured formats) that do not instantiate objects.
  • If deserialization must be retained for legacy reasons, constrain it to safe primitives:
  • Use mechanisms that enforce whitelists of expected types, or
  • Transform stored configuration so that only arrays and scalars are ever serialized.
  • Treat all configuration fields that can be set via the UI as untrusted inputs, even for administrators, and validate them strictly against expected schemas.
  • Reduce available gadget surface by:
  • Avoiding classes with risky magic methods (__wakeup, __destruct, __toString, etc.) handling critical behavior tied to object lifecycle.
  • Apply least privilege to the PHP/application runtime, restricting file system and OS-level capabilities so that any deserialization flaw yields less impact.

How teams detect issues like this

Detection generally involves both code-centric and configuration-centric analysis:

  • Static analysis and code scanning:
  • Search for uses of unserialize() and other generic deserialization APIs, especially where parameters originate from database fields, configuration, or request data.
  • Flag calls that do not enforce a clear, restricted type set or prior integrity validation.
  • Code review practices:
  • During reviews, treat any serialized storage of configuration or content as a strong signal to scrutinize.
  • Verify that block configuration values are stored and processed using data-only formats (e.g., arrays, JSON) rather than PHP object graphs.
  • Security testing:
  • Incorporate targeted tests for PHP object injection in custom blocks and extensions by attempting benign serialized payloads that reveal deserialization behavior.
  • Policy enforcement:
  • Define internal guidelines that disallow unserialize() on non-internal, non-hardcoded data paths and enforce them via pre-commit hooks or CI checks.

Sources

SourceLink
documentation.concretecms.orgdocumentation.concretecms.org/9-x/developers/introduction/version-history/948-release-notes
github.comgithub.com/concretecms/concretecms/pull/12826/changes/167f16e4805d8ab546d2997c753ac21bf4854920://

Frequently asked

questions

Yes, but only through an authenticated administrative session. An attacker must first obtain or abuse administrator-level access to craft and store the malicious serialized payload via the Express Entry List block configuration.

The vulnerability requires high-privilege access: specifically, the ability to log in as an administrator (or another role with equivalent privileges) who can create or modify Express Entry List blocks and set their configuration parameters.

The most robust fix is to remove unsafe deserialization entirely from user- or admin-controlled data paths. Replace unserialize() with data-only formats such as JSON, enforce explicit schemas for configuration fields, and ensure that application logic does not rely on runtime instantiation of arbitrary objects from stored data.

Prevent them by adopting secure design patterns that treat all persisted and user-configurable values as untrusted input; prohibit unserialize() and similar APIs on such data; standardize on structured, schema-validated formats; and enforce these rules using code review checklists, secure coding guidelines, and automated static analysis within the CI/CD pipeline.

Find out what's already
exploitable in your codebase.