Summary
wvp-GB28181-pro up to version 2.7.4 contains an insecure deserialization flaw in the GenericFastJsonRedisSerializer used by the API endpoint layer.
When attacker-controlled data is deserialized, a remote attacker may be able to trigger arbitrary code execution or application-level compromise via crafted payloads.
Affected context
This vulnerability appears in deployments of wvp-GB28181-pro up to 2.7.4 that make use of the RedisTemplateConfig and its GenericFastJsonRedisSerializer for API-related operations.
The risk is highest when API endpoints read data from untrusted sources (for example, client input propagated into Redis or other externalized state) and then deserialize it without strict validation or type controls.
The vulnerability is triggered at the server side and does not require local access, but does assume an attacker can influence the serialized data reaching the deserializer.
Exploit preconditions
- Attack surface: Exposed API endpoints and any backend path that feeds attacker-controlled data into Redis-backed serialization.
- Required access: Remote network access to the API or any interface that can populate or modify data eventually processed by GenericFastJsonRedisSerializer.
- Trigger point: Invocation of the deserialization logic in
RedisTemplateConfig.GenericFastJsonRedisSerializeron crafted serialized data. - Why exploitation is possible: The deserializer accepts untrusted data and reconstructs objects without robust validation or type restrictions, matching CWE-502 and compounded by insufficient input validation (CWE-20).
Why this happens
The core issue is the use of a general-purpose JSON-based serialization mechanism (FastJSON) for Redis caching that can deserialize untrusted data into application objects.
In this pattern, the serializer trusts incoming data and attempts to reconstruct complex types, enabling attackers to craft payloads that abuse type metadata or library features to execute code or alter application behavior.
This aligns with CWE-502: Deserialization of Untrusted Data, where application logic implicitly assumes serialized content is safe, combined with CWE-20: Improper Input Validation due to lack of constraints on what data is accepted and processed.
Potential impact
- Remote execution of arbitrary code within the wvp-GB28181-pro application context
- Unauthorized access to or modification of in-memory or cached data
- Escalation from API-level access to full application compromise
- Disruption of video platform services, including denial of service conditions
- Use of the compromised service as a pivot point for further attacks in the environment
General mitigation guidance
Mitigations generally focus on constraining or eliminating unsafe deserialization flows and tightening trust boundaries:
- Avoid deserializing untrusted data into arbitrary application types; prefer simple, schema-validated data structures.
- Configure FastJSON or any serializer to disallow auto type resolution and limit permissible classes to a small allowlist.
- Introduce strict input validation and canonicalization before data is stored in or retrieved from Redis and passed to the serializer.
- Apply the principle of least privilege to the application runtime so that, even if deserialization is abused, resulting impact is constrained.
- Consider redesigning state handling so that security-sensitive decisions are not based on client-controllable serialized objects.
How teams detect issues like this
Detection typically combines code-level analysis with runtime monitoring:
- Use static analysis to search for deserialization entry points (e.g., FastJSON, custom serializers) that consume externally influenced data.
- During code review, flag patterns where Redis or other caches store objects from API input and are later deserialized without validation or type restrictions.
- Enforce secure coding policies in CI/CD pipelines that prohibit unsafe deserialization APIs or require explicit justification and allowlists.
- At runtime, monitor for anomalous deserialization errors, unexpected class types in logs, or unusual process behaviors around serialization operations.

