Skip to main content

TensorLayer EUVDEUVD-2026-98267

| CVE-2026-108958 LOW
Deserialization of Untrusted Data (CWE-502)
2026-10-13 VulDB GHSA-8vxw-f7hc-g4ph
2.1
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious HDF5 model with manipulated model_config
  2. Exploit
    Distribute file to target user or pipeline
  3. Execution
    Victim calls load_hdf5_graph() on the file
  4. Impact
    Untrusted deserialization executes attacker payload

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
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 a victim to load an attacker-supplied HDF5 model file through TensorLayer's load_hdf5_graph() with a manipulated model_config argument; no authentication is required (PR:N) but mandatory user interaction (UI:P/R) - the target must obtain and load the malicious model. Exploitation is therefore limited to environments that deserialize untrusted or third-party TensorLayer model files and to versions up to and including 2.2.4; it is NOT reachable against an unattended network-facing service with no file-loading step.

Impact

Signals here conflict sharply and skew toward LOW operational priority despite the serious CWE-502 class. The only severity source is VulDB, which rated this CVSS 4.0 2.1 (AV:N/AC:L/AT:N/PR:N/UI:P with only Low VC/VI/VA). That low score contradicts the vulnerability class: deserialization of an untrusted model_config via load_hdf5_graph (CWE-502) in TensorLayer historically means eval-based reconstruction of the model graph, which typically yields arbitrary code execution, not merely low-impact disclosure - so the vendor-of-record impact rating appears understated versus the mechanism. There is NO CISA KEV listing and NO EPSS score in the input, so real-world exploitation frequency cannot be quantified. POC is marked 'publicly available,' but the only 'exploit' reference is a GitHub issue thread (#1169), not verified weaponized code, so publicly available exploit code exists in name though its maturity is unconfirmed (CVSS E:P / 'Proof-of-Concept' corroborates immature exploit status). Critically, exploitation is gated by UI:P/UI:R - a victim must load an attacker-supplied model file - so this is not a remotely reachable service flaw. Net: a low-footprint, now-inactive ML library plus a required user-interaction step plus no KEV/EPSS evidence make this a low real-world priority, even though the underlying class is dangerous for anyone who loads untrusted TensorLayer models.

Exploit ScenarioDerived

An attacker publishes or shares a crafted HDF5 model file with a manipulated model_config to a model hub, repository, or directly to a target. When a developer or ML pipeline loads it via TensorLayer's load_hdf5_graph(), the untrusted model_config is deserialized and attacker-controlled logic runs in the victim's process. A public proof-of-concept is referenced via the project's GitHub issue tracker (#1169), though exploit maturity is only proof-of-concept.

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

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

Alert me

AnalysisAIv1 – Oct 13, 2026

Deserialization of untrusted data in TensorLayer up to 2.2.4 allows local code execution when a victim loads a malicious HDF5 model file via load_hdf5_graph(), requiring user interaction (UI:R) but no privileges (PR:N). Despite high potential impact (C:H/I:H/A:H per our assessed CVSS 3.1 vector), the official CVSS 4.0 score is only 2.1 (low) because it assumes a network vector, and operational priority is LOW since the flaw is not reachable in unattended network services. A publicly available exploit exists; the vendor has not responded to the issue report, and no patch is available.

RemediationAI

No vendor-released patch identified at time of analysis; the project has not responded to the issue report. To mitigate, avoid loading untrusted or third-party HDF5 model files with TensorLayer's load_hdf5_graph(), which breaks the ability to use externally supplied models. If such files must be processed, validate the model_config argument against a strict allowlist and run the deserialization in a sandboxed environment with minimal privileges (e.g., container or seccomp), though sandboxing may degrade performance. Alternatively, disable HDF5 loading if not required, which may remove a feature. Given the public exploit code, prioritize applying any future patch from the maintainers as soon as it is released. Track the GitHub issue at https://github.com/tensorlayer/TensorLayer/issues/1169 for updates.

Affected VersionsENISA

TensorLayer 2.2.4
TensorLayer 2.2.1
TensorLayer 2.2.0
TensorLayer 2.2.3
TensorLayer 2.2.2

Affected Packages

euvd tensorlayer no fix

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

TensorLayer is a deep learning library. The vulnerable function load_hdf5_graph in tensorlayer/files/utils.py loads HDF5 files and deserializes the model_config argument without adequate validation, leading to CWE-502 (Deserialization of Untrusted Data). The CPE cpe:2.3:a:n/a:tensorlayer:*:*:*:*:*:*:*:* confirms all versions up to 2.2.4 are affected. Although the official CVSS 4.0 vector indicates a network attack (AV:N), our independent analysis (CVSS 3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) shows that exploitation requires an attacker to supply a malicious HDF5 file that a victim must then load, effectively a local vector with mandatory user interaction. The deserialization flaw permits arbitrary code execution with high confidentiality, integrity, and availability impact if the malicious file is processed.

Know when Tensorlayer 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 7.8 HIGH

CWE-502 model_config deserialization via load_hdf5_graph typically yields code execution (C/I/A:H), but requires the victim to locally load an attacker-supplied file, hence AV:L and UI:R with PR:N.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/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:30 cve.org
LOW 2.1

DescriptionCVE.org

A weakness has been identified in TensorLayer up to 2.2.4. This affects the function load_hdf5_graph of the file tensorlayer/files/utils.py of the component HDF5 Loading. Executing a manipulation of the argument model_config can lead to deserialization. The attack can be executed remotely. 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

EPSS Score
0.3%
Top 84% exploitable
Prevalence
Low
niche deep-learning library, largely inactive, minimal 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.3%
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

Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.

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