Summary
Changjetong T+ up to and including 16.x exposes a .NET unsafe deserialization flaw in an AjaxPro endpoint that processes attacker-controlled JSON.
By sending a crafted request to a specific handler, a remote attacker can trick the application into deserializing arbitrary .NET types and invoking methods like System.Diagnostics.Process.Start, which can lead to remote code execution under the T+ application service account.
Affected context
This vulnerability occurs in Changjetong T+ when its AjaxPro-based HTTP handler /tplus/ajaxpro/Ufida.T.CodeBehind._PriorityLevel,App_Code.ashx?method=GetStoreWarehouseByStore accepts serialized .NET objects from JSON without sufficient type restrictions or validation.
It is most relevant in deployments where:
- The endpoint is exposed over the network (e.g., intranet or Internet-facing web server)
- AjaxPro is configured to deserialize incoming JSON into .NET objects on the server
- The application trusts type information and data from the request body instead of enforcing a fixed, safe contract
Exploit preconditions
- Attack surface: HTTP(S) interface to the T+ web application, specifically the AjaxPro endpoint:
/tplus/ajaxpro/Ufida.T.CodeBehind._PriorityLevel,App_Code.ashx?method=GetStoreWarehouseByStore- Required access:
- Network-level access to the T+ web server
- Any authentication requirements are deployment-dependent; exploitation can occur wherever this endpoint is reachable and accepts attacker-controlled JSON
- Trigger point:
- Submission of a crafted JSON request body that is deserialized by the AjaxPro handler into .NET types
- Why exploitation is possible:
- The server-side deserialization logic allows dynamic or loosely constrained type resolution during object reconstruction
- Attacker-controlled type metadata and properties are interpreted by the .NET runtime, enabling invocation of dangerous methods (e.g.,
System.Diagnostics.Process.Start) during or immediately after deserialization
Why this happens
The root cause is the use of unsafe .NET deserialization patterns consistent with CWE-502: Deserialization of Untrusted Data.
The AjaxPro endpoint deserializes JSON into .NET objects in a way that:
- Trusts client-supplied data (and potentially type information) as input to a general-purpose deserializer
- Does not strictly limit allowed types or serialization graphs to a minimal, known-safe set
In .NET, generic deserialization of untrusted data can be dangerous when certain framework or application types are reachable.
These types may trigger behavior during construction, property setting, or method calls that allows execution of arbitrary code or commands.
The vulnerable code path essentially treats attacker-controlled serialized input as instructions on how to build and execute complex object graphs instead of treating it as simple data.
Potential impact
- Remote execution of arbitrary system commands under the T+ application service account
- Installation of malware or web shells on the application server
- Access to or modification of business data handled by T+
- Lateral movement into other systems reachable from the compromised server
- Use of the server as a pivot for broader network compromise
- Service disruption or data corruption through malicious command execution
General mitigation guidance
Mitigation revolves around treating serialized data as untrusted and narrowing deserialization behaviors:
- Prefer data-centric models:
- Replace generic object deserialization with explicit DTOs (data transfer objects) that contain only primitive or otherwise safe types
- Map JSON request bodies to strongly typed, whitelisted models rather than relying on dynamic type resolution
- Constrain deserialization:
- Configure serializers to restrict or ignore type metadata from clients
- Enforce an allow-list of types that can be instantiated during deserialization and block all others
- Reduce privileges:
- Run the T+ application service account with the minimum OS and network privileges needed for normal operation
- Avoid granting the service account local administrator or high-privilege roles to limit the blast radius of a compromise
- Harden exposure:
- Restrict network access to administrative and internal endpoints through firewalls, VPNs, or application gateways
- Disable or remove unused AjaxPro endpoints and legacy handlers that perform complex deserialization
- Defense-in-depth:
- Apply request-level validation to enforce expected structure, size, and content before deserialization
- Introduce security checks or middleware capable of rejecting requests that contain unexpected type information or serialization artifacts
How teams detect issues like this
Detection involves both code-centric and runtime perspectives:
- Static analysis and code review:
- Search for AjaxPro handlers and other endpoints that call generic .NET deserialization APIs on data derived from HTTP request bodies
- Flag uses of serializers or frameworks that accept untrusted type metadata or
TypeNameHandling-style configuration - Add review checklists that require explicit justification for any deserialization of externally supplied data
- Automated scanning:
- Use SAST (Static Application Security Testing) tools configured with rules for unsafe .NET deserialization and AjaxPro usage
- Employ dependency and framework scanners that highlight risky serialization behaviors
- Runtime and logging:
- Enable detailed logging of requests to deserialization-heavy endpoints and monitor for anomalous JSON payloads (large object graphs, unusual fields, or embedded type hints)
- Correlate web server logs with OS-level logs to identify suspicious process creation originating from the application pool or service account
- Deploy RASP or EDR solutions that can detect or block unexpected process launches or reflection-heavy behavior in the application process
- Security testing:
- Integrate targeted penetration tests or DAST tools to probe serialization endpoints with intentionally malformed or complex payloads

