/

CVE-2026-76834

Severity:

HIGH RISK

(8.1)

Unsafe Deserialization (CWE-502) in b2evolution CMS

CVE-2026-76834

Deferred

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Potential Remote Code Execution

Severity:

HIGH RISK

(8.1)

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

b2evolution CMS contains an incomplete validation fix for an unsafe PHP object deserialization issue. An unauthenticated attacker may submit a crafted serialized payload that bypasses array-key checks and reaches unserialize(), potentially enabling code execution when suitable gadget chains are available.

Affected context

The issue occurs in b2evolution CMS deployments using affected versions of the request-processing path at htsrv/call_plugin.php. Risk is present when attacker-controlled POST data is passed through param_check_serialized_array() and then reaches PHP object deserialization without fully rejecting negative integer array keys. Successful code execution also depends on usable application or library gadget chains being available.

Exploit preconditions

  • Attack surface: Publicly reachable HTTP POST handling through htsrv/call_plugin.php
  • Required access: No authentication may be required to submit the crafted request
  • Trigger point: Processing of serialized array data before it is passed to unserialize()
  • Why exploitation is possible: Validation does not reject all attacker-controlled serialized structures, allowing object instantiation with attacker-chosen properties
  • Additional condition: A compatible PHP object property-oriented programming gadget chain must be present for code execution

Why this happens

The underlying bug is incomplete validation of serialized input. The defensive check attempts to distinguish permitted serialized arrays from serialized objects, but fails to account for payloads containing negative integer array keys. This allows a crafted value to pass validation and reach PHP's unserialize() function, which can instantiate objects and populate their properties from attacker-controlled data. The behavior maps to CWE-502: Deserialization of Untrusted Data.

Potential impact

  • An attacker may instantiate unexpected PHP objects within the application process
  • Application behavior or stored data could be altered through attacker-controlled object properties
  • Code execution could occur if suitable gadget chains are available
  • Web server or application credentials could be exposed
  • The CMS environment could be used for further compromise or lateral movement

General mitigation guidance

Mitigation generally focuses on eliminating unsafe deserialization of attacker-controlled data and making validation complete rather than relying on narrowly defined serialized-array checks.

Common defensive patterns include:

  • Replacing PHP object deserialization with structured formats that do not instantiate classes
  • Using strict allowlisted schemas and data types for request parameters
  • Rejecting unexpected keys, nested structures, and serialized object markers before processing
  • Reducing trust in all unauthenticated request data, including values that appear array-like
  • Restricting available classes and application privileges where deserialization cannot yet be removed
  • Applying defense-in-depth controls around web-process filesystem, database, and operating-system access

How teams detect issues like this

Detection approaches commonly include:

  • Static analysis rules identifying unserialize() calls that receive request-derived or otherwise untrusted data
  • Code review checks for blacklist-based serialized-input validation and incomplete handling of negative or unusual array keys
  • Instrumentation or web-application firewall policies that flag serialized PHP object markers and anomalous serialized structures in POST bodies
  • Runtime monitoring for unexpected class instantiation, unusual child processes, or web-process access to sensitive resources
  • CI policy checks requiring explicit data-flow review for every deserialization path

Automated security review tools may help identify direct and indirect flows from HTTP input to deserialization functions.

Sources

SourceLink
b2evolution.netb2evolution.net/news/2022/03/26/2022-update-eol
gist.github.comgist.github.com/axg11/3e29501c33f6e1e05ac2a00107afd64e
github.comgithub.com/b2evolution/b2evolution
github.comgithub.com/b2evolution/b2evolution/blob/7.2.5/htsrv/call_plugin.php#L49
github.comgithub.com/b2evolution/b2evolution/blob/7.2.5/inc/_core/_param.funcs.php#L2860
github.comgithub.com/b2evolution/b2evolution/commit/25c21cf9cc4261324001f9039509710b37ee2c4d
github.comgithub.com/b2evolution/b2evolution/commit/335abf09bcea61717bd00bc1e3889f8100ebd1bb
github.comgithub.com/b2evolution/b2evolution/commit/999b5ad1d59760d7e450ceb541f55432fc74cd27
vulncheck.comvulncheck.com/advisories/b2evolution-cms-6.7.8-through-7.2.5-object-injection-via-negative-integer-array-key

Frequently asked

questions

Yes, the affected endpoint may be reachable over HTTP, and the described attack does not require authentication. Successful code execution still depends on the application environment containing a usable gadget chain.

An attacker generally needs network access to the vulnerable endpoint and the ability to submit POST data. No valid CMS account is expected to be necessary for the described path.

The safest pattern is to avoid deserializing attacker-controlled PHP data and instead use a non-object structured format with strict schema and type validation.

Review all request-to-deserialization data flows, use allowlisted input models, test unusual serialized structures such as negative keys, and limit the privileges available to the web application process.

Find out what's already
exploitable in your codebase.