/

CVE-2026-90690

Severity:

HIGH RISK

(7.3)

OS Command Injection (CWE-78) in HexStrike AI API

CVE-2026-90690

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-77, CWE-78

Impact:

Remote Code Execution

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 command injection vulnerability in the HexStrike AI API Tools Endpoint may allow remote attackers to influence arguments passed to a system process. When attacker-controlled values reach the subprocess execution path without sufficient validation or separation, the service could execute unintended operating-system commands.

Affected context

The weakness occurs in deployments of 0x4m4 HexStrike AI where the API Tools Endpoint invokes subprocess.Popen from hexstrike_server.py and incorporates request-controlled values into command arguments. Risk is increased when the endpoint is remotely reachable, accepts untrusted input, and the service process has meaningful operating-system or application privileges.

Exploit preconditions

  • Attack surface: The remotely reachable API Tools Endpoint
  • Required access: Network access to an exposed endpoint; authentication requirements depend on deployment configuration
  • Trigger point: Processing request-controlled values such as additional_args, target, username, password, scan_type, or payload
  • Why exploitation is possible: Insufficient separation or validation allows attacker-controlled data to influence a subprocess execution path

Why this happens

The underlying bug is the unsafe flow of externally controlled input into a system command execution function. When values supplied through API parameters are concatenated, interpreted, or otherwise passed to a shell or command processor without strict validation and safe argument handling, an attacker may alter the intended command. This maps primarily to CWE-78, Improper Neutralization of Special Elements used in an OS Command, with CWE-77 describing the broader command-construction injection class.

Potential impact

  • An attacker may execute arbitrary operating-system commands in the service environment.
  • The service account could be compromised or misused.
  • Sensitive files, credentials, or environment data could be accessed.
  • The host or connected systems could be affected through lateral movement.
  • Security tools or scanning workflows could be disrupted or manipulated.

General mitigation guidance

Mitigation generally focuses on ensuring that API data is treated as data

rather than executable command content.

Common defensive patterns include:

  • Avoiding shell interpretation and using subprocess APIs that pass a fixed executable with a structured argument list.
  • Applying strict allowlists and type validation for targets, scan types, payload identifiers, and optional arguments.
  • Rejecting unexpected metacharacters, delimiters, and argument structures where they are not required by the interface.
  • Removing unnecessary support for caller-supplied command fragments or additional arguments.
  • Reducing trust in remote input through explicit schemas, authentication, authorization, and request-level policy enforcement.
  • Running the service with the minimum filesystem, network, and operating-system privileges needed.
  • Isolating tool execution in constrained workers or sandboxes where practical.

How teams detect issues like this

Organizations can look for command injection risks through:

  • Static analysis rules identifying subprocess.Popen, shell execution, and command-construction APIs that receive request-derived values.
  • Code review checks for string concatenation, interpolation, or shell-enabled process execution involving API parameters.
  • Data-flow analysis tracing HTTP request fields into process-spawning functions.
  • Runtime monitoring for unusual child processes, unexpected command interpreters, and abnormal outbound connections from the API service.
  • API policy enforcement that restricts accepted values and rejects unrecognized argument forms.
  • Automated security review tools that flag untrusted input reaching operating-system execution sinks.

Sources

SourceLink
github.comgithub.com/0x4m4/hexstrike-ai/issues/224
github.comgithub.com/0x4m4/hexstrike-ai/pull/266
vuldb.comvuldb.com/cve/CVE-2026-90690
vuldb.comvuldb.com/submit/914892
vuldb.comvuldb.com/vuln/403223
vuldb.comvuldb.com/vuln/403223/cti

Frequently asked

questions

Potentially. The described attack surface is a remotely reachable API endpoint,

although practical exploitability depends on network exposure, authentication,

authorization, and deployment controls.

An attacker needs the ability to submit requests that reach the affected API

Tools Endpoint. Whether that requires authentication depends on how the

endpoint is deployed and protected.

Keep the executable and arguments under application control, pass arguments

structurally without shell interpretation, and enforce strict allowlists and

schemas for all request-derived values.

Combine secure subprocess APIs with input trust reduction, code review and

static analysis for command sinks, endpoint access controls, audit logging,

and least-privilege execution.

Find out what's already
exploitable in your codebase.