Skip to main content

JetBrains Exposed CVE-2026-108474

| EUVDEUVD-2026-96025 CRITICAL
SQL Injection (CWE-89)
2026-10-09 JetBrains GHSA-cv5g-jv44-53r2
9.8
CVSS 3.1 · Vendor: JetBrains
View

Attack ChainAIDerived

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

  1. Access
    Identify app endpoint reaching vulnerable Exposed function
  2. Delivery
    Submit crafted string argument
  3. Exploit
    Injected SQL alters query via unescaped input
  4. Execution
    Database executes attacker SQL
  5. Impact
    Exfiltrate 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
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 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

Exposed 0 <1.5.1

Affected Packages

euvd exposed fix: 1.5.1

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

Vendor (JetBrains) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 9.8 CRITICAL

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).

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

Primary rating from Vendor (JetBrains).

CVSS VectorVendor: JetBrains

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Oct 10, 2026 - 02:01 EUVD
CVE Published
Oct 09, 2026 - 23:13 cve.org
CRITICAL 9.8

DescriptionCVE.org

In JetBrains Exposed before 1.5.1 sQL injection was possible via unescaped string arguments of several SQL functions

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.3%
Top 77% exploitable
Prevalence
Medium
popular Kotlin SQL/ORM library, but not universally deployed like core servers
Social Media
6
Sightings
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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

49
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +49
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