Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify Wheels app endpoint using dynamic finder
-
DeliverySubmit value with doubled single quote
-
ExploitParser ends literal early, injects SQL
-
ExecutionQuery executes attacker-controlled clause
-
ImpactBypass auth or exfiltrate credentials/tokens
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 an application built on Wheels 1.1.8-4.1.1 that passes caller-supplied string (non-numeric) values into one of the affected APIs: dynamic finders (e.g. findOneByEmail), where(property, value) / where(property, operator, value), string/UUID-key lookup paths (findByKey, updateByKey, deleteByKey, findOrCreateBy...), or validatesUniquenessOf. The concrete trigger is a quoted value containing a doubled single quote, which the parser wrongly treats as the end of the literal. LIMITING FACTORS: numeric-column values are NOT exploitable; the whereBetween() variant (4.0.0-4.1.1 only) is additionally gated on MySQL/MariaDB running with backslash escaping enabled; and exploitation is only remote/unauthenticated where the application actually forwards untrusted request data to these calls rather than sanitizing or parameterizing it first. |
| 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) treats this as a remote, unauthenticated, low-complexity SQL injection with full CIA impact (CWE-89). That rating is plausible but conditional: the flaw lives in framework APIs (dynamic finders like findOneByEmail, where()/whereBetween(), *ByKey lookups, findOrCreateBy..., validatesUniquenessOf), so network-reachable unauthenticated exploitation only materializes when an application actually routes untrusted request data into those calls - which is common but not guaranteed, so real-world risk is application-dependent rather than universal. No EPSS score, no CISA KEV listing, and no public POC were provided, so there is no public exploit identified at time of analysis and no evidence of active exploitation; the 9.8 therefore reflects theoretical severity, not demonstrated mass exploitation. Mitigating nuances the raw score hides: numeric-column values are not affected, and the whereBetween() variant (4.0.0-4.1.1) is further gated on MySQL/MariaDB with backslash escaping enabled. Net: a genuine high priority for teams running Wheels apps that expose these APIs to user input (especially auth, password-reset, and token lookups), but the low real-world footprint of the product tempers absolute risk - treat as patch-urgent for affected deployments rather than an internet-wide emergency. |
| Exploit ScenarioDerived | An attacker submits a crafted value - e.g. an email or token containing a doubled single quote - to a login, password-reset, or lookup endpoint whose handler calls a Wheels dynamic finder such as findOneByEmail or where(property, value). Because the parser mistreats the doubled quote as the end of a string literal, the remainder of the attacker's input is parsed as SQL, letting them bypass authentication or read unauthorized rows. No authentication or user interaction is required when the vulnerable API is exposed to request data; 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 15, 2026
SQL injection in the Wheels CFML framework versions 1.1.8 through 4.1.1 can let unauthenticated remote attackers alter SQL queries when applications pass caller-supplied string values into dynamic finders such as findOneByEmail, query-builder where(property, value) and where(property, operator, value), string/UUID-key lookup paths like findByKey, updateByKey, deleteByKey, findOrCreateBy..., or validatesUniquenessOf. The parser mishandles a doubled single quote by treating it as the end of a string literal, potentially exposing authentication, password-reset, and token lookups; the whereBetween() variant in 4.0.0 through 4.1.1 is additionally gated on MySQL/MariaDB running with backslash escaping enabled, and numeric-column values are not affected. The issue is fixed in 4.1.2, and no public exploit was identified at time of analysis.
RemediationAI
Upgrade to Wheels 4.1.2, which is the vendor-released patched version that fixes this SQL injection. If immediate upgrade is not possible, avoid passing caller-supplied string values directly into the affected APIs, including dynamic finders, query-builder where() and whereBetween() calls, string/UUID-key lookup methods, and validatesUniquenessOf; instead use parameterized queries or strict allow-list validation so that doubled single quotes cannot reach the framework parser. For the whereBetween() variant on MySQL/MariaDB, disabling backslash escaping via NO_BACKSLASH_ESCAPES removes that specific trigger, but this changes escaping behavior globally and may affect other queries, so it should be treated only as a temporary compensating control. Review the vendor advisory at https://github.com/wheels-dev/wheels/security/advisories/GHSA-96rm-h22v-925x for any additional guidance and confirm that no application code continues to forward untrusted request data to these APIs.
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
Wheels is a ColdFusion/CFML MVC framework, and this is a CWE-89 SQL injection caused by incorrect parsing of quoted string literals in the framework's query-generation layer. Specifically, the parser treats a doubled single quote ('') as the end of a literal rather than as an escaped quote, so caller-supplied string values that contain such sequences can break out of the intended SQL context when used in dynamic finders, query-builder where() calls, string/UUID-key lookup methods, and validatesUniquenessOf. The separate whereBetween() concern in 4.0.0 through 4.1.1 occurs because string/date bounds can alter SQL on MySQL/MariaDB when backslash escaping is enabled. The CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (base 9.8) is consistent with the independent assessment: remote, unauthenticated, low-complexity SQL injection with high confidentiality, integrity, and availability impact, though exploitation requires an application that actually forwards untrusted request data to the affected APIs, and numeric-column values are not exploitable.
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
SQLi reachable over the network with no auth or interaction when request data hits the finder APIs, yielding full read/write/DB impact; AC:L since a doubled-quote payload is trivial.
Primary rating from Vendor (mitre).
CVSS VectorVendor: mitre
Lifecycle Timeline
2DescriptionCVE.org
Wheels 1.1.8 through 4.1.1 allows SQL injection when caller-supplied quoted values are parsed again as SQL by dynamic finders (such as findOneByEmail), the query builder's where(property, value) and where(property, operator, value), string/UUID-key lookup paths (findByKey, updateByKey, deleteByKey and findOrCreateBy...), and validatesUniquenessOf. The parser incorrectly treats a doubled single quote as the end of a literal. Applications passing request data to these APIs can expose authentication, password-reset or token lookups, and data to unauthorized access; numeric-column values are not affected. There is a similar concern for query-builder whereBetween() in 4.0.0 through 4.1.1: string/date bounds can alter SQL on MySQL/MariaDB with backslash escaping enabled. This is fixed in 4.1.2.
Technical POC Analysis
CWE-89: SQL injection.
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 1.1.8 through 4.1.1) lets crafted string input alter database queries in common finder, key-lookup and uniqueness-validation helpers, potentially exposing authentication, password-reset and token data held by any application built on the framework. Because Wheels is embedded in application code rather than a single system, the remediation burden is multiplied across every Wheels-based service in the portfolio, including customer-facing and internal CFML applications. No public exploit has been identified at time of analysis, but the affected helpers sit on ordinary request paths, so leadership should treat this as an urgent inventory-and-upgrade programme rather than routine maintenance.
Apply vendor patch (upgrade to Wheels 4.1.2 per vendor advisory). Where the upgrade cannot be completed immediately, interim mitigations include disabling or refactoring affected dynamic finder and key-lookup calls in favour of properly parameterised queries, blocking or normalising doubled single-quote input at the WAF/application boundary on affected endpoints, restricting database account privileges used by affected applications, and rotating any authentication, password-reset or token values that may have been exposed.
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.
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
SQL injection in the Wheels CFML framework through 4.1.2 lets remote attackers manipulate SQL statements when an applica
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-101818
GHSA-2wh3-67f4-gxgc
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB