Summary
DataEase versions 2.10.20 and below contain an unsafe Java object deserialization path in the bundled Quartz scheduler that processes job data BLOBs using ObjectInputStream without any deserialization filtering.
If an attacker can modify Quartz job data in the database, they can inject a Commons-Collections gadget chain and achieve remote code execution when the scheduled job fires, potentially running commands as root inside the container.
Affected context
This vulnerability occurs in DataEase deployments that:
- Use versions 2.10.20 or earlier that bundle Quartz 2.3.2 and legacy velocity-1.7.jar
- Allow Quartz job definitions and JOB_DATA to be read from the
qrtz_job_detailsdatabase table - Permit application or SQL-level mechanisms to write or modify entries in the Quartz job table
The risk is realized when the Quartz scheduler loads and deserializes job data BLOBs, trusting the stored binary content as safe Java objects.
Exploit preconditions
- Attack surface: Application-layer interaction with the DataEase database, specifically the Quartz
qrtz_job_detailstable. - Required access: Ability to write or modify Quartz job JOB_DATA BLOBs (e.g., via authenticated features, SQL access, or chaining another vulnerability such as SQL injection in
previewSql). - Trigger point: Execution of a scheduled Quartz job whose job data has been replaced with a malicious serialized payload.
- Why exploitation is possible: Quartz deserializes job data using
ObjectInputStreamwithout deserialization filters, class allowlists, or type checks, while the classpath includescommons-collections-3.2.1with known gadget chains such asInvokerTransformer, enabling arbitrary code execution during deserialization.
Why this happens
The core issue is unsafe deserialization of untrusted data, mapping directly to CWE-502.
Quartz 2.3.2 is configured to read job data from the qrtz_job_details table and passes the BLOB content directly into ObjectInputStream to reconstruct Java objects. No deserialization filter, validation, or class allowlist is applied, so any bytes in the BLOB are treated as a trusted serialized object graph. Because DataEase ships with commons-collections-3.2.1, the runtime includes well-known gadget classes like InvokerTransformer that can be chained so their readObject or related methods execute attacker-controlled logic during deserialization. The insecure pattern is: combining a generic deserialization mechanism with a rich classpath containing gadget libraries, and allowing attacker influence over the serialized data, without enforcing type constraints or input trust boundaries.
Potential impact
- Remote execution of arbitrary operating system commands within the DataEase container.
- Compromise of the application process, including access to configuration, environment variables, and in-memory data.
- Reading, modifying, or exfiltrating sensitive data managed by DataEase and its connected data sources.
- Escalation to full container takeover, particularly when the process runs with root privileges.
- Use of the compromised instance as a pivot point for lateral movement within the hosting environment or network.
General mitigation guidance
Effective mitigation focuses on eliminating unsafe deserialization and reducing the power of any remaining deserialization paths:
- Prefer non-serializable data formats (e.g., JSON, simple key/value types) for scheduler job data instead of Java native serialization.
- Apply deserialization filtering or class allowlists so only specific, simple data carrier types can be reconstructed.
- Avoid bundling or relying on libraries with known deserialization gadget chains; if they are required, ensure they are not reachable from deserialization contexts.
- Constrain who and what can write to scheduler tables at the database level; apply strict least-privilege for application and integration accounts.
- Run the application container with non-root users and minimal OS-level privileges to reduce the blast radius if code execution occurs.
- Segment database access and enforce strong input validation on any feature that influences scheduled jobs or background tasks.
How teams detect issues like this
Organizations can approach detection with a combination of code-level and runtime techniques:
- Static analysis rules that flag uses of
ObjectInputStream.readObject()and similar APIs, especially in infrastructure components like schedulers, messaging, or caching layers. - Code review checklists that require justification and design approval for any use of Java native serialization and that verify the presence of deserialization filters or whitelists.
- Dependency analysis to identify inclusion of high-risk gadget libraries (e.g., older
commons-collectionsversions) in the classpath, particularly around deserialization sinks. - Database auditing or monitoring for unusual modifications to Quartz scheduler tables, especially changes to JOB_DATA columns outside expected application flows.
- Runtime security monitoring for anomalous process behavior during job execution, such as unexpected shell invocations or outbound network connections originating from scheduler threads.

