/

CVE-2026-23520

Severity:

CRITICAL RISK

(9.0)

Command Injection in Arcane Updater Service

CVE-2026-23520

Analyzed

Vulnerability type

Category:

Command Injection

CWE:

CWE-78

Impact:

Arbitrary Command Execution within Managed Containers

Severity:

CRITICAL RISK

(9.0)

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

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-update and/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 -c without 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.

Sources

SourceLink
github.comgithub.com/getarcaneapp/arcane/commit/5a9c2f92e11f86f8997da8c672844468f930b7e4
github.comgithub.com/getarcaneapp/arcane/pull/1468
github.comgithub.com/getarcaneapp/arcane/releases/tag/v1.13.0
github.comgithub.com/getarcaneapp/arcane/security/advisories/GHSA-gjqq-6r35-w3r8

Frequently asked

questions

Yes, in environments where the Arcane API is reachable to authenticated users over the network. An attacker with valid credentials and project creation rights can craft malicious lifecycle labels remotely and wait for an update to execute them.

No. The description indicates that any authenticated user who can create projects through the API can set the malicious labels. Administrator involvement is only needed later to trigger the container update, either manually or via scheduled mechanisms.

The safest pattern is to eliminate free-form shell command execution based on user-provided values. Instead, design lifecycle hooks around predefined actions, parameterized commands, or strongly typed configuration. If shell usage is unavoidable, use strict allow-lists and robust validation, and avoid constructing command strings by concatenation.

Treat all metadata and labels as untrusted input, apply defense-in-depth around any execution paths, and avoid handing user-controlled strings to shells or command interpreters. During design and review, identify places where configuration influences execution, enforce least privilege for those components, and supplement with static analysis rules that flag dynamic command construction.

Find out what's already
exploitable in your codebase.