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
columnsparameter (or related configuration) is passed intounserialize()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.

