Skip to main content

TinyLLaVA Factory CVE-2026-108957

| EUVDEUVD-2026-98266 LOW
Code Injection (CWE-94)
2026-10-13 VulDB GHSA-57fv-76q7-5x9g
2.1
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

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

  1. Access
    Publish malicious model config/path
  2. Exploit
    Victim loads llm_model_name_or_path
  3. Execution
    Code injected in _load_text_config
  4. Impact
    Arbitrary 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).

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

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

Alert me

AnalysisAIv1 – 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

TinyLLaVA_Factory 1abc6ac5e76a68d0fd087a071b56da968e69ca9b

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

Vendor (VulDB) PRIMARY 2.1 MEDIUM
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
vuln.today AI 8.8 HIGH

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).

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

Primary rating from Vendor (VulDB).

CVSS VectorVendor: VulDB

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
Low
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

3
Severity Changed
Oct 13, 2026 - 03:22 NVD
MEDIUM LOW
CVSS changed
Oct 13, 2026 - 03:22 NVD
5.3 (MEDIUM) 2.1 (LOW)
CVE Published
Oct 13, 2026 - 02:15 cve.org
LOW 2.1

DescriptionCVE.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

EPSS Score
0.2%
Top 86% exploitable
Prevalence
Low
niche academic/research multimodal-LLM training framework, limited production footprint
Exploit
POC
Public exploit code exists
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

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 Yes
EPSS 0.2%
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
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Low

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +10
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

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.

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