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
DataGridproperties - Required access: An authenticated account able to submit or modify the writable
contextproperty - 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

