Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as DataEase user with datasource access
-
DeliverySubmit crafted schema/table/username identifier
-
ExploitCalciteProvider concatenates into JDBC Statement
-
ExecutionInjected SQL executes on backend DB
-
ImpactRead, 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
2DescriptionCVE.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
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.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
SQL injection exploits the way applications construct database queries by mixing user input directly into SQL statements.
EUVD-2026-101608
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB