Severity:

HIGH RISK

(7.3)

Unsafe Deserialization in GenericFastJsonRedisSerializer

CVE-2026-4860

Deferred

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-20, CWE-502

Impact:

Remote Code Execution and Data Integrity Compromise

Severity:

HIGH RISK

(7.3)

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

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.GenericFastJsonRedisSerializer on 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.

Sources

SourceLink
github.comgithub.com/wing3e/public_exp/issues/1
vuldb.comvuldb.com/?ctiid.353191
vuldb.comvuldb.com/?id.353191
vuldb.comvuldb.com/?submit.776213

Frequently asked

questions

Yes. The flaw resides in server-side deserialization reachable via the API and related data flows, so a remote attacker who can influence serialized data can attempt exploitation.

An attacker generally needs network access to any API or interface that ultimately stores or routes data into Redis where it will be processed by GenericFastJsonRedisSerializer. No local system access is required.

The most robust pattern is to avoid deserializing untrusted data into arbitrary objects. Instead, restrict deserialization to simple, well-defined data structures, enforce strict type allowlists, and disable features such as auto type resolution in the serializer.

Build services so that client-controlled data is treated as opaque and validated against explicit schemas, avoid using generic object deserialization for untrusted input, integrate secure coding guidelines into reviews and CI, and periodically audit serialization libraries and configurations for unsafe features.

Find out what's already
exploitable in your codebase.