Skip to main content

Qt Framework EUVDEUVD-2026-46257

| CVE-2026-9499 MEDIUM
Out-of-bounds Read (CWE-125)
2026-07-21 TQtC GHSA-8cm2-5hwv-mhv9
6.3
CVSS 4.0 · Vendor: TQtC
View

Attack ChainAIDerived

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

  1. Access
    Supply attacker-controlled charset/encoding name via network
  2. Delivery
    Application wraps value in non-NUL-terminated QByteArray via fromRawData()
  3. Exploit
    QTextCodec::codecForName() reads past end of buffer
  4. Execution
    Overread crosses unmapped memory page boundary
  5. Impact
    Process crash causes denial of service

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK

1 technique across 1 tactic: Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires two concurrent conditions: (1) the target application must call QTextCodec::codecForName() with a QByteArray constructed via QByteArray::fromRawData() or another method that does not guarantee a NUL terminator on the underlying buffer; and (2) the content or length of that byte array must be influenced by attacker-controlled data, such as a network-supplied charset or encoding name in a file, document, or protocol field. Applications that pass only string literals, the result of QString::toLatin1(), or other NUL-terminated constructions to this function are not exposed. The worst-case crash (DoS) is not deterministic - it requires that the overread advance past the end of a valid memory page into unmapped address space, which depends on runtime memory layout. The CVSS 4.0 AT:P metric explicitly encodes these prerequisite conditions. Authentication requirements are not confirmed from available data: the vector shows PR:N, but whether the network endpoint that feeds codec names is publicly accessible or requires a session depends entirely on the consuming application.

Impact

The CVSS 4.0 base score of 6.3 (Medium) with vector AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:L reflects the constrained nature of this flaw. The AT:P (Attack Requirements Present) metric is the decisive signal: exploitation requires a specific, non-default application code path where a non-NUL-terminated QByteArray is passed to QTextCodec::codecForName(), which is not a typical Qt usage pattern. Integrity impact is Low (incorrect codec selection), and availability impact is Low since a crash occurs only if the overread crosses an unmapped virtual memory page boundary - a hardware- and OS-layout-dependent outcome that is not guaranteed. Confidentiality is explicitly rated N; the authoritative CVE description confirms no data is disclosed. No EPSS score was present in the provided intelligence. The absence of a CISA KEV listing and the lack of any known public exploit further suppress real-world urgency. Notably, the 'Information Disclosure' tag in the source intelligence directly contradicts the CVE description's explicit statement that no data is disclosed to an attacker - this tag is assessed as erroneous, and the vendor-authored description takes precedence. Overall, this is a real but low-priority issue: meaningful only for Qt applications that process untrusted external data through codec-selection APIs using raw, non-NUL-terminated byte arrays.

Exploit ScenarioDerived

An attacker sends a malformed codec-name field over the network to a Qt-based application that reads character-encoding metadata from external documents or protocol messages and passes that value - via QByteArray::fromRawData() - directly to QTextCodec::codecForName(). The codec-name matching routine reads past the end of the buffer; if the overread crosses an unmapped virtual memory page, the application process terminates with a segmentation fault, producing a denial-of-service condition. No public exploit code has been identified at time of analysis.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
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 – Jul 21, 2026

Out-of-bounds read in Qt's QTextCodec::codecForName() causes incorrect text codec selection or a process crash (denial of service) when the function is supplied a non-NUL-terminated QByteArray constructed via QByteArray::fromRawData(). Affected components span Qt Core (qtbase) in Qt 4.x and 5.x, and the Qt5Compat module in Qt 6.0.0 onward. No public exploit has been identified and no CISA KEV listing exists; real-world risk is confined to applications whose codec-selection paths are reachable from attacker-controlled input and that specifically construct raw, non-NUL-terminated byte arrays before passing them to this API.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed. Developers should monitor the four Qt project code review entries at https://codereview.qt-project.org/c/qt/qt5compat/+/723911, https://codereview.qt-project.org/c/qt/qt5compat/+/724348, https://codereview.qt-project.org/c/qt/qt5compat/+/724995, and https://codereview.qt-project.org/c/qt/tqtc-qt5compat/+/725112, and upgrade once a tagged Qt release incorporating these changes is published. As a complete application-level workaround with no side effects, audit all call sites of QTextCodec::codecForName() and ensure the supplied QByteArray is NUL-terminated - avoid using QByteArray::fromRawData() for this purpose, or append a NUL byte explicitly before the call. This eliminates the vulnerability without requiring a Qt runtime upgrade. Applications that do not pass non-NUL-terminated QByteArrays to this function are entirely unaffected and require no action.

Affected VersionsENISA

Qt 6.0.0 <6.8.8
Qt 4.0.0 <6.0.0
Qt 6.9.0 <6.11.1

Affected Packages

euvd qt fix: 6.0.0, 6.8.8, 6.11.1

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

Qt is a cross-platform C++ application framework widely used for desktop, embedded, and mobile software. QTextCodec::codecForName() accepts a codec name as a QByteArray and returns the matching text codec object. CWE-125 (Out-of-bounds Read) describes the root cause: when the QByteArray is created with QByteArray::fromRawData() - which wraps a raw C pointer without guaranteeing NUL-termination - the internal codec-name matching loop reads beyond the supplied buffer boundary, comparing overread bytes against Qt's fixed internal list of codec names. The overread distance is bounded by the length of the longest name in that fixed list, and because the overread bytes are never returned to the caller or transmitted externally, there is no data exfiltration path. The flaw exists natively in Qt Core (qtbase) across Qt 4.x and Qt 5.x, and was carried into the Qt5Compat compatibility module used by Qt 6.0.0 and later. CPE string cpe:2.3:a:qt:qt:*:*:*:*:*:*:*:* covers all affected versions.

Know when Qt 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 (TQtC) PRIMARY 6.3 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:L/SC:N/SI:N/SA:N
vuln.today AI 4.8 MEDIUM

AC:H captures the specific non-NUL-terminated QByteArray precondition; C:N is confirmed by the vendor's explicit statement that no data is disclosed.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:L
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:L/SC:N/SI:N/SA:N
SUSE 5.9 MEDIUM
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
Red Hat 7.5 HIGH

Primary rating from Vendor (TQtC).

CVSS VectorVendor: TQtC

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

An out-of-bounds read (buffer over-read) vulnerability exists in QTextCodec::codecForName() in Qt. When the function is called with a QByteArray that is not NUL-terminated (for example, one created with QByteArray::fromRawData()), the codec-name matching routine reads past the end of the supplied buffer. In most cases this results in an incorrect text codec being selected; in the worst case, if the over-read reaches unmapped memory, the process crashes (denial of service). The over-read is bounded by the length of the longest codec-name candidate, and the out-of-bounds bytes are only compared internally against Qt's fixed list of codec names, so no data is disclosed to an attacker. Applications that do not pass non-NUL-terminated QByteArrays to QTextCodec::codecForName() are not exposed. The affected code resides in the Qt5Compat module from Qt 6.0.0 onward, and in Qt Core (qtbase) in Qt 4.x and Qt 5.x.

Threat Intelligence Overview

EPSS Score
0.3%
Top 78% exploitable
Prevalence
High
Qt is a major cross-platform C++ framework used across millions of desktop and embedded applications.
Data Quality
4 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact· derived
High

Priority Score

32
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +32
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Qt

View all
CVE-2020-12267 CRITICAL POC
9.8 Apr 27

setMarkdown in Qt before 5.14.2 has a use-after-free related to QTextMarkdownImporter::insertBlock. Rated critical sever

CVE-2023-37369 HIGH POC
7.5 Aug 20

In Qt before 5.15.15, 6.x before 6.2.9, and 6.3.x through 6.5.x before 6.5.2, there can be an application crash in QXmlS

CVE-2020-13962 HIGH POC
7.5 Jun 09

Qt 5.12.2 through 5.14.2, as used in unofficial builds of Mumble 1.3.0 and other products, mishandles OpenSSL's error qu

CVE-2020-0570 HIGH POC
7.3 Sep 14

Uncontrolled search path in the QT Library before 5.14.0, 5.12.7 and 5.9.10 may allow an authenticated user to potential

CVE-2023-51714 CRITICAL
9.8 Dec 24

An issue was discovered in the HTTP2 implementation in Qt before 5.15.17, 6.x before 6.2.11, 6.3.x through 6.5.x before

CVE-2024-36048 CRITICAL
9.8 May 18

QAbstractOAuth in Qt Network Authorization in Qt before 5.15.17, 6.x before 6.2.13, 6.3.x through 6.5.x before 6.5.6, an

CVE-2017-10904 CRITICAL
9.8 Dec 16

Qt for Android prior to 5.9.0 allows remote attackers to execute arbitrary OS commands via unspecified vectors. Rated cr

CVE-2018-19873 CRITICAL
9.8 Dec 26

An issue was discovered in Qt before 5.11.3. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploita

CVE-2016-10040 MEDIUM POC
5.5 Mar 07

Stack-based buffer overflow in QXmlSimpleReader in Qt 4.8.5 allows remote attackers to cause a denial of service (applic

CVE-2026-95509 HIGH
8.8 Sep 29

Out-of-bounds read in Qt for MCUs occurs when an application passes a Latin-1-optimized string containing Latin-1 charac

CVE-2018-19870 HIGH
8.8 Dec 26

An issue was discovered in Qt before 5.11.3. Rated high severity (CVSS 8.8), this vulnerability is remotely exploitable,

CVE-2018-15518 HIGH
8.8 Dec 26

QXmlStream in Qt 5.x before 5.11.3 has a double-free or corruption during parsing of a specially crafted illegal XML doc

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise High Performance Computing 12 Affected
SUSE Linux Enterprise High Performance Computing 15 SP7 Affected
SUSE Linux Enterprise High Performance Computing 15 SP7 Not-Affected

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