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.createortemplate.updatepermission 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 -con 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.createandtemplate.updatepermissions, 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.

