Skip to main content

uproot EUVDEUVD-2026-45374

| CVE-2026-9147 HIGH
Code Injection (CWE-94)
2026-07-18 VulnCheck GHSA-98vv-9pqj-g87v
8.5
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft ROOT file with malicious streamer metadata
  2. Delivery
    Deliver file to victim data path
  3. Exploit
    Victim opens file with uproot
  4. Execution
    Generated reader evaluates injected expression
  5. Impact
    Arbitrary Python code executes in victim 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 the victim to open or process an attacker-crafted ROOT file with a vulnerable uproot version, and requires that uproot reach the affected class-code generation path - i.e., the file must contain custom class TStreamerInfo records whose file-controlled metadata (streamer element name, count name, or field name) is interpolated into the generated Python reader source. Per the CVSS 4.0 vector this is a LOCAL vector (AV:L) requiring passive user interaction (UI:P) but NO authentication (PR:N) and low complexity (AC:L). Limiting factors: the attacker cannot trigger this over the network without getting a malicious file into the victim's processing path, exploitation is scoped to processes that actually deserialize the malicious streamer records, and environments that only ever read self-generated or trusted ROOT files are not realistically reachable.

Impact

This is a genuine, high-severity remote-ish code execution but with a meaningful gating factor: the provided CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, VC:H/VI:H/VA:H, base 8.5) shows a LOCAL attack vector requiring passive user interaction - the victim must open or process the malicious ROOT file. There is no authentication requirement (PR:N), attack complexity is low, and impact is full compromise of confidentiality, integrity, and availability with no scope change (SC/SI/SA:N). No EPSS score, KEV listing, or POC was provided, so exploitation probability cannot be quantified; treat 'no public exploit identified at time of analysis' as the status, distinct from active exploitation. The realistic risk is high for any automated pipeline, grid job, or analysis workflow that ingests untrusted ROOT files, and lower for closed environments handling only self-produced files. Note the AV:L classification means this is not wormable network RCE despite the 'attacker-controlled file' framing - verify delivery path against your own workflow.

Exploit ScenarioDerived

An attacker crafts a ROOT file whose TStreamerInfo streamer-element name contains Python expression-breaking content and delivers it to a victim - for example by uploading it to a shared analysis dataset, a physics data portal, or an automated processing queue. When a researcher or batch job opens the file with a vulnerable uproot version, uproot generates and invokes the reader method, evaluating the injected expression and running the attacker's Python in the victim's process. No public POC was provided, but the low attack complexity and file-driven trigger make exploitation straightforward for anyone who can place a file in the victim's read path.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.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 – Jul 18, 2026

Arbitrary Python code execution in scikit-hep uproot (uproot5) arises because the library dynamically generates and compiles reader classes from a ROOT file's TStreamerInfo records, interpolating file-controlled streamer metadata (such as streamer element names) into generated Python source without repr()/!r safe quoting. A crafted ROOT file can inject expression-breaking content that is evaluated in the process opening the file, giving code execution to whoever processes attacker-supplied ROOT data. Reported by VulnCheck; no public exploit identified at time of analysis, and it is not listed in CISA KEV.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed - apply the vendor's patched release once identified, tracking GHSA-6946-mq52-g438 (https://github.com/scikit-hep/uproot5/security/advisories/GHSA-6946-mq52-g438) and the fix commit c045c2824295d907d2e705f31110c742928e50e7 which introduces a _sanitize_string() helper, switches generated error messages to the !r (repr) format specifier, and replaces eval() with ast.literal_eval() in identify.py. Until a tagged patched version is confirmed and deployed, do not open or process ROOT files from untrusted or externally-supplied sources with vulnerable uproot code paths; where files must be ingested, run uproot inside an isolated sandbox or unprivileged container with no network egress and minimal filesystem access so that any injected code cannot pivot (trade-off: added pipeline complexity and latency). Validate provenance of ROOT files (restrict to trusted producers) as a compensating control, accepting that this does not stop a compromised upstream producer. Cite the exact fixed version from the vendor advisory when patching; do not assume a version number not published by the vendor.

Affected VersionsENISA

uproot 0 ≤5.7.4

Affected Packages

euvd uproot 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

uproot is a pure-Python reader for the CERN ROOT columnar file format widely used in high-energy physics. To deserialize custom C++ classes stored in a ROOT file, uproot reads the embedded TStreamerInfo schema and synthesizes Python reader methods on the fly, then compiles them at runtime. The root cause is CWE-94 (Improper Control of Generation of Code / code injection): several f-strings in src/uproot/streamers.py (the class_code generator) and an eval() in identify.py embedded attacker-influenced metadata - streamer element names, count names, and field names - directly into generated source. Because these values originate entirely from the file rather than trusted code, and were not passed through repr() or escaped, a value containing quote characters or Python expressions breaks out of the intended string literal and executes.

Know when Uproot 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 (VulnCheck) PRIMARY 8.5 HIGH
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.8 HIGH

Attacker-controlled file must be opened by the victim, so AV:L and UI:R; no auth needed (PR:N), low complexity, and code execution yields full C:H/I:H/A:H with no scope change.

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
SUSE HIGH

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

DescriptionCVE.org

uproot dynamically generates Python class source code from ROOT TStreamerInfo records in a file and compiles it at runtime. Some file-controlled streamer metadata fields (for example, streamer element names) are interpolated into the generated Python source without safe quoting via repr() or the !r format specifier. An attacker who can supply a crafted ROOT file can place Python expression-breaking content into a streamer metadata field. When uproot generates and invokes the corresponding reader method, the injected Python expression is evaluated in the context of the process opening the file, resulting in arbitrary Python code execution in applications that open or process attacker-controlled ROOT files with affected uproot code paths.

Executive ViewAI

Why It Matters

scikit-hep uproot5 contains a critical vulnerability enabling arbitrary Python code execution when processing specially crafted ROOT data files, with no public exploit identified at time of analysis. Organizations using uproot5 for scientific data analysis face potential system compromise and data exfiltration if they process ROOT files from untrusted sources or external collaborators. The vulnerability stems from unsafe dynamic code generation that fails to properly sanitize file-controlled metadata.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Restrict uproot5 processing to ROOT files from trusted, verified internal sources only. Implement file integrity verification and digital signatures for all ROOT files. Run uproot5 in isolated execution environments with minimal system privileges and no access to sensitive data stores. Deploy monitoring to detect suspicious process execution or unauthorized access attempts when ROOT files are processed. Evaluate and test alternative ROOT data parsing libraries as potential replacements pending vendor patch release.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Low
niche high-energy-physics ROOT-file library, limited non-research deployment
Social Media
3
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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
PoC: 0
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.

Vendor StatusVendor

SUSE

Severity: Important

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