/

CVE-2026-41451

Severity:

HIGH RISK

(7.8)

Command Injection (CWE-78) in UAC Artifact Parsing

CVE-2026-41451

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 versions before 3.3.0 contain a command injection flaw in the user substitution logic of parse_artifact.sh. If an attacker can influence /etc/passwd entries, crafted usernames or home-directory paths may cause shell commands to execute on the analyst's host during artifact collection.

Affected context

The vulnerability occurs in UAC environments that use the affected parse_artifact.sh logic to process usernames and home directories from /etc/passwd. Risk is present when those values can contain shell metacharacters and are incorporated into command strings that are later evaluated by the shell.

Exploit preconditions

  • Attack surface: UAC artifact collection scripts running on an analyst's host
  • Required access: Ability to influence or provide an /etc/passwd file, or otherwise control relevant username or home-directory values
  • Trigger point: User substitution and subsequent command execution in parse_artifact.sh
  • Why exploitation is possible: Input values are inserted into command strings without adequate escaping before execution through eval

Why this happens

The underlying bug is the construction of shell commands from externally influenced account data followed by evaluation as shell code. Shell metacharacters, command substitutions, and separators within usernames or home-directory paths can therefore alter the intended 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
  • The local UAC execution context could be compromised
  • Collected artifacts may be modified, disclosed, or deleted
  • Additional local systems or credentials may be exposed
  • Analysis workflows could be disrupted or used to distribute tampered results

General mitigation guidance

Mitigation generally focuses on avoiding shell evaluation of data-derived command strings and reducing trust in account metadata.

Common defensive patterns include:

  • Replacing eval-based execution with direct command invocation and explicit argument handling
  • Treating usernames and home-directory paths as untrusted input
  • Applying strict validation and allowlisting for expected path and account formats
  • Separating data from executable command logic
  • Running collection tools with the minimum host privileges required
  • Restricting access to source artifact files and using controlled analysis environments

How teams detect issues like this

Organizations can identify similar weaknesses through:

  • Static analysis rules for eval, shell command construction, and unquoted variable expansion
  • Code review checks for account, path, or environment data embedded in command strings
  • Tests using metacharacters and other boundary characters in representative input fields
  • Shell security policies that prohibit dynamic evaluation in collection scripts
  • Runtime monitoring for unexpected child processes launched by artifact collection tools

Automated code review and shell-linting tools may help identify unsafe command construction patterns.

Sources

SourceLink
github.comgithub.com/tclahr/uac/commit/2cc367d8ead388f05abd3cfb8af537788a124e72
github.comgithub.com/tclahr/uac/pull/443
vulncheck.comvulncheck.com/advisories/uac-command-injection-via-user-substitution-in-parse-artifact-sh

Frequently asked

questions

Not inherently. Exploitation generally requires a crafted or attacker-controlled /etc/passwd source to be processed by UAC, followed by execution of the affected collection logic on an analyst's host.

The attacker must be able to influence the usernames or home-directory values consumed by the script, or supply an artifact set containing such data. Local execution of UAC is also required to reach the vulnerable code path.

Avoid eval and dynamic shell command construction. Execute programs directly with separated arguments, while validating and safely handling all account and path data.

Treat system metadata as untrusted input, enforce shell scripting standards, review command-building code, apply least privilege, and test collection workflows with hostile input values.

Find out what's already
exploitable in your codebase.