/

CVE-2026-33310

Severity:

HIGH RISK

(8.8)

Command Injection in Intake Catalog Parsing

CVE-2026-33310

Analyzed

Vulnerability type

Category:

Command Injection

CWE:

CWE-78, CWE-94

Impact:

Arbitrary Command Execution on Host System

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Intake catalogs could automatically expand shell() expressions embedded in parameter default values during catalog parsing, causing commands to run on the host.

When a user opens or accesses a malicious catalog YAML file containing shell(<command>) defaults, those commands may execute with the user's privileges, leading to local code execution risks.

Affected context

This vulnerability affects environments where Intake is used to load or browse data catalogs defined in YAML.

It becomes relevant when:

  • Catalogs define parameters with default values using the shell() syntax
  • Users load catalogs obtained from untrusted or semi-trusted sources (e.g., shared repos, data exchanges)
  • Catalog parsing occurs on a system where executing shell commands can affect local files, data, or services

The risk is especially pronounced in shared research environments, data science platforms, and notebook servers that routinely consume external catalogs.

Exploit preconditions

  • Attack surface: Intake catalog loading and parsing, typically via Python APIs, notebooks, CLIs, or applications that integrate Intake.
  • Required access: Ability to supply or influence a catalog YAML file consumed by Intake (e.g., commit to a repo, upload to a shared directory, or host a catalog remotely).
  • Trigger point: A victim process (user script, notebook, or application) opens or accesses the malicious catalog, causing parameter default evaluation and shell() expansion.
  • Why exploitation is possible: The parsing logic treats shell() in parameter defaults as an instruction to execute system commands, effectively evaluating catalog content as code rather than treating it as passive configuration.

Why this happens

The core issue is treating configuration content as executable instructions during catalog parsing.

Intake's handling of parameter defaults allowed the shell() syntax to be automatically expanded, effectively injecting system-level commands into what should be a declarative catalog.

This maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), because untrusted configuration values are passed through to the shell without robust neutralization or isolation.

It also relates to CWE-94: Improper Control of Generation of Code ('Code Injection'), as the catalog format effectively allowed embedded logic to run in the host environment.

Potential impact

  • Arbitrary command execution on the host system under the permissions of the Intake-using process
  • Unauthorized file reads, modifications, or deletions on the local machine or mounted storage
  • Theft or exfiltration of data accessed by the affected environment (e.g., datasets, credentials in config files)
  • Installation of backdoors, cryptominers, or other malware on shared compute infrastructure
  • Lateral movement within the network, using the compromised host as a pivot

General mitigation guidance

Effective mitigation focuses on removing executable behavior from catalog parsing and reducing trust in external configuration:

  • Prefer treating catalogs as purely declarative: avoid features that evaluate shell commands or arbitrary code in configuration files.
  • Where dynamic behavior is required, use explicit, opt-in mechanisms (e.g., dedicated APIs) that clearly separate configuration from execution and default to non-executable behavior.
  • Apply strict validation to catalog fields, especially parameter defaults, ensuring they are treated as data, not interpreted as commands.
  • Limit the use of any shell-like expansion to tightly controlled, trusted catalogs; avoid enabling it globally or by default.
  • Run Intake-based workloads with least privilege, restricting filesystem and network access so that any unintended command execution has constrained impact.
  • Introduce trust boundaries: treat catalogs from external or collaborative sources as untrusted inputs, and vet or sanitize them before use in production or sensitive environments.

How teams detect issues like this

Organizations can detect and monitor for similar issues using a combination of code-focused and operational approaches:

  • Static analysis & code review:
  • Flag code paths that interpret configuration fields using shell execution utilities (e.g., subprocess with shell=True, os.system, or equivalent).
  • Look for parsing functions that perform string-based evaluation or templating that can reach the OS shell.
  • Review configuration-processing code to ensure there is a clear separation between configuration parsing and command execution.
  • Configuration linting:
  • Implement linters or schema validators for catalog YAML files that disallow or warn on shell() or similar executable constructs.
  • Enforce policies in CI pipelines so that catalogs containing executable patterns cannot be merged into shared repositories without explicit review.
  • Runtime monitoring:
  • Monitor Intake-using processes for unexpected child process creation or shell command execution when loading catalogs.
  • Use host-level logging (e.g., process audit logs) to correlate catalog parsing events with suspicious command activity.

Automated scanning tools and secure coding checks in CI/CD can help surface risky patterns early, before they reach end users.

Sources

SourceLink
github.comgithub.com/intake/intake/commit/d0c0b6b57c1cb3f73880655ded4a9b0e18e1fd1b
github.comgithub.com/intake/intake/security/advisories/GHSA-37g4-qqqv-7m99

Frequently asked

questions

It can be, depending on how catalogs are supplied. If an application loads catalogs from remote locations (e.g., URLs, shared repositories, or uploaded files) without vetting, an attacker can remotely provide a malicious catalog that leads to command execution when a user or service parses it.

The attacker must be able to introduce or influence an Intake catalog that the victim environment will load—such as by publishing a shared catalog, committing to a common repository, or providing a file that a user imports. No direct shell access is required; the parsing of the catalog itself triggers the execution.

Disable automatic execution semantics in catalog parsing, especially for constructs like shell(). Treat all catalog fields as data only, validate them against a strict schema, and require explicit, opt-in mechanisms when command execution is genuinely needed, guarded by clear trust assumptions.

Design configuration formats and parsers to be non-Turing-complete and non-executable by default. Avoid embedding code or shell commands in configuration, enforce strong validation for config inputs, and use security reviews or automated checks to flag any parsing logic that evaluates configuration content as commands or code.

Find out what's already
exploitable in your codebase.