Skip to main content

Wheels CVE-2026-110911

| EUVDEUVD-2026-101818 CRITICAL
SQL Injection (CWE-89)
2026-10-15 mitre GHSA-2wh3-67f4-gxgc
9.8
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Identify Wheels app endpoint using dynamic finder
  2. Delivery
    Submit value with doubled single quote
  3. Exploit
    Parser ends literal early, injects SQL
  4. Execution
    Query executes attacker-controlled clause
  5. Impact
    Bypass 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.

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

Wheels 1.1.8 <4.1.2

Affected Packages

euvd wheels fix: 4.1.2

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

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

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.

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

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.3%
Top 79% exploitable
Prevalence
Low
Wheels is a niche ColdFusion/CFML MVC framework, limited production footprint
Social Media
4
Sightings
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
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.

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

More in Wheels

View all

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