/

CVE-2026-61686

Severity:

HIGH RISK

(7.5)

Unsafe Deserialization (CWE-502) in SolidInvoice Platform

CVE-2026-61686

Deferred

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Potential Remote Code Execution

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

SolidInvoice versions before 3.0.1 unsafely deserialize a client-controlled context property in the DataGrid LiveComponent using PHP's unserialize() function. An authenticated attacker who can submit this writable property may provide a crafted serialized value, potentially resulting in arbitrary PHP object instantiation or code execution in the application context.

Affected context

The vulnerability occurs in SolidInvoice's DataGrid LiveComponent when the context property is both writable by the client and passed to PHP's native deserialization mechanism. Deployments are exposed when an authenticated user can influence this property and the application processes the supplied value without restricting its serialized types or enforcing a safe data format.

Exploit preconditions

  • Attack surface: The client-facing LiveComponent handling DataGrid properties
  • Required access: An authenticated account able to submit or modify the writable context property
  • Trigger point: Server-side processing of the submitted property
  • Why exploitation is possible: Client-controlled serialized data reaches unserialize() without an adequately restricted representation or trusted-input boundary

Why this happens

The underlying flaw is the use of PHP's general-purpose unserialize() function on data that can be controlled by an authenticated client. PHP serialization can represent objects and invoke class-specific behavior during reconstruction, so treating the serialized value as ordinary application data creates an unsafe deserialization path. This behavior maps to CWE-502: Deserialization of Untrusted Data.

Potential impact

  • An attacker may instantiate unexpected application objects
  • Server-side code execution could occur if exploitable gadget chains are available
  • Application data or invoice records could be accessed or modified
  • The application process may be disrupted or its integrity compromised
  • A compromised application account could be used for further internal access

General mitigation guidance

Mitigation generally focuses on removing client-controlled PHP serialization from the data flow and reducing trust in component properties.

Common defensive patterns include:

  • Use structured formats such as JSON with strict, allowlisted schemas instead of PHP serialization
  • Avoid deserializing client-provided values into PHP objects
  • Mark state as non-writable when it does not need to be changed by the client
  • Validate type, shape, size, and permitted values before processing component data
  • If deserialization is unavoidable, restrict accepted classes and use narrowly scoped conversion logic
  • Apply least-privilege permissions to the application process and its data stores
  • Invalidate or review sessions and credentials after suspected exploitation

How teams detect issues like this

Organizations can identify similar issues through:

  • Static analysis rules that flag unserialize() on request, component, form, or other user-influenced data
  • Code review checks for writable component properties that flow into object deserialization
  • Taint analysis tracing client input into serialization and object-construction APIs
  • Runtime monitoring for unusual component requests, serialized object markers, application errors, or unexpected process behavior
  • Policy enforcement requiring structured, schema-validated formats for browser-to-server state
  • Automated security review tools that identify unsafe deserialization and missing input trust boundaries

Sources

SourceLink
github.comgithub.com/SolidInvoice/SolidInvoice/releases/tag/3.0.1
github.comgithub.com/SolidInvoice/SolidInvoice/security/advisories/GHSA-4gj8-frx2-gmp6

Frequently asked

questions

Yes, within the application's authenticated attack surface. An attacker generally needs to send crafted component data to the server through a reachable SolidInvoice interface.

The attacker needs an authenticated account with the ability to influence the writable context property. The practical impact depends on authorization controls and available PHP object gadget chains.

Do not deserialize client-controlled data with PHP's general-purpose unserialize() function. Prefer a strict, allowlisted structured format and keep component state server-controlled wherever possible.

Treat all browser-supplied component properties as untrusted, enforce schemas and size limits, restrict writable state, scan for unsafe deserialization APIs, and test authorization boundaries during security reviews.

Find out what's already
exploitable in your codebase.