Skip to main content

Llama-Chinese EUVDEUVD-2026-104068

| CVE-2026-112080 LOW
Code Injection (CWE-94)
2026-10-19 VulDB GHSA-2p28-j54x-gv38
2.1
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

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

  1. Access
    Host malicious model/adapter config
  2. Exploit
    Induce operator to load crafted base_model_name_or_path
  3. Execution
    Dynamic module resolution injects code
  4. Impact
    Execute attacker code in app 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

Exploitation requires that the examples/chat_gradio_no_merge.py Gradio demo is actually deployed AND that an attacker can influence the base_model_name_or_path argument consumed by get_class_from_dynamic_module (the Adapter Config component) - typically by getting an operator to load an attacker-controlled model/adapter path or remote module. Limiting factors: this is example/demo code rather than a core library API, so most installations never expose it; the CVSS flag UI:P indicates passive user interaction is needed (a victim must load/process the crafted value); there is no fixed release (rolling release, versions undisclosed) and no vendor response. These constraints sharply narrow realistic exploitation despite the AV:N/PR:N labeling.

Impact

Signals conflict sharply and should be read with caution. VulDB (the sole source) assigns a CVSS 4.0 base score of 2.1 (Low) with partial impacts (VC:L/VI:L/VA:L) and passive user interaction (UI:P), yet the CWE (CWE-94, code injection) and tags (RCE, Code Injection) describe a bug class that normally yields full code execution - so the published score likely understates technical impact while correctly capturing that the attack surface is narrow. The vector advertises a network, low-complexity, unauthenticated path (AV:N/AC:L/PR:N), but the vulnerable input, base_model_name_or_path, is an operator-/config-controlled model path in an example Gradio demo script (examples/chat_gradio_no_merge.py), not a routine remote request parameter, so real exploitation depends on an operator or victim being induced to load an attacker-supplied path (consistent with UI:P). A public exploit (poc.zip) exists, which raises opportunistic risk, but there is NO CISA KEV listing and NO EPSS value provided, so there is no evidence of active, widespread exploitation - POC availability is not the same as in-the-wild use. No SSVC decision data was supplied. Net: this is a real but low-priority issue for most environments - meaningful only where this specific demo script is actually deployed and its model-path input is attacker-influenceable; the 'remote/unauthenticated' framing should be verified against how the argument is actually exposed.

Exploit ScenarioDerived

An operator runs the chat_gradio_no_merge.py demo and is induced to load an attacker-supplied base_model_name_or_path (e.g., a crafted adapter config / remote module); when get_class_from_dynamic_module resolves it, attacker-controlled code executes in the application's process. A public proof-of-concept (poc.zip) exists; the CVSS passive user-interaction flag (UI:P) indicates the victim must load or process the malicious value rather than it triggering fully unattended.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
No patch listed yet

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

Alert me

AnalysisAIv1 – Oct 19, 2026

Code injection in Llama-Chinese's Gradio chat demo (examples/chat_gradio_no_merge.py) lets unauthenticated remote attackers run arbitrary code when an operator loads an attacker-influenced value for base_model_name_or_path. Exposed deployments of the example script are the realistic attack surface; the project uses a rolling release with no disclosed version and has not responded to the issue report. Publicly available exploit code exists, but there is no CISA KEV confirmation of active exploitation.

RemediationAI

No vendor-released patch identified at time of analysis; the project has not responded to issue 371 and uses rolling releases without version disclosure. Remove or disable examples/chat_gradio_no_merge.py in any production or internet-facing deployment, and do not expose the Gradio demo publicly - bind it to localhost or place it behind an authenticated VPN/reverse proxy, accepting that this limits legitimate access. Patch the example locally to reject user- or config-supplied base_model_name_or_path values unless they match a strict allowlist of trusted local model paths or trusted repositories, and avoid loading untrusted adapters; this may break legitimate custom model loading. Run the demo in a sandbox or container with no cloud credentials, no sensitive mounts, and restricted egress so any code execution is contained; this reduces functionality that depends on network or host resources. Monitor https://github.com/LlamaChinese/Llama-Chinese/issues/371 and https://vuldb.com/vuln/421759 for a vendor fix.

Affected VersionsENISA

Llama-Chinese 6fa0fffb0dd82fe3cfaa1449ee54a5806d26ae9b

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

Llama-Chinese is a Chinese-language LLM project; the vulnerable component is the Adapter Config handling in examples/chat_gradio_no_merge.py. The function get_class_from_dynamic_module, a Hugging Face Transformers-style dynamic module loader, imports code based on the model or adapter identifier supplied through base_model_name_or_path. Because that argument can point to an external repository or path, manipulating it can cause Python code from an attacker-controlled source to be imported and executed, matching CWE-94 code injection. The CPE cpe:2.3:a:llamachinese:llama-chinese:*:*:*:*:*:*:*:* reflects that all rolling-release revisions are treated as potentially affected, with the last referenced commit 6fa0fffb0dd82fe3cfaa1449ee54a5806d26ae9b; the risk is concentrated in the demo script rather than the core library, and exploitation requires the demo to be deployed plus a victim/operator to load or process the crafted value.

Know when Llama Chinese 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

Code injection via dynamic module loading yields full code execution (C/I/A:H), but the malicious model path must be loaded by a victim operator, so UI:R; no attacker 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:A/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 19, 2026 - 05:22 NVD
MEDIUM LOW
CVSS changed
Oct 19, 2026 - 05:22 NVD
5.3 (MEDIUM) 2.1 (LOW)
CVE Published
Oct 19, 2026 - 05:00 cve.org
LOW 2.1

DescriptionCVE.org

A vulnerability was found in LlamaChinese Llama-Chinese up to 6fa0fffb0dd82fe3cfaa1449ee54a5806d26ae9b. The impacted element is the function get_class_from_dynamic_module of the file examples/chat_gradio_no_merge.py of the component Adapter Config. The manipulation of the argument base_model_name_or_path results in code injection. The attack may be performed from remote. The exploit has been made public and could be used. This product utilizes a rolling release system for continuous delivery, and as such, version information for affected or updated releases is not disclosed. The project was informed of the problem early through an issue report but has not responded yet.

Threat Intelligence Overview

Prevalence
Low
example/demo script in a community LLM project, minimal production footprint
Exploit
POC
Public exploit code exists
Data Quality
4 sources
Confidence: Medium

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 N/A
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