Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious .bin model file
-
DeliveryDistribute via model hub or supply chain
-
ExploitVictim loads model in CTranslate2
-
ExecutionLoader reads unterminated string field
-
PersistOut-of-bounds heap read
-
ImpactCrash or adjacent-memory disclosure
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 the victim application to load an attacker-controlled CTranslate2 binary model file (.bin) through the model loader/deserialization path (src/models/model.cc). The specific trigger is a serialized string field with no null terminator and/or an invalid declared length, which drives an out-of-bounds heap read. Limiting factors: the attack is local (AV:L) - the attacker must get their crafted model file loaded - and requires user/process interaction (UI:P) to open it; there is no network-facing or unauthenticated path. Realistic risk is concentrated in workflows that ingest untrusted or third-party models (e.g., downloaded from public hubs); environments that only load first-party, trusted models are largely unaffected. |
| Impact | This is a genuine memory-safety flaw but a low-to-moderate real-world priority. The vendor CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P) makes the true limiting factor explicit: exploitation is LOCAL and requires user interaction (a victim must load an attacker-supplied .bin model), not a remote network attack. Technical impact is split - VC:L (limited heap disclosure of adjacent memory) plus VA:H (crash/DoS), with no integrity impact (VI:N), consistent with CWE-125 out-of-bounds READ (not a write). There is no EPSS score, no CISA KEV listing, and no public exploit identified at time of analysis, so there is no evidence of active or imminent exploitation. The signals are internally consistent - the modest 6.9 score, local vector, and required user interaction all point to an opportunistic/supply-chain-style risk rather than a mass-exploitable bug. A patch IS confirmed available (v4.8.1, PR #2068, commit d9b991e0), which lowers residual risk for anyone who updates. Note this is the OOB-READ sibling of the OOB-WRITE issue in the same loader/release; the read variant is meaningfully less dangerous because it cannot corrupt memory for RCE. Bottom line: patch on normal cadence; treat as elevated only for environments that ingest untrusted/third-party models. |
| Exploit ScenarioDerived | An attacker publishes or substitutes a malicious CTranslate2 .bin model (e.g., on a model hub or via a compromised supply channel) whose serialized string field lacks a null terminator and declares a bad length. When a victim application (such as one built on faster-whisper) loads that model, the binary loader reads past the heap buffer, crashing the process or leaking adjacent heap contents. No public exploit code is identified at time of analysis, and exploitation requires the victim to load the crafted file locally (AV:L/UI:P). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 29, 2026
Out-of-bounds heap reads in CTranslate2's binary model loader affect all releases before 4.8.1, allowing an attacker who supplies a crafted model file to crash the loading process or disclose adjacent heap memory contents. The flaw is in the model deserialization path (src/models/model.cc), where string fields are read without validating their declared length or null termination; exploitation is local and requires the victim to load an untrusted .bin model through the library's loader. The vendor has released a fix in 4.8.1, and at time of analysis there is confirmed actively exploited status absent (no CISA KEV listing) and no public exploit identified at time of analysis; severity scores cluster around medium (CVSS 4.0 base 6.9; independent assessment CVSS 3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H), reflecting a genuine memory-safety flaw but a low-to-moderate real-world priority concentrated in workflows that ingest third-party models.
RemediationAI
Upgrade to CTranslate2 4.8.1, the vendor-released patch version, applying the upstream fix from PR 2068 (https://github.com/OpenNMT/CTranslate2/pull/2068) and commit d9b991e0700933a0c05373df8b52ed89cdcab96d; downstream packagers and Python environments should pin ctranslate2>=4.8.1 and rebuild any bundled native library rather than relying on a stale wheel. Where immediate upgrading is not possible, the most effective compensating control is to stop loading models from untrusted sources: restrict the loader to first-party model artifacts shipped with the application, or verify SHA-256 checksums and signatures against a trusted manifest before loading - the trade-off is loss of flexibility to consume community or hub-hosted models, which is precisely the untrusted-input vector here. If third-party models must be supported, run the loading/inference process in a sandboxed or least-privileged container with seccomp and strict memory limits so that a crash is contained and heap disclosure is limited to that process's memory, accepting reduced performance and operational overhead; note that sandboxing mitigates information disclosure and availability impact but does not remove the underlying read past the buffer, and a crash of the loading process remains possible under all workarounds. Vendor and third-party advisories with additional detail are available at https://github.com/OpenNMT/CTranslate2/releases/tag/v4.8.1 and https://www.vulncheck.com/advisories/ctranslate2-before-4.8.1-out-of-bounds-read-via-model-deserialization.
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
CTranslate2 is OpenNMT's C++ inference engine for Transformer models, distributed as a native library with Python bindings and consumed by downstream projects such as faster-whisper and various translation pipelines. The vulnerable code lives in the binary model loader at src/models/model.cc, which deserializes the serialized model format on disk. The root cause maps to CWE-125 (Out-of-bounds Read): the loader previously reconstructed a string field with std::string(c_str), relying entirely on the serialized data containing a null terminator and a valid declared length. A model file whose string field omits the null terminator or declares a length that does not match the actual payload causes the constructor to read past the allocated heap buffer. The upstream fix (PR #2068 / commit d9b991e0700933a0c05373df8b52ed89cdcab96d) adds an explicit check that throws std::runtime_error when str_length == 0 and constructs the string as std::string(c_str, str_length - 1) so the length is honored rather than inferred from a terminator; the same patch also validates that a variable's num_bytes equals variable.size() * variable.item_size(), hardening the surrounding payload-size logic. CPE data (cpe:2.3:a:opennmt:ctranslate2:*:*:*:*:*:*:*:*) confirms the entire OpenNMT CTranslate2 product line prior to the fixed release is in scope. Note that the CVSS 4.0 vector carries PR:N and UI:P, i.e., no privileges are required to trigger the flaw, but the attacker must first place a malicious model file where the victim's application will load it.
Know when Ctranslate2 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
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N
Local because a malicious model file must be loaded (AV:L/UI:R); no auth needed (PR:N); OOB read yields limited heap disclosure (C:L) and crash (A:H), no integrity impact (I:N).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
CTranslate2 before 4.8.1 contains an out-of-bounds heap read vulnerability in the binary model loader when deserializing string fields without null terminators. Attackers can craft malicious model files to trigger heap memory reads past buffer boundaries, causing crashes or disclosing adjacent heap memory contents.
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
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.
EUVD-2026-88968
GHSA-wjw8-fx44-f93w
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB