Summary
Arcane's updater service previously allowed untrusted lifecycle label values to be executed directly via /bin/sh -c, leading to command injection.
Any authenticated user who could create a project through the API could set malicious lifecycle labels that would later execute arbitrary commands during container updates triggered by an administrator or scheduled task.
Affected context
This vulnerability affects Arcane deployments that:
- Use the Arcane updater service prior to version 1.13.0
- Allow authenticated (non-admin) users to create or manage projects via the Arcane API
- Rely on lifecycle labels
com.getarcaneapp.arcane.lifecycle.pre-updateand/or
com.getarcaneapp.arcane.lifecycle.post-update to run commands around container updates
The risk materializes when lifecycle label values are treated as shell command strings and executed
inside containers during update operations, without adequate validation or restriction.
Exploit preconditions
- Attack surface: Arcane API for project creation and management; updater service processing lifecycle labels.
- Required access: Authenticated user account capable of creating or modifying projects (administrative privileges are not required).
- Trigger point: An administrator initiates a container update manually, or a scheduled update process runs and the updater service reads and executes lifecycle labels.
- Why exploitation is possible: The updater service passes lifecycle label values directly to
/bin/sh -cwithout sanitization, escaping, or command restrictions, allowing arbitrary shell commands to run in the container context.
Why this happens
The core issue is the direct use of user-controlled data as part of a shell command string without validation or constraint. The lifecycle labels com.getarcaneapp.arcane.lifecycle.pre-update and com.getarcaneapp.arcane.lifecycle.post-update allow users to define commands that are later executed by the updater.
By passing these label values straight into /bin/sh -c, the updater treats label content as executable shell syntax. This maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), where untrusted input is incorporated into a command line and interpreted by the OS, enabling attackers to inject arbitrary commands or modify the intended behavior.
Potential impact
- Execution of arbitrary commands inside the affected container during update operations.
- Modification or destruction of application data within the container's scope.
- Installation of backdoors, cryptominers, or other malicious tooling in managed containers.
- Lateral movement opportunities if the container has access to sensitive services, credentials, or the host.
- Disruption of services by crashing or corrupting containers during updates.
General mitigation guidance
Effective mitigation focuses on removing direct shell interpretation of user-controlled values and minimizing trust in configuration labels:
- Avoid passing label values directly to
/bin/sh -c; prefer invoking predefined, parameterized commands or using structured configuration rather than raw shell strings. - If dynamic behavior is necessary, use allow-lists of supported actions or subcommands instead of free-form shell commands.
- Apply strict validation and normalization to any configuration that influences command execution, rejecting values that include shell metacharacters or unsupported constructs.
- Run updater-related workloads with least-privilege container and runtime permissions so that a compromised container has limited reach.
- Separate low-privilege project creation capabilities from high-impact execution paths whenever possible, reducing the trust placed in user-provided metadata.
How teams detect issues like this
Organizations can detect and monitor similar issues using layered approaches:
- Static analysis and code review:
- Flag uses of shell execution APIs (e.g.,
/bin/sh -c,system,exec,popen) where arguments include data from labels, annotations, or other user-supplied configuration. - Review logic around lifecycle hooks and update automation paths to ensure only trusted, constrained input influences command execution.
- Configuration and policy checks:
- Enforce policies that prohibit free-form shell commands in lifecycle labels or metadata fields.
- Periodically scan existing project configurations to identify labels that look like complex shell pipelines or include suspicious metacharacters.
- Runtime monitoring:
- Log commands executed by the updater service and alert on anomalous patterns or unexpected tools being invoked.
- Use container security tooling to detect unusual process activity inside containers during update windows.

