Skip to main content

Godot Engine CVE-2026-110736

| EUVDEUVD-2026-101289 LOW
Improper Validation of Specified Index, Position, or Offset in Input (CWE-1285)
2026-10-14 cve@mitre.org GHSA-qf43-7r7c-mf8f
3.6
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Deliver crafted .translation file to victim
  2. Delivery
    Engine or exported game loads resource
  3. Exploit
    Unvalidated offset indexes past bucket table
  4. Execution
    OOB read in OptimizedTranslation::get_message
  5. Impact
    Heap bytes leaked via tr() or crash

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Hardware permission validation
Exploitation Conditions

Exploitation requires the attacker to get a crafted .translation resource file loaded by the Godot editor or an exported Godot game, after which a string lookup (tr()) must be performed against it to trigger the out-of-bounds read in OptimizedTranslation::get_message. Limiting factors: the attacker needs a path to deliver an untrusted translation file into the project/game (local access, no remote network vector), user interaction is required to load the resource, and reliable disclosure of meaningful heap contents depends on process memory layout (reflected as AC:H) - a crash is easier to achieve than useful memory leakage. The vendor further considers loading untrusted resource files to be outside Godot's security boundary, so default/intended usage does not expose this path.

Impact

All signals point to genuinely low real-world risk despite this being a memory-safety/information-disclosure flaw. The NVD CVSS 3.1 base score is 3.6 (Low) with vector AV:L/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:L: exploitation is local (the malicious .translation file must be loaded by the engine/game), requires user interaction, has high attack complexity (meaningful heap disclosure depends on process memory layout, not just triggering the OOB read), and yields only limited confidentiality and availability impact (partial heap leak via tr() or a crash). No EPSS score was provided in the input, there is no CISA KEV listing, and no public exploit code is identified - only a third-party research writeup and an upstream GitHub issue. Critically, the Supplier (Godot) explicitly disputes this as a security issue, stating the required attacker access (getting a victim to load an untrusted/crafted resource file) is outside the engine's current threat model. This is therefore a low-priority, disputed, low-CVSS issue rather than an urgent threat; it matters mainly to pipelines that load untrusted .translation files (e.g. user-generated mods or localization packs). No conflicting signals between CVSS and description - both consistently indicate local, interaction-dependent access.

Exploit ScenarioDerived

An attacker distributes a crafted .translation resource - for example as a mod, localization pack, or downloadable game asset - to a developer or player. When the Godot editor or an exported game loads that file and performs a string lookup via tr(), the unvalidated offset/index drives an out-of-bounds read that either crashes the process or returns raw heap bytes as the 'translated' string, disclosing process memory. No public exploit code is identified; a third-party research writeup documents the bug.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
No patch listed yet 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 14, 2026

Out-of-bounds read in Godot Engine through 4.7.2 lets a crafted .translation resource drive a hash-table offset far past the allocated bucket table in OptimizedTranslation::get_message, so that loading the resource and performing a tr() string lookup either crashes the Godot editor or an exported game or returns raw heap bytes from elsewhere in the process as the 'translated' string, disclosing process memory. Exploitation is local and requires user interaction - the crafted translation file must be delivered into the project or game and then a lookup performed against it - and reliable heap disclosure depends heavily on process memory layout, so a crash is far easier to trigger than a useful leak; there is no public exploit identified at time of analysis. The report is disputed by the supplier, which argues loading untrusted resource files sits outside Godot's current threat model, and the assessed CVSS of 3.6 (AV:L/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:L) reflects a genuinely low real-world risk rather than a remote or wormable issue.

RemediationAI

No vendor-released patch identified at time of analysis - the supplier disputes the finding on the grounds that loading untrusted resource files is outside Godot's security boundary, so no fixed engine version is documented in the available data; monitor https://github.com/godotengine/godot/issues/123608 for an upstream fix or maintainer decision, and check the writeup at https://axeghost.offprint.app/a/3mvs6zo4blo23-three-memory-safety-bugs-in-godots-untrusted-file-parsers for any follow-up. Because the defect is an information-disclosure/crash primitive rather than code execution, the practical mitigation is to eliminate the untrusted-input path: never load .translation files (or any project resource) supplied by users, mods, or downloads, and restrict exported games to translations bundled at build time or verified against a signature/hash allowlist before loading - the trade-off is that runtime user-supplied localization and translation modding are disabled. Where untrusted resources must be accepted, parse and re-serialize them in a sandbox or throwaway process with a strict timeout so a crash does not take down the main game, and run the editor or game under least privilege with OS-level sandboxing so heap contents recovered through a successful tr() lookup are low-value; note that these controls reduce availability and functionality impact at the cost of added complexity and latency, and none of them fix the underlying missing bounds check. Enterprise and CI environments that open third-party Godot projects should treat project resources as untrusted code-adjacent artifacts and scan or reject externally sourced .translation files until an upstream patch validates indices against the bucket table allocation.

Affected VersionsENISA

Godot Engine 1.0.0 ≤4.7.2

Affected Packages

euvd godot_engine no fix

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

Godot's optimized translation format (core/string/optimized_translation.cpp) compiles a .translation resource into an in-memory structure with a hash table whose entries are offsets into a bucket table of message strings. OptimizedTranslation::get_message() reads an offset from the hash table and uses it directly as an index into the bucket table without validating that the index lies within the allocated buffer; only a single designated sentinel value is rejected. This is CWE-1285 (Improper Validation of Specified Index, Position, or Offset in Input): the stored index/offset is trusted data taken from the parsed file, and there is no bounds check binding it to the actual bucket allocation. A crafted file can therefore encode an index that points arbitrarily far past the buffer, so the read returns unrelated heap contents that are then handed back to the caller as a translated string via the tr() lookup path - an information-disclosure primitive arising from the same missing validation that also produces out-of-bounds crashes. The flaw is reachable only through the local resource-loading path (AV:L) combined with a user action to load the resource and perform a lookup (UI:R), and PR:N/UI:R in the vector indicates no privileges are required but the victim must actively open or execute the malicious content. Because the leaked region is whatever happens to reside at the computed heap offset, the usefulness of the disclosure depends on allocator state and memory layout, which is why the assessed complexity is High and the impact on confidentiality and availability is Low rather than High.

Know when Godot 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 3.6 LOW
AV:L/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:L
vuln.today AI 3.6 LOW

Attacker supplies a file the victim must load (AV:L, UI:R, PR:N); useful heap disclosure depends on memory layout (AC:H); limited memory leak (C:L) and crash potential (A:L), no integrity impact.

3.1 AV:L/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:L
4.0 AV:L/AC:H/AT:N/PR:N/UI:A/VC:L/VI:N/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

Attack Vector
Local
Attack Complexity
High
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
Low
Integrity
None
Availability
Low

DescriptionCVE.org

Godot Engine through 4.7.2 has an out-of-bounds read in the optimized translation loader (core/string/optimized_translation.cpp, OptimizedTranslation::get_message). Offsets read from the hash table of a crafted .translation resource are used as indices into the bucket table without bounds validation; only a single sentinel value is rejected. A crafted file can point an index far past the allocated buffer. Depending on the values, the result is a crash, or a string lookup (tr()) returns raw bytes from elsewhere in the process heap as the translated string, disclosing process memory. The defect is reached when the product or an exported game loads and performs lookups in a crafted translation file. NOTE: the Supplier's position is that the research has identified "no security issues" because the required attacker access is outside of the current Godot Engine threat model.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Medium
popular open-source game engine, large indie dev base, limited enterprise footprint
Data Quality
8 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment CIRCL GitHub VulDB

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 LOW
CISA KEV No
Public POC No
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

18
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +18
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.

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