Skip to main content

DataEase CVE-2026-104141

| EUVDEUVD-2026-101608 HIGH
SQL Injection (CWE-89)
2026-10-14 security-advisories@github.com
8.7
CVSS 4.0 · Vendor: github
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate as DataEase user with datasource access
  2. Delivery
    Submit crafted schema/table/username identifier
  3. Exploit
    CalciteProvider concatenates into JDBC Statement
  4. Execution
    Injected SQL executes on backend DB
  5. Impact
    Read, alter, or destroy database data

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Parameterized queries, prepared statements
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Persistence

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires an authenticated DataEase account that has access to a configured datasource (PR:L); the attacker then supplies crafted identifiers - schema name, connection username, table name, or database name - into datasource metadata operations (getSchema, validate, save, update). These values are injected into metadata queries run via a plain JDBC Statement in CalciteProvider, so the SQL executes against the configured backend using DataEase's stored datasource credentials. No victim action or user interaction is needed. Exploitation is LIMITED by the need for valid credentials with datasource access and by the privileges of the application-held datasource account on the target database; it does not apply to anonymous/unauthenticated users. Fixed in v2.10.27.

Impact

This is a genuine CWE-89 SQL injection in DataEase's CalciteProvider, where user-supplied schema names, connection usernames, table names, and database names were concatenated into metadata queries executed via a plain JDBC Statement rather than parameterized/quoted. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N) indicates remote, low-complexity exploitation with no user interaction, and the high VC:H/VI:H/VA:H impact reflects full compromise of the connected backend database using the application-held datasource credentials. The key limiting signal is PR:L: this is NOT unauthenticated - the attacker must be an authenticated DataEase user who already has datasource access, which meaningfully narrows the threat to insiders or attackers who have obtained valid credentials. No CISA KEV listing and no public POC were provided, so exploitation status is 'no public exploit identified at time of analysis'; EPSS was not supplied. The signals are internally consistent (network vector, authenticated, high impact) with no contradictions, but the real-world priority is tempered by the authentication prerequisite and the fact that the attacker typically already holds some database reach through the datasource feature - the elevation is from configured-datasource access to arbitrary SQL against that backend with the app's credentials.

Exploit ScenarioDerived

An authenticated DataEase user who has access to a configured datasource edits or validates a datasource, injecting crafted SQL metacharacters into the schema name, table name, database name, or connection username fields. When DataEase runs getSchema/validate/save/update, CalciteProvider concatenates the malicious identifier into a metadata query run as a plain JDBC Statement, executing attacker-controlled SQL against the backend with the application's stored datasource credentials. No public exploit code was identified at the time of analysis, and no victim interaction is required.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 14, 2026

SQL injection in DataEase's CalciteProvider allows authenticated users with access to a configured datasource to alter the metadata queries the platform builds for getSchema, validate, save, and update flows, executing attacker-controlled SQL against the connected backend database using the application's stored datasource credentials. The assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (8.7), reflecting high confidentiality, integrity, and availability impact on the backend database with no victim interaction required, though exploitation is constrained by the need for a valid DataEase account that has been granted datasource access and by the privileges of the application-held datasource account. No public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor has released v2.10.27, which introduces identifier quoting, literal escaping, and parameter binding in CalciteProvider.

RemediationAI

Apply the vendor fix by upgrading DataEase to v2.10.27 or later (https://github.com/dataease/dataease/releases/tag/v2.10.27), which is the release carrying the CalciteProvider hardening introduced in commit 181bb5cb95a1174f04689b3b6042d5e0c71b782d - this commit adds an ILLEGAL_IDENTIFIER_CHAR rejection pattern, a quoteName() identifier-quoting helper with a 64-character cap, an escapeSqlLiteral()/sqlFormat() literal-escaping path, a bindQuery() helper that turns '%s' placeholders into JDBC '?' bind parameters, and converts the DB2 schema-enumeration branch from a plain Statement to a PreparedStatement with setString. Consult the GitHub security advisory GHSA-8hgp-vw27-hxph for the vendor's own affected-version statement and any additional guidance before backporting. If immediate upgrade is not possible, the highest-value compensating control is credential containment rather than network blocking, because this vulnerability rides on the application's own authenticated datasource channel: reconfigure every DataEase datasource to use a least-privilege database account restricted to SELECT on the specific schemas and tables actually needed (the trade-off is that reporting or dataset-creation features requiring broader metadata or write access may break, and revoked DDL/write grants will surface as permission errors in DataEase rather than as a visibly blocked attack). Secondarily, restrict who can create or edit datasources and who can invoke datasource metadata operations by tightening DataEase's role/menu permissions so that datasource administration is limited to a small trusted group (trade-off: legitimate analysts lose self-service datasource onboarding), and monitor or alert on DataEase-originated queries that contain unexpected statement terminators, stacked statements, or DDL/DML against catalogs rather than metadata, since the application-held credentials mean such activity arrives from a trusted-looking source IP. Network controls such as blocking the DataEase server from reaching backend databases are only viable if those connections are genuinely unnecessary, and disabling report/dataset features that invoke getSchema, validate, save, or update reduces but does not eliminate exposure because the injection also reaches the save and update flows. No vendor-released patch is missing here - v2.10.27 is the corrective release - so prioritization should center on upgrade plus datasource credential minimization.

Affected VersionsENISA

dataease < 2.10.26

Affected Packages

euvd dataease fix: 2.10.26

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

DataEase is an open-source data visualization and BI platform that connects to external databases (MySQL, DB2, and others) through datasource definitions and executes metadata discovery queries via Apache Calcite-based providers. The vulnerable component is CalciteProvider (core/core-backend/src/main/java/io/dataease/datasource/provider/CalciteProvider.java), which took user-influenced identifiers - schema name, connection username, table name, and database name - and concatenated them directly into SQL text executed through a plain JDBC Statement rather than a PreparedStatement or a hard-quoted identifier. This is a classic CWE-89 improper neutralization of special elements used in an SQL command: because the identifiers were string-formatted into the query template (for example, the schema/table name built into "SELECT * FROM <schema>.<table> LIMIT 0 OFFSET 0"), a crafted value such as a schema containing backticks, quotes, or statement terminators could terminate the intended metadata query and append arbitrary SQL. The same pattern affected the table-field enumeration path, which used string formatting for table names and 'desc' queries, and the schema enumeration path, which interpolated the configured username into the query string (the DB2 branch in the pre-patch code was notably executed with Statement, and the patch converts it to a parameterized PreparedStatement with setString). The upstream fix adds an ILLEGAL_IDENTIFIER_CHAR pattern that rejects control characters, quotes, backticks, brackets, semicolons, and backslashes; a quoteName() helper that enforces a 64-character limit; an escapeSqlLiteral()/sqlFormat() pair for literal escaping; and a bindQuery() helper that converts '%s' placeholders into JDBC '?' bind parameters. Together these changes move the vulnerable metadata queries from string concatenation to identifier validation plus parameterization.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (github) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 8.8 HIGH

Remote network-facing metadata operations (AV:N/AC:L), but a valid account with datasource access is required (PR:L); injected SQL fully compromises the connected DB (C/I/A:H), scope unchanged as the DB is the vulnerable system.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Oct 14, 2026 - 20:34 EUVD
CVE Published
Oct 14, 2026 - 19:17 cve.org
HIGH 8.7

DescriptionCVE.org

DataEase is an open source data visualization and analysis tool. Authenticated users with datasource access can supply crafted schema names, connection usernames, table names, or database names to datasource metadata operations, including getSchema, validate, save, and update flows. CalciteProvider inserts these identifiers into metadata queries that are executed through a plain JDBC Statement, allowing the generated SQL to be altered and run against the configured backend with application-held datasource credentials. The issue can compromise the confidentiality, integrity, and availability of the connected database without requiring a victim action.

Executive ViewAI

Why It Matters

DataEase contains a high-severity SQL injection in its CalciteProvider component that could let authenticated users with datasource access run attacker-controlled SQL against connected backend databases using stored application credentials. This creates a material risk of unauthorized data disclosure, modification, or disruption across business-critical data stores, and leadership should prioritize patching and tightening datasource privileges. No public exploit code or confirmed active exploitation was identified at the time of analysis, but the vendor has released v2.10.27 to address the flaw.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 81% exploitable
Prevalence
Medium
popular open-source BI/data-visualization tool, common but not ubiquitous in enterprises
Data Quality
5 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

SQL injection exploits the way applications construct database queries by mixing user input directly into SQL statements.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy