Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify app endpoint reaching vulnerable Exposed function
-
DeliverySubmit crafted string argument
-
ExploitInjected SQL alters query via unescaped input
-
ExecutionDatabase executes attacker SQL
-
ImpactExfiltrate or modify 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 | Exploitation requires a downstream application that (1) uses JetBrains Exposed before version 1.5.1 and (2) passes attacker-controllable, unescaped string values into one of the specific affected SQL functions that fail to escape string arguments. This is the concrete prerequisite stated by the advisory ('via unescaped string arguments of several SQL functions'). The key limiting factor is that the flaw is not triggerable against the library in isolation: an application must actually route untrusted input into the vulnerable function calls, so apps that only pass literals or use parameterized/escaped paths are not exposed. Unauthenticated reach (per PR:N) depends on the hosting application exposing the vulnerable code path without authentication; the exact function names are not provided, so developers must audit their Exposed usage to confirm applicability. |
| Impact | The input CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, base 9.8) describes an unauthenticated, network-reachable SQL injection (CWE-89) with full confidentiality, integrity, and availability impact - a worst-case nominal score. However, the signals are incomplete and partly in tension with the description. No EPSS probability was provided, the CVE is NOT on the CISA KEV list, and no public proof-of-concept is indicated, so exploitation status is: no public exploit identified at time of analysis. Critically, Exposed is a Kotlin SQL library/ORM, not a standalone network service: the 9.8 severity is only realized when a downstream application passes untrusted input to the specific affected SQL functions without escaping. The PR:N/AV:N scoring reflects the end attacker (typically an unauthenticated web user hitting a vulnerable app endpoint) rather than any inherent remote listener in the library itself. This is therefore a real and serious priority for teams that build on Exposed and use the affected functions with user-controlled strings, but the absence of KEV/EPSS/POC signals, combined with the conditional 'developer-must-have-used-the-vulnerable-API' nature of library SQLi, argues against assuming widespread opportunistic exploitation. Treat as high-priority-to-patch rather than confirmed-under-attack. |
| Exploit ScenarioDerived | A web application built on JetBrains Exposed (before 1.5.1) passes user-supplied input into one of the affected SQL functions that does not escape string arguments. An unauthenticated attacker submits a crafted value through a normal request field, which is concatenated into the generated SQL and alters the query, allowing data exfiltration or manipulation. No public exploit code has been identified, so exploitation would currently require an attacker to craft their own payload against a known-vulnerable usage. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
SQL injection in JetBrains Exposed before 1.5.1 enables unauthenticated remote attackers to execute arbitrary SQL against downstream applications that pass attacker-controllable, unescaped string arguments into several affected SQL functions. The library itself is not directly exploitable; exploitation requires a hosting application to route untrusted input into the vulnerable function calls, so applications that only pass literals or use parameterized/escaped paths are unaffected. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, base 9.8) describes a worst-case nominal impact of full confidentiality, integrity, and availability loss; no public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis.
RemediationAI
Upgrade to JetBrains Exposed 1.5.1 or later; this is the vendor-released patch version per the advisory. Because exploitation requires a downstream application to pass unescaped string arguments into vulnerable SQL functions, developers should also audit their Exposed usage and replace string concatenation with parameterized queries or properly escaped inputs. If immediate upgrade is not possible, restrict network access to application endpoints that invoke affected Exposed functions (e.g., via authentication, WAF rules blocking SQLi patterns, or IP allowlists), though these are compensating controls and do not eliminate the root cause. Refer to the JetBrains advisory at https://www.jetbrains.com/privacy-security/issues-fixed/ for the most current guidance.
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
JetBrains Exposed is a Kotlin SQL framework/ORM that provides a DSL for database access. The vulnerability is CWE-89 (Improper Neutralization of Special Elements used in an SQL Command), where several SQL functions fail to escape string arguments before concatenating them into queries. The CPE cpe:2.3:a:jetbrains:exposed:*:*:*:*:*:*:*:* identifies the affected product across versions prior to 1.5.1. An attacker who controls a string value that is passed into one of these functions can inject arbitrary SQL, potentially leading to data theft, modification, or deletion depending on database permissions. The flaw is not exploitable in the library on its own; it manifests through an application that uses Exposed and does not independently sanitize or parameterize the untrusted input. The CVSS vector PR:N indicates unauthenticated access, but this is contingent on the downstream application exposing the vulnerable code path without authentication, as noted in the independent assessment.
Know when Exposed gets its next vulnerability
- 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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
SQL injection reachable by an unauthenticated web user through an app's untrusted input (AV:N/PR:N/AC:L), yielding full read/write and potential destructive DB impact (C:H/I:H/A:H).
Primary rating from Vendor (JetBrains).
CVSS VectorVendor: JetBrains
Lifecycle Timeline
2DescriptionCVE.org
In JetBrains Exposed before 1.5.1 sQL injection was possible via unescaped string arguments of several SQL functions
Executive ViewAI
JetBrains Exposed, a Kotlin database library embedded inside many enterprise applications, carries a critical SQL injection flaw that can hand an attacker full read, write, and delete access to any downstream application's database if that application routes untrusted input into the affected query functions. The library is not exploitable on its own, so leadership exposure is concentrated in the product teams whose services embed Exposed and accept user-supplied strings; for those services the consequence is potential wholesale loss of data confidentiality, integrity, and availability, with breach-notification and regulatory implications. No public exploit code or confirmed active exploitation was identified at time of analysis, but the unauthenticated, low-complexity attack profile means the risk can escalate quickly once proof-of-concept code circulates.
No vendor-released patch identified at time of analysis; the advisory names 1.5.1 as the affected-version boundary, so upgrading to that release is the remediation target to confirm with the vendor. Interim mitigations: enforce parameterized or escaped query construction for every value entering the affected SQL functions, refuse untrusted string arguments to query builders, apply strict input validation and allowlisting at service boundaries, run affected databases under least-privilege accounts without DDL or bulk-delete rights, deploy SQL injection WAF rules and database activity monitoring in front of internet-facing services, and temporarily disable or gate features that must pass user-controlled strings into dynamic SQL.
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-96025
GHSA-cv5g-jv44-53r2
NVD
CVE.org
EPSS
VulDB
Exploit-DB