/

CVE-2026-25044

Severity:

HIGH RISK

(8.8)

OS Command Injection in Budibase Bash Automation Step

CVE-2026-25044

Analyzed

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

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

Budibase's bash automation step previously executed user-provided commands with execSync after processing them through a template interpolation function, without sufficient sanitization or validation.

In configurations where untrusted or partially trusted data could reach these automation commands, this behavior could allow arbitrary OS command execution on the Budibase server or automation runner.

Affected context

This vulnerability affects Budibase deployments that use the bash automation step to run shell commands constructed from dynamic values.

The risk is highest when:

  • Automation workflows incorporate user-controlled or externally sourced data into command strings
  • Command templates rely on interpolation or concatenation rather than fixed, parameterized invocations
  • The automation runner has access to sensitive data, filesystem paths, or network resources

In such environments, malicious input that flows into the bash step can cause unintended shell commands to be executed.

Exploit preconditions

  • Attack surface: Budibase automation workflows, specifically the bash automation step.
  • Required access: Ability to influence or configure bash automation commands, or to supply input that is interpolated into these commands (e.g., through forms, APIs, or connected data sources).
  • Trigger point: Execution of an automation flow that contains a bash step using templated or otherwise dynamic strings.
  • Why exploitation is possible: The system passes processed command strings directly to execSync without robust validation, escaping, or argument separation, enabling crafted input to alter the intended shell command structure.

Why this happens

The core issue is the construction of shell commands as raw strings that are executed via execSync without strict validation or safe parameterization.

The processStringSync template interpolation mechanism allows user-influenced data to be embedded inside command templates, and these expanded strings are then executed by the shell.

This pattern maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), where input is not adequately neutralized before being incorporated into commands, allowing attackers to inject additional shell syntax or substitute arbitrary commands.

Potential impact

  • Execution of arbitrary OS commands in the context of the Budibase server or automation worker
  • Reading, modifying, or deleting files accessible to the automation process
  • Exfiltration of sensitive data such as configuration secrets, environment variables, or database credentials
  • Lateral movement within the hosting environment or internal network through crafted commands
  • Denial of service by terminating critical processes or consuming system resources

General mitigation guidance

Effective mitigation focuses on eliminating direct string-based command construction and reducing trust in any data that may influence OS-level operations.

Recommended defensive patterns include:

  • Replacing raw shell command execution with higher-level, parameterized APIs or libraries that do not invoke a shell when possible
  • Strictly separating command names from their arguments and avoiding shell interpretation (e.g., using exec variants that accept argument arrays)
  • Applying strong input validation and allowlists for any values that influence OS commands, restricting them to known-safe tokens or patterns
  • Designing automation steps so that user-supplied or external data cannot alter command structure, only constrained parameters
  • Running automation workers with least privilege, limiting filesystem, network, and credential access to reduce blast radius if a command is abused
  • Centralizing security review of any feature that introduces OS command execution, and preferring safer, sandboxed alternatives

How teams detect issues like this

Detection typically combines code-level analysis with operational monitoring:

  • Static analysis: Flag use of execSync, exec, or similar APIs when they are passed concatenated or interpolated strings, especially where inputs originate from user-configurable templates or external data
  • Code review signals: Highlight automation steps or helper functions (such as interpolation utilities) that feed into command execution; reviewers should question why shell access is necessary and how inputs are constrained
  • Configuration review: Periodically inspect automation workflows for bash steps using dynamic template expressions, focusing on those referencing request data, form fields, or external sources
  • Runtime monitoring: Use command auditing, process monitoring, and logging to identify unusual commands run by the automation service, such as outbound network tools, file enumeration, or credential harvesting commands
  • Policy enforcement: Introduce development and deployment policies that require explicit justification and security review for new shell-executing features or flows, optionally enforced via automated CI checks and linters

Sources

SourceLink
github.comgithub.com/Budibase/budibase/releases/tag/3.33.2
github.comgithub.com/Budibase/budibase/security/advisories/GHSA-gjw9-34gf-rp6m

Frequently asked

questions

It can be, depending on how automation flows are configured. If remote users or external systems can control data that is interpolated into bash automation commands, exploitation can occur without direct access to the host, via the Budibase application itself.

An attacker needs the ability to influence command templates or the data that flows into them. This could be through access to create or edit automations, or through untrusted inputs (like form submissions or API calls) that are embedded into command strings by existing automation configurations.

The most robust pattern is to avoid executing shell commands constructed from dynamic strings. Where command execution is unavoidable, use parameterized execution APIs that do not invoke a shell, strictly validate and constrain all arguments, and ensure user-controlled data cannot modify command structure.

Prevention involves establishing secure design guidelines for automation and scripting features: disallow or heavily restrict string-based shell execution, require input validation and allowlists for any system-level operations, enforce least-privilege execution contexts, and integrate static analysis and security reviews into the development lifecycle for any code paths that run OS commands.

Find out what's already
exploitable in your codebase.