Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious TensorRT model/engine file
-
DeliveryDeliver to victim model repo or inference service
-
ExploitVictim TensorRT process parses file
-
ExecutionTrigger heap buffer overflow (CWE-122)
-
ImpactExecute arbitrary code in inference process
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
MITRE ATT&CK
1 technique across 1 tactic: Execution 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 attacker to get NVIDIA TensorRT to parse attacker-controlled input (a crafted model, ONNX, or serialized engine/plan file) on the local system, and per the CVSS vector requires user interaction (UI:R) - meaning a user or application must actively load/process the malicious file; it is not remotely triggerable without that step (AV:L). No prior privileges or authentication are needed on TensorRT itself (PR:N). What limits exploitation: the malicious content must reach a local TensorRT process and be deliberately processed, so environments that only run first-party, integrity-verified models are largely insulated, whereas multi-tenant inference services, model marketplaces, and CI pipelines that build engines from externally supplied models are the realistic exposure. The specific vulnerable code path (which parser/deserializer) is not detailed in the provided description and should be confirmed from the NVIDIA advisory. |
| Impact | The signals are moderately aligned rather than alarming: CVSS 7.8 (HIGH) reflects strong technical impact (C:H/I:H/A:H) but is bounded by AV:L (local vector) and UI:R (the victim must load the malicious input), which meaningfully lowers real-world exploitability versus a network-facing flaw. No KEV listing and no EPSS score were provided, and no public proof-of-concept is referenced, so there is no evidence of active or imminent mass exploitation - the practical risk is concentrated where TensorRT loads untrusted models (model marketplaces, multi-tenant inference, CI pipelines building engines from external artifacts). Note a nuance: PR:N in the vector means no privileges are needed, but AV:L plus UI:R means exploitation still hinges on delivering a malicious file to a local process and having it processed, so this behaves more like a malicious-content/opening-a-file bug than a remote drive-by. Missing data to flag explicitly: no EPSS, no KEV, and no fixed-version string are present in the input, so prioritization should treat this as a patch-when-available issue for environments that ingest external models, and higher priority specifically for those handling untrusted model files. |
| Exploit ScenarioDerived | An attacker crafts a malicious TensorRT engine/plan or model file and delivers it to a victim - for example by uploading it to a shared model repository, an inference service that accepts user-supplied models, or a developer's build pipeline. When the local TensorRT process deserializes or parses the file, the heap-based buffer overflow is triggered, corrupting memory and allowing the attacker to execute code in the context of the inference application. No public proof-of-concept is referenced, and the AV:L/UI:R vector means the attacker relies on the victim actually loading the crafted input. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 14, 2026
Local code execution in NVIDIA TensorRT is possible when the library parses an attacker-supplied input (such as a crafted model/engine file), triggering a heap-based buffer overflow (CWE-122) that can corrupt memory and lead to arbitrary code execution in the context of the process using TensorRT. The CVSS 3.1 vector (AV:L/UI:R) indicates the attacker needs local access and must induce a user or application to load malicious content, and there is no public exploit identified at time of analysis. TensorRT is NVIDIA's deep-learning inference SDK, so the affected population is developers, MLOps pipelines, and inference servers that load third-party or untrusted models.
RemediationAI
Patch available per vendor advisory: consult NVIDIA security bulletin https://nvidia.custhelp.com/app/answers/detail/a_id/5855 and upgrade to the fixed TensorRT version specified there (an exact fixed version string is not present in the provided input, so verify it directly from that advisory before rollout). Until patched, the most effective compensating control is to treat model and serialized engine/plan files as untrusted code: only load models from trusted, integrity-verified sources (signed artifacts, checksums) and refuse externally supplied engine files, accepting the trade-off that this blocks model-sharing and third-party model ingestion workflows. Additional controls include running TensorRT inference in an isolated, least-privilege process or container with reduced host access so that memory corruption cannot easily pivot to the host, and gating any pipeline that builds engines from external ONNX/model uploads behind manual review - with the side effect of added latency to model-onboarding pipelines. Rebuild and redeploy any container images that bundle the vulnerable TensorRT runtime after the fixed version is available.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
TensorRT is NVIDIA's high-performance deep-learning inference optimizer and runtime that ingests trained models (e.g., ONNX) and serialized engine/plan files, builds optimized GPU execution graphs, and runs inference on NVIDIA GPUs. The root cause is CWE-122 (heap-based buffer overflow): during parsing or deserialization of input data, the code writes past the bounds of a heap-allocated buffer, typically because a length/size field or element count from the input is trusted without adequate validation against the allocation size. Because TensorRT is delivered as native C++ libraries (with Python bindings) linked into inference applications, memory corruption in the parser executes within the host application's address space rather than a sandbox. The single CPE (cpe:2.3:a:nvidia:tensorrt:*:*:*:*:*:*:*:*) is a wildcard covering all versions, so the exact fixed build must be taken from the NVIDIA advisory rather than the CPE range.
Know when Tensorrt 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:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Local malicious-file parsing requires the victim to load input (AV:L/UI:R) with no privileges (PR:N), and memory-corruption code execution yields full C:H/I:H/A:H.
Primary rating from Vendor (nvidia).
CVSS VectorVendor: nvidia
DescriptionCVE.org
NVIDIA TensorRT contains a vulnerability where an attacker might cause a heap-based buffer overflow. A successful exploit of this vulnerability might lead to code execution.
Articles & Coverage 1
Zero Day Initiative Advisories
Executive ViewAI
NVIDIA TensorRT inference SDK is vulnerable to local code execution when processing specially crafted model files; no public exploit identified at time of analysis. Organizations running ML inference servers and MLOps pipelines that load third-party models face risk of arbitrary code execution within the TensorRT process context, potentially compromising AI systems, data integrity, and underlying infrastructure.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict model loading to internally vetted or digitally signed sources only; implement file integrity monitoring on model directories; run TensorRT processes with minimal OS privileges and in isolated execution environments (containers, VMs, separate user accounts); disable TensorRT on systems where not actively used; monitor process execution and file access logs for anomalies; implement network segmentation to limit lateral movement if a TensorRT process is compromised.
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.
A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Code execution in NVIDIA TensorRT is possible when the SDK processes a maliciously crafted input that overflows a heap-b
Improper array index validation (CWE-129) in NVIDIA TensorRT allows an attacker to trigger out-of-bounds memory access t
Out-of-bounds write in NVIDIA TensorRT prior to version 10.16.1 allows an attacker to corrupt memory and tamper with dat
Code execution in NVIDIA TensorRT (all versions through v10.16.1) arises from unsafe deserialization of untrusted data (
EUVD-2026-44488
GHSA-89jv-4g4v-pr3h
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB