Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious tokenizer with poisoned auto_map
-
DeliveryDistribute untrusted model to victim
-
ExploitVictim loads via AutoTokenizer.from_pretrained
-
ExecutionRemote code imported and executed locally
-
ImpactCode execution as local user
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that a LightX2V user (up to version 0.5.0) load an attacker-controlled tokenizer/model through the cosmos3 runner's AutoTokenizer.from_pretrained call, where the malicious model's configuration supplies a crafted auto_map value pointing to attacker code. The decisive prerequisite is loading UNTRUSTED model/tokenizer content (effectively equivalent to enabling remote/custom code loading for that model). Limiting factors that reduce real-world risk: the attack is restricted to local execution (AV:L), the attacker needs the victim to choose to load the malicious model, it runs only with the local user's existing privileges (PR:L), and there is no remote network attack surface. No fixed version is available since the project has not yet responded. |
| Impact | This is a low-real-risk issue despite the RCE/code-injection tags. The CVSS 4.0 vector supplied by VulDB (AV:L/AC:L/AT:N/PR:L/UI:N, VC:L/VI:L/VA:L) scores only 1.9, and every signal reinforces low severity: exploitation is restricted to local execution (AV:L), requires low privileges (PR:L), and impact to confidentiality/integrity/availability is rated Low rather than High even though the flaw is CWE-94 code injection. The reason is contextual - this is not remote unauthenticated RCE but rather code execution that occurs when a user/operator loads an attacker-supplied tokenizer/model via AutoTokenizer.from_pretrained with a malicious auto_map entry (the well-known HuggingFace trust_remote_code / auto_map class of issue), so the attacker effectively only gains the privileges of the local user who already chose to load the untrusted model. Exploitation signals: publicly available exploit code exists (referenced VulDB/GitHub issue 1559), but there is no CISA KEV listing and no EPSS score was provided in the input, so there is no evidence of active or widespread exploitation. No SSVC decision data was supplied. Note a conflict worth verifying: the impact is labeled 'code injection'/RCE, which normally implies High integrity impact, yet VulDB rated VI:L and scored 1.9 - the low score reflects the local, operator-dependent trust-boundary nature of the bug rather than its code-execution capability, so defenders relying only on the numeric score should understand the 'RCE' tag is technically accurate but gated behind the victim loading untrusted model content. |
| Exploit ScenarioDerived | An attacker publishes or supplies a malicious model/tokenizer repository whose configuration contains a crafted auto_map argument; when a LightX2V user loads it through the cosmos3 runner's AutoTokenizer.from_pretrained call, the referenced remote/custom code is imported and executed on the victim's machine with that user's privileges. Because exploitation is local and depends on the victim choosing to load attacker-controlled model files, it fits a supply-chain / untrusted-model scenario rather than remote network attack. A public proof-of-concept exists (GitHub issue #1559), lowering the bar to reproduce. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
Code injection in ModelTC LightX2V through version 0.5.0 allows a local attacker to execute arbitrary code when a victim loads an attacker-controlled tokenizer/model via the cosmos3 runner's AutoTokenizer.from_pretrained call, by supplying a crafted auto_map value in the model configuration. Exploitation requires the user to load untrusted model content and runs only with the local user's existing privileges; there is no remote network attack surface. Publicly available exploit code exists, the project has not responded or released a patch, and the assessed real-world risk remains low because the attack is local and depends on the victim choosing to load a malicious model.
RemediationAI
No vendor-released patch identified at time of analysis, and the project has not yet responded to the issue. Until a fix is available, avoid loading tokenizers or models from untrusted or unverified sources, especially any model configuration that includes a custom auto_map; verify model provenance and inspect configuration files before use. If untrusted models must be handled, run LightX2V's cosmos3 runner in a least-privilege sandbox or container with restricted filesystem and network access, knowing that sandboxing may limit GPU acceleration or break models that require custom tokenizer code. Disabling trust_remote_code or stripping auto_map entries can prevent the code path, but it will cause legitimate models that rely on custom tokenizer implementations to fail to load. Monitor the vendor repository and issue https://github.com/ModelTC/LightX2V/issues/1559 for an official fix, and consult the VulDB entries at https://vuldb.com/vuln/416768 and https://vuldb.com/cve/CVE-2026-108943 for updates.
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
The underlying issue involves Hugging Face Transformers tokenizer loading: AutoTokenizer.from_pretrained can process a model's auto_map configuration field, which maps tokenizer classes to custom Python code. When a malicious model repository supplies a crafted auto_map, loading it can import and execute attacker-supplied code. The vulnerability is classified as CWE-94 (improper control of code generation / code injection). LightX2V's cosmos3 runner at lightx2v/models/runners/cosmos3/cosmos3_runner.py calls this function, so any injected code runs in the LightX2V process with the local user's privileges. The CPE string cpe:2.3:a:modeltc:lightx2v:*:*:*:*:*:*:*:* indicates all LightX2V releases are in scope, with the known affected range up to 0.5.0. The attack is local (AV:L) because the victim must load the malicious model/tokenizer content; the CVSS vector shows PR:L, meaning low local privileges, and no remote network vector is exposed.
Know when Lightx2V 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:L/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P
Local-only trigger (AV:L) when a low-privileged user loads an untrusted model (PR:L); code runs with that user's rights, giving limited C/I/A impact without scope change.
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
3DescriptionCVE.org
A weakness has been identified in ModelTC LightX2V up to 0.5.0. Affected is the function AutoTokenizer.from_pretrained of the file lightx2v/models/runners/cosmos3/cosmos3_runner.py of the component Tokenizer. This manipulation of the argument auto_map causes code injection. The attack is restricted to local execution. The exploit has been made available to the public and could be used for attacks. The project was informed of the problem early through an issue report but has not responded yet.
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-98182
GHSA-j5rm-qfch-8hjp
NVD
CVE.org
EPSS
VulDB
Exploit-DB