/

CVE-2026-37579

Severity:

HIGH RISK

(7.3)

Unsafe Deserialization in Sms-core

CVE-2026-37579

Deferred

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Remote Code Execution

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

Sms-core up to and including version 2.1.13.6 contains an unsafe deserialization flaw in the Cmpp7FDeliverRequestMessageCodec component that can lead to arbitrary code execution.

When a remote attacker can send crafted CMPP deliver request messages to a vulnerable SMSGate deployment, they may be able to trigger deserialization of attacker-controlled data and execute code in the server context.

Affected context

This vulnerability occurs in SMSGate sms-core deployments that process CMPP (China Mobile Peer to Peer) protocol messages using the Cmpp7FDeliverRequestMessageCodec implementation.

The risk is present where:

  • The sms-core service is reachable over the network and accepts CMPP message traffic
  • Incoming CMPP deliver request payloads are decoded and deserialized without strict type or content validation
  • The codec logic operates with sufficient permissions on the host or in the JVM to perform sensitive actions if compromised

Exploit preconditions

  • Attack surface: Network-accessible CMPP interface exposed by the SMSGate sms-core service.
  • Required access: Ability to send arbitrary or malformed CMPP deliver request messages to the affected endpoint (often unauthenticated at the protocol level, depending on deployment).
  • Trigger point: Deserialization of attacker-controlled fields within CMPP deliver request messages inside Cmpp7FDeliverRequestMessageCodec.
  • Why exploitation is possible: The codec performs deserialization of untrusted data using general-purpose mechanisms that can instantiate arbitrary classes or invoke code paths, aligning with CWE-502 unsafe deserialization.

Why this happens

The underlying bug belongs to the unsafe deserialization class (CWE-502).

The Cmpp7FDeliverRequestMessageCodec component appears to treat parts of a CMPP deliver request as serialized objects or structured data and deserializes them without ensuring they are simple, data-only types.

By allowing attacker-controlled bytes to drive the deserialization process, the component can inadvertently create objects with side effects or reach gadget chains that execute arbitrary code.

The core problem is trusting external protocol payloads as if they were internal, trusted serialized objects instead of decoding them into strictly defined, benign data structures.

Potential impact

  • Remote execution of arbitrary code within the SMSGate sms-core process
  • Full compromise of the SMS processing service and its configuration
  • Access to or manipulation of SMS message content and metadata
  • Use of the compromised service as a pivot point into the surrounding network
  • Denial of service through crafted payloads that crash or hang the JVM

General mitigation guidance

Effective mitigation focuses on eliminating unsafe deserialization paths and constraining what the codec can do with network data.

Recommended patterns include:

  • Avoid using Java native deserialization or similarly powerful mechanisms for CMPP payloads; instead, parse messages into simple, well-defined value objects.
  • Enforce strict schema and type validation for all fields in CMPP messages, rejecting any data that does not conform to expected formats.
  • Apply allowlists of permitted classes or message types if deserialization cannot be entirely avoided, and disallow arbitrary object graphs.
  • Run the sms-core component with least-privilege OS and JVM permissions (reduced file system access, constrained network permissions, non-root accounts).
  • Isolate the SMS processing service in its own network segment or container to limit impact if a compromise occurs.

How teams detect issues like this

Detection commonly combines code-centric and runtime approaches:

  • Static analysis: Scan for uses of ObjectInputStream, native Java deserialization, or other general-purpose deserialization APIs within CMPP codecs and protocol handlers.
  • Code review: Flag any logic where network payload bytes are passed directly into deserialization routines or where codec classes reference broad, polymorphic object hierarchies.
  • Security testing: Perform protocol fuzzing of the CMPP interface to identify unexpected exceptions, crashes, or execution paths triggered by malformed messages.
  • Runtime monitoring: Instrument the JVM to detect suspicious class loading, reflective calls, or deserialization of unexpected types in the sms-core process.

Sources

SourceLink
github.comgithub.com/wudijun/jun.github.io/blob/main/SMSGate%20deserialization%20vulnerability.md

Frequently asked

questions

Yes. If the CMPP interface of sms-core is reachable over the network and not sufficiently restricted, an attacker can remotely send crafted deliver request messages to attempt exploitation.

The attacker needs the ability to connect to the SMSGate sms-core CMPP endpoint and transmit CMPP deliver request messages. No additional operating system–level access is required beyond network reachability, although deployment-specific authentication or IP restrictions may raise the bar.

Replace any generic object deserialization in the Cmpp7FDeliverRequestMessageCodec with explicit, schema-driven parsing into simple data types. Ensure the codec only ever constructs known, benign message objects and does not rely on polymorphic or reflective instantiation based on untrusted data.

Establish a design rule that external protocol data is always treated as untrusted and parsed, not deserialized. Incorporate static analysis and security review for any serialization-related code, and standardize on safe serialization formats and libraries for all network-facing components.

Find out what's already
exploitable in your codebase.