Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted request parameter
-
DeliveryReach inline-literal query path
-
ExploitBackslash defeats quote escaping
-
ExecutionInjected SQL alters query
-
ImpactExfiltrate 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
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).
Primary rating from Vendor (mitre).
CVSS VectorVendor: mitre
Lifecycle Timeline
2DescriptionCVE.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
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.
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.
SQL injection in the Wheels CFML framework versions 1.1.8 through 4.1.1 can let unauthenticated remote attackers alter S
Remote, unauthenticated attackers can access password-less development tools under /wheels/* in Wheels 4.0.0 through 4.1
Broken object-level authorization in the Wheels CFML framework (versions 1.1 through 4.1.2) allows an authenticated low-
Broken object-level authorization in the Wheels (CFML) framework 4.0.0 through 4.1.2 lets an authenticated low-privilege
Unauthenticated request-context confusion in Wheels 4.0.6 through 4.1.2 lets any remote client push a normal request int
Exception-detail disclosure in the Wheels CFML framework (versions 3.0.0 through 4.1.1) lets a remote, unauthenticated c
Information disclosure in the Wheels CFML framework through 4.1.1 allows an unauthenticated remote attacker who wins a c
Reload-password and code disclosure, plus unintended state-changing operations against a foreign local server, affect de
Wheels 4.0.0 through 4.1.2 performs case-insensitive path-containment checks on case-sensitive filesystems, so a pre-exi
EUVD-2026-102606
GHSA-cpjx-54pq-8rcv
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB