Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPublish malicious model config/path
-
ExploitVictim loads llm_model_name_or_path
-
ExecutionCode injected in _load_text_config
-
ImpactArbitrary code execution in process
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 | Requires the victim to invoke TinyLlavaConfig/_load_text_config with an attacker-controlled llm_model_name_or_path value - i.e., loading an untrusted or crafted model/config reference in tinyllava/model/configuration_tinyllava.py. Limiting factors: user interaction is required (UI:P) because an operator must point the loader at the hostile input (it does not fire against an untouched default deployment), and exploitation runs with the privileges of the process loading the config. No authentication is required per the vector (PR:N). No patched release exists due to the rolling-release model, so mitigation depends on only loading trusted model paths. |
| Impact | Signals are mostly low-to-moderate and partly self-reported. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:P) describes a network-reachable, low-complexity, unauthenticated flaw, but UI:P means a victim must passively load attacker-controlled input, and the vendor-rated impacts are only Low across VC/VI/VA, yielding a very low base score of 2.1. That low score conflicts with the vulnerability class: CWE-94 code injection in a config loader typically yields arbitrary code execution, which I would normally rate with High confidentiality/integrity/availability impact - this divergence should be verified rather than taken at face value. Exploitation maturity is E:P (proof-of-concept), and POC=YES is reported, so publicly available exploit code exists; however there is NO CISA KEV listing and NO EPSS score provided, so there is no evidence of widespread or active exploitation. The single intelligence source is VulDB (self-submitted, submission #997884), and the project 'has not responded yet,' so none of this is vendor-confirmed. Net: this reads as a real but low-practical-priority issue - the realistic attack requires tricking a user into loading a malicious llm_model_name_or_path, and the affected product is a niche research/ML framework, so it is far from a mass-exploitation threat despite the code-injection class. |
| Exploit ScenarioDerived | An attacker publishes or socially-engineers a victim into using a crafted llm_model_name_or_path value (e.g., a malicious model/config reference); when the victim instantiates TinyLlavaConfig and _load_text_config processes that argument, attacker-controlled code is injected and executed in the Python process. A public proof-of-concept is referenced in GitHub issue #212, but exploitation is not automatic - it depends on the victim loading the hostile path (UI:P). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
Code injection in TinyLLaVA Factory (TinyLLaVA_Factory) allows a remote attacker to execute arbitrary code with the privileges of the process that loads a model configuration, by supplying a crafted llm_model_name_or_path value that is handled by TinyLlavaConfig._load_text_config in tinyllava/model/configuration_tinyllava.py. Exploitation is not fully autonomous: user interaction is required (CVSS 4.0 UI:P / assessed CVSS 3.1 UI:R) because an operator must point the loader at the hostile path or model reference - an untouched default deployment is not affected - while authentication is not required per the vector (PR:N). Publicly available exploit code exists (the CVE reference set includes a public upstream issue/exploit at GitHub issue #212 and is flagged as 'exploit'), but there is no confirmation of active exploitation via CISA KEV, and because the project uses a rolling release with no response to the report, no vendor-patched version can be identified; the independent assessment (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8) rates confidentiality, integrity and availability impact as High, well above the 2.1 score published by the reporting source.
RemediationAI
No vendor-released patch is identified at time of analysis: the project follows a rolling release with no versioned releases, the issue was reported upstream (https://github.com/TinyLLaVA/TinyLLaVA_Factory/issues/212) but the maintainers had not responded, so there is no fixed commit or tagged version to upgrade to. Until a fix lands, mitigation depends on never letting untrusted data reach the loader. Restrict llm_model_name_or_path to a hard-coded allowlist of internal, hash-pinned local model directories (reject URLs, bare Hugging Face repo IDs, and relative paths supplied by users) - the trade-off is reduced flexibility in multi-model or research workflows and an extra internal review step for new models. Disable remote/custom code execution in the underlying loading path (e.g., pass trust_remote_code=False to the Transformers configuration/model loaders used by TinyLLaVA, or otherwise block the code-fetching branch), accepting that models which genuinely require custom modeling code - several LLaVA-style checkpoints do - will fail to load unless they are vendored and reviewed locally. Run the config-loading and inference process as an unprivileged, network-egress-restricted user or in a container/VM with a read-only filesystem so a successful injection cannot reach secrets, the host, or a package/index foothold; this costs some performance and complicates pipelines that mount training data. Block endpoints that fetch model metadata directly from the internet from the inference host, and add validation/sanitization of any path before it reaches TinyLlavaConfig, since the vulnerable behavior is executed with the privileges of the process that loads the configuration. Monitor the upstream repository and the GitHub issue for an emergency fix and re-check the referenced VulDB entries (https://vuldb.com/vuln/416776, https://vuldb.com/cve/CVE-2026-108957) for an updated patch reference, because publicly available exploit code exists and no patched release currently exists.
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
The flaw is a CWE-94 (Improper Control of Generation of Code / code injection) in the configuration-loading path of TinyLLaVA_Factory, an open-source multimodal (LLaVA-style) training and inference framework that wraps Hugging Face Transformers components. The vulnerable element is the _load_text_config method of the TinyLlavaConfig class in tinyllava/model/configuration_tinyllava.py; the llm_model_name_or_path argument is consumed during configuration construction, and when that value is attacker-influenced the loader can be steered into importing or executing code from an untrusted location rather than merely reading static configuration metadata - the classic pattern in which a model identifier or local path is passed into a dynamic loader (e.g., Transformers' AutoConfig/AutoModel resolution and the trust_remote_code mechanism, or equivalent dynamic import/eval logic) and the framework executes code shipped alongside the model. The CPE cpe:2.3:a:tinyllava:tinyllava_factory:*:*:*:*:*:*:*:* uses a wildcard version, which is consistent with the project's rolling-release delivery model: there are no discrete affected or fixed release identifiers, only the upstream source state up to commit 1abc6ac5e76a68d0fd087a071b56da968e69ca9b. Root cause is the absence of validation, allowlisting, or sandboxing of the model/config reference before it is resolved, so any deployment (or any downstream application embedding TinyLLaVA) that accepts model paths from user input, datasets, or shared repositories inherits the risk.
Know when Tinyllava Factory 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:N/AC:L/AT:N/PR:N/UI:P/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P
CWE-94 injection via a config argument yields arbitrary code execution (C/I/A:H), but a victim must load the attacker-controlled llm_model_name_or_path, so UI:R; no privileges needed (PR:N).
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
3DescriptionCVE.org
A security flaw has been discovered in TinyLLaVA TinyLLaVA_Factory up to 1abc6ac5e76a68d0fd087a071b56da968e69ca9b. The impacted element is the function _load_text_config of the file tinyllava/model/configuration_tinyllava.py of the component TinyLlavaConfig. Performing a manipulation of the argument llm_model_name_or_path results in code injection. Remote exploitation of the attack is possible. The exploit has been released to the public and may be used for attacks. This product follows a rolling release approach for continuous delivery, so version details for affected or updated releases are not provided. 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-98266
GHSA-57fv-76q7-5x9g
NVD
CVE.org
EPSS
VulDB
Exploit-DB