Skip to main content

Wheels CVE-2026-111444

| EUVDEUVD-2026-102606 CRITICAL
SQL Injection (CWE-89)
2026-10-16 mitre GHSA-cpjx-54pq-8rcv
9.8
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Send crafted request parameter
  2. Delivery
    Reach inline-literal query path
  3. Exploit
    Backslash defeats quote escaping
  4. Execution
    Injected SQL alters query
  5. Impact
    Exfiltrate or modify database

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 a MySQL or MariaDB backend with backslash escaping enabled (NO_BACKSLASH_ESCAPES mode absent - the MySQL default), AND the application must pass attacker-controlled request data into inline-literal query paths: opt-in parameterize=false queries, IN lists, or developer-written where strings at parser-unbound positions (BETWEEN bounds, function arguments, LIKE ESCAPE literals). Limiting factors that prevent exploitation: use of bound/parameterized queries (which are unaffected), whereBetween() which is bound from 4.1.2, databases other than MySQL/MariaDB, and servers running with NO_BACKSLASH_ESCAPES enabled. The authentication requirement is unauthenticated per PR:N, but the vulnerable code path depends on developer query construction rather than a simple default-config remote hit.

Impact

The input CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H = 9.8 Critical) describes an unauthenticated, network-reachable SQL injection (CWE-89) with full confidentiality, integrity and availability impact, which on its face is a top-priority issue. However, the description reveals material preconditions the raw score does not capture: exploitation requires (a) a MySQL/MariaDB backend with backslash escaping enabled (NO_BACKSLASH_ESCAPES absent - the MySQL default), and (b) the application to route attacker-controlled request data into inline-literal paths such as parameterize=false queries, IN lists, or developer-written where strings at parser-unbound positions (BETWEEN bounds, function arguments, LIKE ESCAPE literals). Fully parameterized/bound paths are not affected. This makes the real-world risk highly dependent on application coding patterns rather than being universally exploitable against a default install, so the 9.8 overstates risk for deployments that rely on bound queries. No EPSS score, CISA KEV listing, or POC was provided in the input, so there is no evidence of active exploitation or automatable mass-exploitation; absence of these signals is not proof of safety but does argue against treating this as an under-active-attack emergency. Net: a genuine Critical-class SQLi worth prompt patching for exposed Wheels apps on MySQL/MariaDB, but the practical attack surface is gated by developer query construction, so prioritize applications known to use parameterize=false or raw where-string literals.

Exploit ScenarioDerived

An attacker submits crafted request data (e.g., a query-string or form parameter) to a Wheels endpoint whose underlying query places that value into an inline SQL literal - for example a parameterize=false query or a where string using a BETWEEN bound or LIKE ESCAPE literal. Because the framework doubles single quotes but does not account for backslash escaping on MySQL/MariaDB, the attacker uses a backslash to neutralize the escaping and break out of the literal, altering the query to read, modify, or destroy database contents. No public exploit code was identified in the provided data.

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 16, 2026

SQL injection in the Wheels CFML framework through 4.1.2 lets remote attackers manipulate SQL statements when an application feeds request data into inline-literal query paths - opt-in parameterize=false queries, IN lists, and developer-written where strings at positions the parser does not bind, such as BETWEEN bounds, function arguments and LIKE ESCAPE literals. The flaw is reachable unauthenticated over the network (CVSS 3.1 9.8, PR:N) but only materialises on MySQL or MariaDB backends running with the default backslash-escaping behaviour (NO_BACKSLASH_ESCAPES absent), and only where the developer has constructed the vulnerable query form; bound/parameterized queries and whereBetween() as of 4.1.2 are not affected. No public exploit code or confirmed active exploitation was identified at time of analysis. The issue is fixed in Wheels 4.2.0.

RemediationAI

Upgrade to Wheels 4.2.0, the vendor-released fix for this issue, following the guidance in the advisory at https://github.com/wheels-dev/wheels/security/advisories/GHSA-mvr9-2h5x-w6cq; this is the only complete remediation because the escaping defect is inside the framework's literal-quoting code. Where an immediate upgrade is not possible, apply the following compensating controls and accept their trade-offs: (1) audit application code for parameterize=false queries, IN list construction, and manually written where fragments containing BETWEEN bounds, function arguments or LIKE ESCAPE literals, and rewrite them to use bound parameters or the whereBetween() helper (bound from 4.1.2) - this requires developer effort and code review but removes the vulnerable path entirely; (2) set the MySQL/MariaDB session or server SQL mode to include NO_BACKSLASH_ESCAPES so the backslash escape is not honoured, which neutralises this class of injection but can break existing application data and queries that rely on backslash escaping semantics, so it must be tested before rollout; (3) restrict database account privileges used by the Wheels application to the minimum required (no FILE, no stacked-statement or DDL rights) to limit the blast radius of any successful injection; (4) place the application behind network controls or authentication where the exposed endpoints are not intended to be public. Note that filtering or escaping user input application-side is not a reliable substitute, because the flaw is in how the framework itself quotes literals.

Affected VersionsENISA

Wheels 0 <4.2.0

Affected Packages

euvd wheels fix: 4.2.0

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

The root cause is CWE-89 (Improper Neutralisation of Special Elements used in an SQL Command). Wheels builds SQL by escaping string literals in the classic SQL way - doubling embedded single quotes - rather than relying solely on server-side prepared statement binding for every position in a query. That escaping model is sound on ANSI SQL semantics but breaks down on MySQL/MariaDB, where a backslash acts as an escape character inside string literals unless the server runs with NO_BACKSLASH_ESCAPES enabled. Because the framework's literal-quoting logic does not account for backslash escapes, an attacker-supplied value can use a trailing backslash to consume the closing quote the framework emits, escaping the string context and injecting arbitrary SQL. The vulnerable paths are specifically the inline-literal ones: queries written with the opt-in parameterize=false option, IN list expansion, and developer-authored where clause fragments at positions the parser does not automatically bind - BETWEEN lower/upper bounds, arguments passed to SQL functions, and LIKE ... ESCAPE literals. Properly bound/parameterized paths, and the whereBetween() helper from version 4.1.2 onward, are not affected. The CPE entry cpe:2.3:a:wheels:wheels:*:*:*:*:*:*:*:* confirms all released versions up to and including 4.1.2 are in scope; 4.2.0 is the first fixed release. The assessed vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H reflects that no authentication or user interaction is required once a reachable vulnerable code path exists, and that successful injection yields full read, write and availability impact on the backing database.

Know when Wheels 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 (mitre) 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

Unauthenticated request data reaches parser-unbound literal positions on default MySQL backslash escaping (AV:N/AC:L/PR:N/UI:N); SQL injection yields full read/write/destructive DB impact (C/I/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 (mitre).

CVSS VectorVendor: mitre

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 16, 2026 - 05:16 EUVD
CVE Published
Oct 16, 2026 - 03:31 cve.org
CRITICAL 9.8

DescriptionCVE.org

Wheels through 4.1.2 allows SQL injection on MySQL/MariaDB with backslash escaping enabled (NO_BACKSLASH_ESCAPES absent) when an application supplies request data to inline-literal paths. These include opt-in parameterize=false queries and IN lists, and positions in developer-written where strings that the parser does not bind, such as BETWEEN bounds, function arguments and LIKE ESCAPE literals. Doubling single quotes without accounting for backslash escapes allows a value to alter the query. Bound paths are not affected; whereBetween() is bound from 4.1.2. This is fixed in 4.2.0.

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 the Wheels CFML framework (versions through 4.1.2) allows unauthenticated remote attackers to manipulate database queries in applications that pass request data into certain developer-written query forms, potentially exposing or altering the contents of the underlying database. The exposure is limited to internet- or network-reachable CFML applications running on MySQL or MariaDB with default escaping behavior and using affected inline-literal query patterns. Because exploitation requires no credentials and the affected data stores often hold customer, transactional, or regulated information, leadership should treat remediation of any matching deployment as an urgent priority.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 83% exploitable
Prevalence
Low
Wheels (CFWheels) is a niche CFML/ColdFusion MVC framework
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.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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
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.

More in Wheels

View all

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