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.

