/

CVE-2026-90809

Severity:

HIGH RISK

(7.3)

Argument Injection (CWE-88) in nanobot Shell ExecTool

CVE-2026-90809

Deferred

Vulnerability type

Category:

Argument Injection

CWE:

CWE-74, CWE-88

Impact:

Command Execution and Unauthorized Process Control

Severity:

HIGH RISK

(7.3)

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 high-severity argument injection vulnerability in HKUDS nanobot affects the ExecTool shell execution component. When attacker-controlled input reaches the command-spawning path without adequate argument separation and validation, a remote attacker may alter how a command is interpreted or executed.

Affected context

The vulnerability occurs in nanobot versions up to 0.2.1, within the ExecTool implementation in nanobot/agent/tools/shell.py. It is relevant when remotely supplied or otherwise untrusted data can reach _guard_command or _spawn and influence the arguments passed to a shell or subprocess without sufficiently strict validation.

Exploit preconditions

  • Attack surface: A remotely reachable nanobot function or workflow that invokes ExecTool
  • Required access: Ability to submit input that is processed by the affected command-execution feature
  • Trigger point: Command validation or subprocess creation through ExecTool._guard_command and ExecTool._spawn
  • Why exploitation is possible: Insufficient neutralization and separation of attacker-controlled command arguments may allow input to modify the intended command invocation

Why this happens

The underlying bug is improper neutralization of special elements in input that is later interpreted by a downstream command or process interface. This maps to CWE-88: Improper Neutralization of Argument Delimiters in a Command ('Argument Injection') and is also related to CWE-74, where untrusted data changes the meaning or structure of instructions processed by another component. The insecure pattern typically involves constructing command arguments from untrusted text without using a structured argument interface, strict allowlisting, or context-appropriate escaping.

Potential impact

  • An attacker may alter the arguments supplied to an intended command
  • Unauthorized local commands or processes could be initiated
  • Sensitive files, environment data, or service credentials could be exposed
  • The nanobot runtime could be disrupted or used for lateral movement
  • Actions performed by the service account could be abused

General mitigation guidance

Mitigation generally focuses on preventing untrusted input from controlling command structure.

Common defensive patterns include:

  • Prefer structured subprocess APIs that receive arguments as separate values rather than assembling shell command strings
  • Avoid shell interpretation unless it is strictly required by the feature
  • Apply narrowly scoped allowlists for permitted commands, options, and argument formats
  • Treat remote tool input as untrusted and validate it before command construction
  • Run command-executing components with minimal filesystem, network, and operating-system privileges
  • Isolate execution in constrained environments with restricted credentials and resources
  • Keep command policy enforcement separate from attacker-controlled request data

How teams detect issues like this

Organizations can look for argument-injection risks through:

  • Static analysis rules identifying string concatenation or interpolation in shell and subprocess calls
  • Code review checks for shell execution APIs, dynamic command construction, and incomplete argument validation
  • Tests that verify special characters, delimiters, option-like values, and unexpected argument counts remain data rather than command structure
  • Runtime monitoring for unusual child processes, command-line arguments, or outbound connections from the nanobot service
  • Policy enforcement that restricts which executables and execution contexts application components may use

Automated security review tools may help identify suspicious command construction patterns, but findings should be validated against the actual execution model.

Sources

SourceLink
github.comgithub.com/HKUDS/nanobot/
github.comgithub.com/HKUDS/nanobot/commit/af582246f141311d574551b7571a517bcc3df750
github.comgithub.com/HKUDS/nanobot/issues/5306
github.comgithub.com/HKUDS/nanobot/pull/5345
vuldb.comvuldb.com/cve/CVE-2026-90809
vuldb.comvuldb.com/submit/922850
vuldb.comvuldb.com/vuln/403311
vuldb.comvuldb.com/vuln/403311/cti

Frequently asked

questions

The description indicates that remote exploitation is possible when a reachable nanobot feature allows attacker-controlled data to flow into the affected ExecTool command path.

An attacker generally needs access to a remote interface, workflow, or tool invocation that accepts input subsequently used by ExecTool. The exact requirement depends on authentication, authorization, and deployment configuration.

Use structured process invocation with separately validated arguments, avoid unnecessary shell interpretation, and enforce a strict command and argument allowlist.

Treat all remote tool input as untrusted, review every process-launching path, apply least privilege, and use automated analysis and tests for dynamic command construction.

Find out what's already
exploitable in your codebase.