/

CVE-2026-41450

Severity:

HIGH RISK

(7.8)

Command Injection (CWE-78) in UAC Artifact Collector

CVE-2026-41450

Deferred

Vulnerability type

Category:

Command Injection

CWE:

CWE-78

Impact:

Arbitrary Command Execution

Severity:

HIGH RISK

(7.8)

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

UAC contains a command injection vulnerability in its artifact collection logic, where command output is inserted into shell commands without adequate escaping before evaluation. If an attacker can influence filenames or artifact definitions processed by the collector, they may execute arbitrary commands on the analyst's host system.

Affected context

The vulnerability occurs in UAC deployments that use the affected command collection functionality and process attacker-influenced artifact names, definitions, or command output. It becomes risky when collected data or artifact configuration can contain shell metacharacters and the resulting command is evaluated with the host shell's privileges.

Exploit preconditions

  • Attack surface: UAC artifact collection and command construction
  • Required access: Ability to influence filenames, artifact definitions, or other values consumed by the collector
  • Trigger point: Processing of command output lines by the _command_collector function
  • Why exploitation is possible: Unescaped input is substituted into command strings and subsequently evaluated by the shell

Why this happens

The underlying flaw is improper neutralization of externally influenced data before it is incorporated into shell commands. The collector substitutes command output directly into command strings and uses eval, allowing shell syntax embedded in that data to alter command behavior. This maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command, commonly known as OS command injection.

Potential impact

  • An attacker may execute arbitrary commands on the analyst's host
  • Sensitive files or collected artifacts could be accessed or modified
  • The local user account or analysis environment could be compromised
  • Malware, persistence mechanisms, or additional tooling could be introduced
  • Evidence integrity and incident-response conclusions could be undermined

General mitigation guidance

Mitigation generally focuses on removing shell evaluation from data-processing paths and reducing trust in artifact-controlled values.

Common defensive patterns include:

  • Avoiding eval and constructing commands with argument arrays rather than shell-interpreted strings
  • Treating filenames, artifact definitions, and command output as untrusted data
  • Applying strict allowlists and schema validation to artifact definitions
  • Separating data collection from command construction and execution
  • Running analysis tools with least privilege and in isolated environments
  • Limiting access to sensitive host files and execution capabilities

How teams detect issues like this

Organizations can identify similar risks through:

  • Static analysis rules for eval, shell invocation APIs, and string-based command construction
  • Code review checks for unescaped interpolation of filenames or command output
  • Tests using benign metacharacter cases to verify that values remain data rather than executable syntax
  • Dependency and policy checks that prohibit shell evaluation in collection components
  • Runtime monitoring for unexpected child processes or commands launched by the collector

Automated security review tools may help flag these patterns during development.

Sources

SourceLink
github.comgithub.com/tclahr/uac/commit/2cc367d8ead388f05abd3cfb8af537788a124e72
github.comgithub.com/tclahr/uac/pull/443
vulncheck.comvulncheck.com/advisories/uac-command-injection-via-command-collector-sh

Frequently asked

questions

Not necessarily. Exploitation depends on whether an attacker can influence filenames, artifact definitions, or other inputs that UAC processes on the analyst's host.

It requires access to an input or artifact source trusted by the collection workflow. The necessary access may be local, through shared evidence, or through another system that supplies artifact definitions.

Avoid shell evaluation for dynamically constructed commands. Use direct process APIs with fixed executable paths and separately validated argument arrays.

Treat all collection inputs as untrusted, enforce strict artifact schemas, prohibit eval in security-sensitive code, apply least privilege, and test command-building paths for injection behavior.

Find out what's already
exploitable in your codebase.