Skip to main content

HoneySQL EUVDEUVD-2026-114395

| CVE-2026-61620 CRITICAL
SQL Injection (CWE-89)
2026-10-30 security-advisories@github.com
9.8
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

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

  1. Access
    Identify app input flowing into keyword/symbol
  2. Exploit
    Inject SQL metacharacters via entity name
  3. Execution
    HoneySQL emits tainted SQL string
  4. Impact
    JDBC executes, read/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 the consuming application to pass user input or other arbitrary data into HoneySQL's DSL by calling keyword or symbol on that data, and the resulting SQL to be executed unchanged by a JDBC driver; the flaw manifests only because some formatters do not apply the existing suspicious-character check to entity names. It is further limited to library versions >= 2.0.0 and < 2.7.1392, and the severity of impact is bounded by the privileges of the database connection running the statement. Applications that never route untrusted data through keyword/symbol entity construction are not exploitable even on vulnerable versions. The maintainer workaround is to validate input before constructing keyword/symbol entities, though the maintainer notes this is tedious and error-prone; upgrading to 2.7.1392 is the designated fix.

Impact

The input assigns CVSS 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) and a vuln.today 'act_now' decision label, both signaling top urgency, and the CWE-89 classification plus GHSA advisory confirm this is a genuine SQL injection weakness. However, these signals must be read against the vulnerability's nature: this is a library-level flaw that only becomes exploitable when the consuming application itself passes user-controlled or otherwise arbitrary data into HoneySQL's DSL by calling keyword or symbol on it - a specific, non-default coding pattern on the application side. The CVSS vector therefore describes the worst-case exploitable application (remote, unauthenticated, full CIA impact), not every deployment of the library. No EPSS score, no CISA KEV listing, and no verified exploit code are present in the input, so there is no evidence of active exploitation or mass scanning; the 9.8/act_now posture is driven by severity and the ease of exploitation in affected apps rather than by observed in-the-wild activity. The maintainer also notes the real impact 'depends on the privileges of the database connection executing the generated statement,' so C/I/A impact in practice scales with DB account privileges. Net: this is a real, high-priority patch for any Clojure application that feeds untrusted data through keyword/symbol into HoneySQL, but the blanket 9.8 overstates risk for applications that never pass arbitrary input into entity names.

Exploit ScenarioDerived

An attacker supplies crafted input (for example a column or table name derived from an HTTP parameter) to a Clojure application that converts that input via keyword or symbol into a HoneySQL entity. Because some formatters do not apply the suspicious-character check, the resulting entity name carries SQL metacharacters into the generated SQL string, which a JDBC driver then executes unchanged, yielding SQL injection. No public exploit code is identified in the provided input; the GitHub references are the patch commit and advisory, not a working exploit.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 30, 2026

SQL injection can result in HoneySQL (Clojure; Maven/Clojars coordinate com.github.seancorfield/honeysql) versions 2.0.0 through 2.7.1391 when an application calls keyword or symbol on untrusted input to build DSL entities and the rendered SQL string is then executed unchanged by a JDBC driver, because several formatters emit those entity names without applying the library's existing suspicious-character check. The CVSS vector is AV:N/AC:L/PR:N/UI:N (unauthenticated, network-reachable), and the impact is bounded by the privileges of the database connection that runs the generated statement; applications that never route arbitrary data through keyword/symbol entity construction are not exploitable even on vulnerable versions. No public exploit code was identified at time of analysis, and the maintainer-designated fix is release 2.7.1392, with a vuln.today decision label of act_now reflecting the 9.8 severity score and CWE-89 classification.

RemediationAI

Vendor-released patch: upgrade com.github.seancorfield/honeysql to 2.7.1392 or later, per the GHSA advisory (https://github.com/seancorfield/honeysql/security/advisories/GHSA-fcfq-xqgp-8v97) and the release notes (https://github.com/seancorfield/honeysql/releases/tag/v2.7.1392); audit dependencies transitively, since HoneySQL is typically pulled in as a library rather than run as a service. The maintainer's documented workaround is to validate input before calling keyword or symbol when constructing DSL entities, which the advisory itself describes as tedious and error-prone if a single input is missed, so it is a stopgap only for code that cannot yet upgrade. Because the advisory notes that impact depends on the privileges of the connection executing the generated statement, running affected applications against least-privilege database accounts limits what an injected statement can reach, though this bounds rather than removes the flaw. Note that 2.7.1390 was an intermediate hardening step that expanded the suspicious-character check and applied it to sql-kw; it is not the maintainer-designated fixed version, which is 2.7.1392.

Affected VersionsENISA

honeysql 2.0.0, < 2.7.1392

Affected Packages

euvd honeysql fix: 2.7.1392

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

HoneySQL is a Clojure/ClojureScript library that compiles Clojure data structures (maps, vectors, keywords, symbols) into SQL strings, which are typically handed verbatim to a JDBC driver. Identifiers such as column and table names cannot be bound as JDBC parameters, so the library renders them by concatenating formatted entity names into the statement text; the only defense in that path is a 'suspicious character' filter. CWE-89 (Improper Neutralization of Special Elements used in an SQL Command) applies because some formatters skipped that filter, so a keyword or symbol derived from user input could carry SQL syntax into the emitted identifier position. The referenced upstream commit (1141fcd) shows the direction of the hardening: the private suspicious character set was narrowed from ";,()\r\n\t" to ";,", a suspicious-entity-check was added to the sql-kw formatter path, and string inlining was consolidated into an inline-str helper that doubles single quotes; that commit corresponds to the 2.7.1390 changelog entry, which describes applying the expanded check to sql-kw. The GHSA advisory states that 2.7.1392 extends the existing suspicious-character check to additional formatters, which is what closes the reported injection vector; the exact set of formatters covered only in 2.7.1392 versus earlier releases is not itemized in the available sources.

Know when Clojure 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 (github) 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

For an app that feeds untrusted data into keyword/symbol entities, injection is remote, unauthenticated and straightforward with full DB read/write impact bounded by connection privileges.

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

CVSS VectorVendor: github

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 30, 2026 - 21:18 EUVD
CVE Published
Oct 30, 2026 - 20:17 cve.org
CRITICAL 9.8

DescriptionCVE.org

HoneySQL turns Clojure data structures into SQL. From 2.0.0 until 2.7.1392, applications that pass user input or other arbitrary data into the HoneySQL DSL by calling keyword or symbol on that input can produce SQL strings that facilitate SQL injection when executed unchanged by a JDBC driver. Some formatters do not apply the existing suspicious-character check to the resulting entity names. The impact depends on the privileges of the database connection executing the generated statement. Input validation before constructing keyword or symbol entities is a workaround. The maintainer-designated fixed version is 2.7.1392.

Technical POC Analysis

CWE-89: Improper Neutralization of Special Elements used in an SQL Command.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

A critical SQL injection flaw in HoneySQL, an open-source Clojure library used to build SQL queries, affects versions 2.0.0 through 2.7.1391. Any internal application that passes untrusted user input through the library's entity construction could allow an attacker to execute arbitrary SQL against backend databases, potentially exposing or altering sensitive data. Leadership should care because a successful compromise is bounded only by the privileges of the database connection, and any internet-facing service built on the affected library becomes a priority exposure.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis; interim mitigations include restricting database connection privileges to least-privilege accounts, validating and allow-listing input before it reaches keyword or symbol entity construction, and reviewing code to ensure untrusted data is never used to build DSL entities. The maintainer-designated fix is release 2.7.1392.

Threat Intelligence Overview

EPSS Score
0.4%
Top 67% exploitable
Prevalence
Low
Most popular SQL DSL in the comparatively niche Clojure ecosystem
Data Quality
6 sources
Confidence: High

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.4%
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Total

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