/

CVE-2026-19188

Severity:

CRITICAL RISK

(10.0)

OS Command Injection (CWE-78) in Haiwell HMI Gateway

CVE-2026-19188

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Arbitrary Command Execution with Root Privileges

Severity:

CRITICAL RISK

(10.0)

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 critical OS command injection vulnerability in the Haiwell IoT Cloud HMI Gateway allows user-supplied input from the Net Check feature to reach the operating system without adequate sanitization. An attacker who can access the affected endpoint and trigger the cmdPing Socket.io event may execute arbitrary commands with root privileges.

Affected context

The vulnerability occurs in the Net Check functionality exposed through the /setting endpoint of the Haiwell IoT Cloud HMI Gateway. It becomes risky when externally influenced input from the cmdPing Socket.io event is incorporated into an operating-system command without strict validation and safe command-handling boundaries.

Exploit preconditions

  • Attack surface: The /setting endpoint and its associated Net Check Socket.io functionality
  • Required access: Network access sufficient to reach the affected interface; authentication requirements depend on deployment configuration
  • Trigger point: Processing of the cmdPing Socket.io event
  • Why exploitation is possible: User-controlled input reaches an operating-system command without adequate sanitization, allowing command syntax to alter the intended operation

Why this happens

The underlying bug is an OS command injection flaw caused by combining untrusted input with a system command in an unsafe manner.

This maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command, where input is not sufficiently constrained or separated from command arguments before execution. The insecure pattern allows data intended as a network-check parameter to influence command interpretation by the operating system.

Potential impact

  • An attacker may execute arbitrary operating-system commands
  • The attacker could gain control of processes running with root privileges
  • Device configuration and operational data may be modified or destroyed
  • The system could be used to access connected services or devices
  • Availability may be disrupted through privileged system changes

General mitigation guidance

Mitigation generally focuses on removing shell interpretation from network-check functionality and reducing the trust placed in request parameters.

Common defensive patterns include:

  • Using structured process-execution APIs that pass fixed arguments without invoking a shell
  • Allowing only narrowly defined, validated values for host and diagnostic parameters
  • Applying strict input schemas and rejecting unexpected characters, formats, and command options
  • Avoiding dynamic command construction and using secure-by-default library operations
  • Running gateway services with the least privileges needed for their functions rather than root
  • Restricting access to administrative endpoints and isolating management interfaces
  • Applying compensating controls such as network segmentation and restrictive process policies where practical

How teams detect issues like this

Organizations can look for command-injection risk through:

  • Static analysis rules identifying shell execution APIs that incorporate request, query, event, or form data
  • Code review checks for string concatenation or interpolation used to construct operating-system commands
  • Tests that verify invalid characters and unexpected argument forms are rejected
  • Runtime monitoring for unusual child-process creation, shell invocation, or privileged command activity by the gateway
  • Web and Socket.io gateway logs showing anomalous Net Check requests or repeated command-related failures
  • Policy enforcement requiring approved process-execution wrappers and input-validation controls

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

Sources

SourceLink
en.haiwell.comen.haiwell.com/app/system/entrance.php?m=include&c=access&a=dodown&lang=en&id=361
github.comgithub.com/cisagov/CSAF/blob/develop/csaf_files/OT/white/2026/icsa-26-225-02.json
cisa.govcisa.gov/news-events/ics-advisories/icsa-26-225-02

Frequently asked

questions

It may be remotely exploitable when the affected /setting interface is network-accessible and an attacker can invoke the Net Check functionality. The precise scope depends on exposure and access controls.

The supplied information does not establish whether authentication is required. Access to the endpoint and permission to trigger the cmdPing event are the relevant conditions.

Avoid shell-based command construction, use structured process APIs with fixed argument boundaries, and strictly validate all user-controlled parameters.

Apply least privilege, restrict administrative interfaces, enforce secure command-execution patterns in code review and CI policies, and monitor privileged child-process activity.

Find out what's already
exploitable in your codebase.