/

CVE-2026-26009

Severity:

CRITICAL RISK

(9.9)

OS Command Injection in Catalyst Server Templates

CVE-2026-26009

Awaiting Analysis

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Root-Level Remote Code Execution Across Cluster Nodes

Severity:

CRITICAL RISK

(9.9)

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

Catalyst allows install scripts defined in server templates to run directly on the host operating system as root via bash -c, without sandboxing or containerization.

Any user with template.create or template.update permissions can embed arbitrary shell commands, leading to reliable root-level remote code execution on every node machine in the cluster where those templates are applied.

Affected context

The issue appears in Catalyst deployments where server templates include install scripts that are executed on physical or virtual node machines.

Templates are treated as trusted configuration and executed directly on the host OS as root using bash -c, with no isolation layer (such as containers, jails, or restricted interpreters).

Environments that delegate template management to multiple users or teams, or integrate with external systems for template provisioning, are especially exposed because template authorship translates directly into root command execution on all affected nodes.

Exploit preconditions

  • Attack surface: Catalyst template management interface or API where install scripts are defined or updated.
  • Required access: An account or integration with template.create or template.update permission on the relevant project or environment.
  • Trigger point: Provisioning or updating servers that use a malicious template, which causes the install script to run on each node as root.
  • Why exploitation is possible: The platform executes template-provided shell content via bash -c on the host OS, fully trusting template authors and providing no sandboxing, command filtering, or privilege separation.

Why this happens

The root cause aligns with CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

Catalyst treats template install scripts as trusted instructions and passes them directly to bash -c on the host without isolation, validation, or privilege reduction.

This design effectively blurs the line between configuration and code: any party allowed to define or update templates can inject arbitrary shell commands that the system runs with root privileges.

The lack of a sandbox or command whitelisting means the execution environment exposes the entire host, not just the game server process, to compromise.

Potential impact

  • Full root-level remote code execution on every node that processes a malicious template
  • Installation of persistent malware, backdoors, or rootkits on host machines
  • Theft or destruction of game data, user credentials, and configuration secrets
  • Lateral movement across cluster nodes and other infrastructure reachable from compromised hosts
  • Abuse of compute resources for activities like cryptomining or DDoS participation
  • Complete takeover of the Catalyst-managed game server environment and associated infrastructure

General mitigation guidance

Long-term mitigations focus on separating template configuration from privileged command execution and reducing trust in template authors:

  • Execute template install logic inside sandboxed environments such as containers, VMs, or restricted user accounts instead of directly as root on the host.
  • Introduce least-privilege execution, running installation steps under non-root service accounts, granting specific capabilities only where absolutely necessary.
  • Treat template content as untrusted input: apply validation and policy controls that restrict allowed commands, enforce whitelists, or require explicit approval for high-risk operations.
  • Provide safe, high-level abstractions (e.g., predefined install actions, package operations, and configuration primitives) so template authors rarely need arbitrary shell access.
  • Limit and audit who can hold template.create and template.update permissions, aligning them with administrative trust boundaries rather than general project roles.
  • Encourage operational practices where infrastructure provisioning is immutable and reproducible, reducing the need for ad-hoc install-time scripting on hosts.

How teams detect issues like this

Detection should combine static policy checks on templates with runtime monitoring of node behavior:

  • Implement policy-based template validation that scans install scripts for dangerous patterns (e.g., network utilities, privilege escalation commands, file system-wide modifications) before they are accepted.
  • Use static analysis or linters specialized for shell scripts to flag high-risk operations, unbounded command execution, or calls to external interpreters.
  • Introduce change approval workflows or mandatory code review for template modifications, especially where they affect production clusters.
  • Monitor host systems with endpoint detection and response (EDR) or logging agents that track process creation from Catalyst-controlled scripts, highlighting anomalous commands, connections, or file changes.
  • Periodically review audit logs of template changes and server provisioning events to correlate suspicious template updates with unusual host activity.

Sources

SourceLink
github.comgithub.com/karutoil/catalyst/commit/11980aaf3f46315b02777f325ba02c56b110165d
github.comgithub.com/karutoil/catalyst/security/advisories/GHSA-xv5r-cpcw-8wr3

Frequently asked

questions

Yes, if the Catalyst management interface or API is reachable over the network and an attacker can obtain or abuse credentials with template permissions, they can achieve root-level code execution on cluster nodes from remote locations.

The attacker needs access to an account or integration that has template.create or template.update permissions. No direct shell or node access is required; the platform will execute the malicious commands during server provisioning.

The most robust fix is to eliminate direct, unsandboxed execution of user-defined shell commands on the host. Run install logic in isolated environments under non-root identities, and replace free-form scripting with constrained, well-defined operations wherever possible.

When designing automation or template systems, treat all user-editable content as untrusted, apply least privilege to any execution path, and enforce sandboxing by default. Combine this with strong role-based access control, template policy checks, and a preference for declarative configuration over imperative shell scripting.

Find out what's already
exploitable in your codebase.