/

CVE-2026-40901

Severity:

HIGH RISK

(8.8)

Unsafe Deserialization in DataEase Quartz Job Handling

CVE-2026-40901

Analyzed

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Remote Code Execution

Severity:

HIGH RISK

(8.8)

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

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_details database 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_details table.
  • 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 ObjectInputStream without deserialization filters, class allowlists, or type checks, while the classpath includes commons-collections-3.2.1 with known gadget chains such as InvokerTransformer, 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-collections versions) 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.

Sources

SourceLink
github.comgithub.com/dataease/dataease/releases/tag/v2.10.21
github.comgithub.com/dataease/dataease/security/advisories/GHSA-gm5q-g72w-c466

Frequently asked

questions

Exploitability is constrained by the ability to write to the Quartz job data table. When an attacker can influence JOB_DATA BLOBs, either via application features or chained vulnerabilities, exploitation is highly reliable because it leverages deterministic deserialization behavior.

Some level of write access to the Quartz tables is required, which may be obtained through authenticated application features or direct SQL access. In scenarios where another vulnerability (such as SQL injection) is present, the attacker might not need valid credentials.

Replace Java native serialization for job data with a safer, structured format and enforce strict type constraints. In addition, introduce deserialization filters or allowlists for any remaining serialization use and remove or upgrade high-risk gadget libraries from the classpath.

Adopt a development policy that forbids unsafe generic deserialization of externally influenced data, mandates safe data formats for persistence and messaging, and enforces security-focused reviews when schedulers, queues, or caches are introduced. Automated scanning for dangerous APIs and high-risk libraries should be integrated into CI/CD pipelines.

Find out what's already
exploitable in your codebase.