/

CVE-2025-56422

Severity:

CRITICAL RISK

(9.8)

Unsafe Deserialization in LimeSurvey Server

CVE-2025-56422

Modified

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.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

LimeSurvey versions before 6.15.0+250623 contain an unsafe deserialization flaw that allows untrusted data to be deserialized on the server.

When an attacker can supply crafted serialized input to the vulnerable code path, this can lead to arbitrary code execution in the LimeSurvey server context.

Affected context

The vulnerability arises in LimeSurvey's server-side processing, where serialized data originating from client-controlled or otherwise untrusted sources is deserialized.

It is most relevant in deployments where LimeSurvey is accessible over the network (e.g., public survey portals or intranet instances) and where the affected deserialization routines are reachable via web requests or imported data flows.

The issue manifests when application logic assumes serialized data is trustworthy and reconstructs objects without constraining what types or behaviors can be instantiated.

Exploit preconditions

  • Attack surface: HTTP(S) interface of the LimeSurvey application, or other remote input channels that feed into the deserialization routine.
  • Required access: Ability to submit or influence serialized data processed by LimeSurvey (typically as a remote, potentially unauthenticated or low-privileged user, depending on the exposed features and configuration).
  • Trigger point: Invocation of the vulnerable deserialization code path during request handling or background processing, where the crafted payload is deserialized.
  • Why exploitation is possible: The application uses a general-purpose deserializer on data that is not strictly trusted or validated, permitting the creation of attacker-controlled objects whose methods or magic hooks can be leveraged to execute arbitrary code, consistent with CWE-502.

Why this happens

This issue is rooted in unsafe deserialization of untrusted data, mapped to CWE-502: Deserialization of Untrusted Data.

The application relies on a serialization format that can express complex objects and then reconstructs them without enforcing a safe type allowlist, structural validation, or isolation.

As a result, an attacker can craft serialized data that, when deserialized, instantiates objects with side effects, invokes gadget chains, or triggers application-level behaviors culminating in remote code execution.

The core pattern is trusting serialized input as if it were benign state rather than treating it as executable, attacker-controlled instructions shaping program behavior.

Potential impact

  • Remote execution of arbitrary code on the LimeSurvey server
  • Full compromise of the application instance, including survey data and configuration
  • Theft or exposure of sensitive respondent data and survey results
  • Installation of backdoors or web shells on the underlying host
  • Use of the compromised server as a pivot point for broader network intrusion

General mitigation guidance

Mitigation typically focuses on removing or tightly constraining unsafe deserialization and hardening how state is exchanged between client and server.

Recommended defensive patterns include:

  • Replacing general-purpose object deserialization with safer data formats (e.g., JSON) that map only to primitive types and simple structures.
  • Applying strict allowlists for types that can be deserialized, rejecting unexpected classes and limiting object graphs.
  • Normalizing and validating all incoming data before it reaches any deserialization layer, ensuring it conforms to a known schema.
  • Decoupling security-sensitive operations from deserialized object constructors and magic methods so object reconstruction cannot implicitly trigger powerful actions.
  • Running the LimeSurvey application under least-privilege accounts and with minimal filesystem and OS permissions to reduce impact if deserialization is abused.
  • Segmenting the LimeSurvey host from critical internal systems and applying network-layer controls, so a compromise is contained.

How teams detect issues like this

Organizations can approach detection of unsafe deserialization in LimeSurvey and similar applications by combining code-centric and behavior-centric techniques.

Possible strategies include:

  • Static analysis: Configure SAST tools or custom rules to flag use of generic deserialization APIs on data derived from HTTP requests, uploaded content, or other untrusted sources.
  • Code review: Look for patterns where request parameters, cookies, session data, or stored user inputs are directly passed into unserialize-like functions or framework deserializers without validation or type restrictions.
  • Runtime monitoring: Instrument application logs and APM tools to detect anomalous object graphs, unexpected errors during deserialization, or execution of OS-level commands in application processes.
  • Policy enforcement: Establish coding guidelines that discourage or forbid object deserialization of externally sourced data, and enforce these rules during pull requests with automated checks.
  • Security testing: Use targeted dynamic testing in staging environments to probe for deserialization sinks and validate that untrusted input cannot control deserialized object types or behaviors.

Sources

SourceLink
github.comgithub.com/hongancalif/security-advisories/blob/main/CVE-2025-56422.md

Frequently asked

questions

Yes. The vulnerability is remotely exploitable when an attacker can reach the application interface that processes the vulnerable serialized input, which is common for Internet-facing or widely accessible LimeSurvey deployments.

Not necessarily. Depending on how the affected functionality is exposed, exploitation may be possible with only basic user access or even anonymously if the vulnerable endpoint accepts unauthenticated input. The exact requirement is determined by the specific deserialization entry point in the deployment.

The safest pattern is to eliminate unsafe deserialization entirely by using simpler, data-only formats such as JSON and ensuring that server-side state is not reconstructed as executable objects. Where deserialization cannot be removed, restrict it to a strict set of known-safe types and enforce schema-level validation.

Prevention involves treating deserialization as a high-risk operation, adopting secure-by-default data formats, and codifying rules that prohibit object deserialization of untrusted data. Incorporating static analysis, security-focused code reviews, and explicit type-allowlisting into the development lifecycle helps ensure new features do not reintroduce this pattern.

Find out what's already
exploitable in your codebase.