/

CVE-2026-56004

Severity:

CRITICAL RISK

(10.0)

Command Injection (CWE-78) in OBS tar_scm Mercurial Handler

CVE-2026-56004

Awaiting Analysis

Vulnerability type

Category:

Command Injection

CWE:

CWE-78

Impact:

Arbitrary Code Execution

Severity:

CRITICAL RISK

(10.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

A command injection vulnerability in the Open Build Service tar_scm source service's Mercurial handler allows shellcode execution when processing attacker-controlled _service files.

If an attacker can supply or modify a malicious _service configuration, they may execute arbitrary commands as the source service account or as a local user who checks out and processes those services.

Affected context

This vulnerability appears when the OBS tar_scm source service processes Mercurial-based projects using _service files that can be influenced by untrusted parties.

In practice, it affects build or checkout workflows where:

  • tar_scm is configured to handle Mercurial repositories, and
  • the _service configuration file is either accepted from external contributors or synchronized from locations an attacker could control.

Under these conditions, unsafe command construction in the Mercurial handler can lead to shellcode injection during service execution or local checkout.

Exploit preconditions

  • Attack surface: OBS source service jobs and local environments that process _service files for Mercurial-based projects.
  • Required access: Ability to submit, upload, or otherwise influence a project's _service file so that it is processed by tar_scm.
  • Trigger point: Execution of the tar_scm source service or local tooling that evaluates the malicious _service configuration for a Mercurial repository.
  • Why exploitation is possible: User-controlled values from the _service file are interpolated into shell commands without adequate validation or escaping, allowing crafted input to inject arbitrary shellcode.

Why this happens

The core issue is unsafe construction and execution of shell commands from configuration data in the Mercurial handler of tar_scm.

Instead of treating fields in the _service file as data, the implementation combines them directly into command strings that are executed by the operating system shell.

This aligns with CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), where untrusted input is allowed to alter the structure and behavior of commands rather than being safely escaped or passed as arguments.

Potential impact

  • Attackers can execute arbitrary commands with the privileges of the OBS source service.
  • Malicious _service files may lead to arbitrary code execution on local developer machines that check out and process those services.
  • Build infrastructure may be compromised, enabling backdoored packages or manipulated build outputs.
  • Sensitive data accessible to the service or local user (credentials, tokens, configuration) could be exfiltrated.
  • Attackers could pivot from compromised build or checkout environments to other internal systems.

General mitigation guidance

Effective mitigation focuses on eliminating direct command injection vectors and tightening trust boundaries around configuration-driven execution.

Common defensive patterns include:

  • Avoid building shell command strings from _service file values; instead, invoke version-control operations via safe APIs or subprocess calls with argument lists that do not pass through a shell.
  • Apply strict validation and normalization to configuration fields before use, rejecting or constraining values that do not conform to expected formats.
  • Treat _service files as untrusted input unless they originate from tightly controlled, authenticated sources, and consider limiting which fields can influence execution.
  • Run source service processes and local tooling with least privilege, isolating them from sensitive resources and applying sandboxing where feasible.
  • Prefer secure-by-default command invocation mechanisms that escape or quote arguments automatically, reducing the risk that special characters alter command structure.

How teams detect issues like this

Detection typically involves both code-centric and workflow-centric approaches:

  • Static analysis rules that flag direct use of shell interpreters (e.g., /bin/sh, system(), popen()) with concatenated strings derived from configuration or user input.
  • Code review checklists that require developers to justify any shell command usage and demonstrate that all inputs are validated and properly escaped.
  • Security policies that restrict configuration-driven command execution, requiring that build and source services use safe library calls instead of ad-hoc shell invocations.
  • Automated scanning of repository and service codebases for patterns such as string interpolation into shell commands, or unbounded parameter passing from _service files into command-line options.
  • Runtime monitoring or logging that highlights unusual or high-risk commands executed during tar_scm operations, which can help identify exploitation attempts.

Sources

SourceLink
github.comgithub.com/openSUSE/obs-service-tar_scm/pull/552/changes/bcf29d318c671c45fe87dd9f995a4a0c78ecedd7

Frequently asked

questions

Yes, in environments where attackers can submit or modify _service files that are processed by the tar_scm source service. Remote contribution mechanisms, such as public project submissions or integrations, can expose this attack surface.

An attacker must be able to influence or provide a project's _service file that uses the Mercurial handler. This can occur through project contribution workflows, misconfigured permissions, or compromised upstream repositories.

The safest approach is to remove shell-based command construction from the Mercurial handler, instead using library or API calls that treat configuration values strictly as data. Where commands must be invoked, ensure all parameters are validated, escaped, and passed as discrete arguments without shell interpretation.

Establish secure coding practices that prohibit building shell commands from untrusted input, enforce validation of configuration fields, and require security review for any code that executes external programs. Integrate static analysis and policy checks into CI pipelines to automatically detect injection-prone patterns before deployment.

Find out what's already
exploitable in your codebase.