/

CVE-2026-85426

Severity:

CRITICAL RISK

(9.8)

OS Command Injection (CWE-78) in MOOS-IvP uMemWatch

CVE-2026-85426

Awaiting Analysis

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Arbitrary Command Execution

Severity:

CRITICAL RISK

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

MOOS-IvP uMemWatch constructs shell commands using attacker-controlled MOOS client names without adequately sanitizing them. A remote or local attacker who can provide a crafted client name may execute arbitrary operating-system commands with the privileges of the uMemWatch process.

Affected context

The vulnerability occurs in MOOS-IvP uMemWatch deployments through version 24.8.1 when client names are incorporated into system commands. It becomes risky when an untrusted party can register or influence a MOOS client name and the monitoring process handles that name through an unquoted shell redirection target.

Exploit preconditions

  • Attack surface: MOOS client-name handling and the uMemWatch monitoring workflow
  • Required access: Ability to supply or influence a MOOS client name accepted by the MOOS environment
  • Trigger point: Processing of the client name when uMemWatch builds and invokes a system command
  • Why exploitation is possible: The name is inserted into a shell command without sufficient sanitization or safe argument handling, allowing shell metacharacters to alter command interpretation

Why this happens

The underlying bug is command construction from untrusted data followed by execution through a shell-oriented system call. Because client names are treated as command or redirection components rather than opaque data, shell metacharacters can change the intended command structure. 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 could execute arbitrary commands as the uMemWatch process user.
  • The attacker could read, modify, or delete data available to that account.
  • The application or host environment could be compromised.
  • The attacker could disrupt monitoring or alter operational data.
  • Further compromise could occur if the process has excessive privileges or access to other systems.

General mitigation guidance

Mitigation generally focuses on ensuring that externally supplied client names remain data throughout processing.

Common defensive patterns include:

  • Avoiding shell invocation for operations that can use direct process or file APIs.
  • Passing arguments through structured APIs rather than concatenating command strings.
  • Applying allowlist-based validation for client-name syntax and rejecting unexpected characters.
  • Treating redirection targets as validated data and using safe file-handling primitives.
  • Running uMemWatch with the least privileges, limited filesystem access, and restricted network permissions.
  • Reducing trust in client-provided identity fields through authenticated registration and policy enforcement.

How teams detect issues like this

Organizations can look for command-injection risks through:

  • Static analysis rules identifying string concatenation or interpolation passed to system, shell, or process-execution APIs.
  • Code review checks for unquoted variables, dynamic redirection targets, and externally controlled identifiers used in commands.
  • Tests that verify client names are handled as data and that invalid name characters are rejected.
  • Runtime monitoring for unexpected child processes, shell launches, or command execution by the uMemWatch account.
  • Policy enforcement that restricts shell execution and limits process privileges in production deployments.
  • Automated security review tools that flag unsafe command construction patterns.

Sources

SourceLink
github.comgithub.com/moos-ivp/moos-ivp
github.comgithub.com/moos-ivp/moos-ivp/blob/1de9ae146cd63c209e8c3fd81611a4ed2472971b/ivp/src/uMemWatch/MemWatch.cpp#L182
github.comgithub.com/moos-ivp/moos-ivp/commit/0b2bd991b0ca7139b1edcf271473d33e7eccfc20
github.comgithub.com/moos-ivp/moos-ivp/pull/121
vulncheck.comvulncheck.com/advisories/moos-ivp-through-24.8.1-umemwatch-command-injection-via-moos-client-names

Frequently asked

questions

Exploitability depends on deployment architecture and MOOS access controls. It may be remotely exploitable when an attacker can submit or influence client names through an exposed MOOS interface.

The attacker must be able to provide a client name that uMemWatch processes. The required access may be unauthenticated or authenticated depending on the surrounding MOOS configuration.

The safest pattern is to avoid shell command construction, use direct APIs with separate arguments, and validate client names against a strict allowlist before processing them.

Treat all client-controlled identifiers as untrusted data, enforce authenticated client registration, scan for dynamic shell invocation during code review, and run monitoring components with minimal privileges.

Find out what's already
exploitable in your codebase.