/

CVE-2026-71567

Severity:

HIGH RISK

(7.7)

OS Command Injection (CWE-78) in FakeFish Shell Scripts

CVE-2026-71567

Awaiting Analysis

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Command Execution and Manifest Manipulation

Severity:

HIGH RISK

(7.7)

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

FakeFish contains shell scripts that insert variable values into command lines or generated manifests without consistently quoting or validating them. If an attacker can influence values such as image URLs or BMC credentials, specially crafted input may alter command interpretation, modify manifests, or enable operating system command execution.

Affected context

The issue occurs in FakeFish scripts that construct shell commands or manifests from variable-controlled data. Risk is higher when image references, BMC credentials, or other configuration values can be supplied by an untrusted or insufficiently trusted source and are later interpreted by a shell or downstream manifest-processing tool.

Exploit preconditions

  • Attack surface: FakeFish shell scripts that interpolate variables into commands or manifests
  • Required access: Ability to influence one or more substituted values, directly or through deployment configuration
  • Trigger point: Execution of the affected script or processing of the generated manifest
  • Why exploitation is possible: Unquoted or insufficiently validated values may be interpreted as shell syntax or may alter the structure and meaning of generated configuration

Why this happens

The underlying bug is failure to preserve data boundaries when shell variables are expanded into commands or serialized configuration. Unquoted shell expansion can allow attacker-controlled metacharacters, whitespace, or substitutions to be interpreted as syntax rather than data. This maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command, with related risk from insufficient validation of values inserted into manifests.

Potential impact

  • An attacker may execute commands with the privileges of the affected script
  • Generated manifests could be altered or rendered invalid
  • BMC credentials or other sensitive values could be exposed or misused
  • Cluster resources or provisioning workflows could be modified
  • Follow-on compromise may occur if the script has elevated permissions

General mitigation guidance

Mitigation generally focuses on maintaining strict separation between data and executable syntax.

Common defensive patterns include:

  • Quote shell expansions consistently and use argument arrays where supported
  • Prefer APIs or structured serializers over shell-built commands and manifests
  • Apply allowlist validation to image references, endpoints, identifiers, and credential fields
  • Treat image URLs and BMC credentials as untrusted input until validated
  • Keep secrets out of command-line arguments and generated files where possible
  • Run provisioning scripts with the minimum permissions and filesystem access required
  • Use fixed command structures rather than concatenating user-controlled fragments

How teams detect issues like this

Organizations commonly identify this class of issue through:

  • Static analysis for unquoted variable expansions in shell command contexts
  • Code review checks for string concatenation used to build commands or manifests
  • Scanning for variables such as image URLs or credentials crossing into shell execution
  • Shell linting and policy rules that require quoting, safe arrays, and controlled templating
  • Tests using metacharacters, whitespace, and malformed configuration values to verify data remains inert

Automated review tools can help flag suspicious expansion patterns, but findings should be validated against actual data flow and script behavior.

Sources

SourceLink
github.comgithub.com/openshift-metal3/fakefish/security/advisories/GHSA-xfhv-fp7q-v2cc

Frequently asked

questions

Exploitability depends on how FakeFish is deployed. It may be reachable through an automated provisioning or CI workflow if an attacker can influence the relevant variables, but it is not necessarily exposed as a standalone network service.

The attacker generally needs a way to control an image URL, BMC credential, or another value consumed by an affected script. This access could come from configuration, an upstream automation system, or another compromised component.

Keep variable values separate from shell syntax by using consistent quoting, structured argument passing, strict validation, and safe manifest serialization rather than command or YAML string concatenation.

Enforce shell scripting standards in code review and CI, use static analysis and shell linting, minimize script privileges, and test all externally influenced values as hostile input.

Find out what's already
exploitable in your codebase.