Severity:

HIGH RISK

(7.2)

Command Injection in UTT HiPER 810 rehttpd

CVE-2026-2118

Analyzed

Vulnerability type

Category:

Command Injection

CWE:

CWE-74, CWE-77

Impact:

Remote Code Execution on Network Appliance

Severity:

HIGH RISK

(7.2)

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

UTT HiPER 810 firmware 1.7.4-141218 contains a command injection vulnerability in the rehttpd web server, specifically in the /goform/formReleaseConnect handler and its sub_4407D4 function.

By manipulating the Isp_Name parameter, a remote attacker can inject arbitrary system commands, potentially gaining full control of the affected device.

Affected context

This vulnerability occurs in the embedded web management interface (rehttpd) of UTT HiPER 810 routers running firmware version 1.7.4-141218.

It is exposed when the /goform/formReleaseConnect endpoint is reachable over the network and processes user-supplied Isp_Name input as part of system-level operations.

Environments where the device's admin or WAN interface is accessible to untrusted networks are at particular risk, especially if access controls or segmentation are weak.

Exploit preconditions

  • Attack surface: HTTP interface of the router's rehttpd process, specifically the /goform/formReleaseConnect endpoint.
  • Required access: Network-level access to the web management service; may require valid session/authentication depending on deployment and configuration.
  • Trigger point: Submission of a crafted HTTP request that sets the Isp_Name parameter to include command injection syntax.
  • Why exploitation is possible: The sub_4407D4 function incorporates Isp_Name directly into a system command or shell context without proper sanitization, escaping, or use of safe APIs, allowing injected shell metacharacters to be interpreted by the underlying OS.

Why this happens

The underlying flaw is the direct concatenation of user-controlled data (Isp_Name) into a command line executed by the operating system without robust validation.

This maps to CWE-77: Improper Neutralization of Special Elements used in a Command ('Command Injection') and is closely related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component.

In abstract terms, the code treats input parameters as trusted content within a shell or system command, failing to neutralize or reject shell metacharacters, pipelines, or command separators, which the OS then interprets as additional commands.

Potential impact

  • Execution of arbitrary system commands with the privileges of the rehttpd process.
  • Full compromise of the router, including configuration manipulation and credential theft.
  • Interception, redirection, or disruption of network traffic traversing the device.
  • Use of the router as a foothold for lateral movement inside the network.
  • Enrollment of the device into botnets or participation in DDoS campaigns.
  • Deployment of persistent backdoors or malicious configuration changes.

General mitigation guidance

Mitigation strategies center on eliminating direct command construction from untrusted data and tightening the device's exposure:

  • Replace shell-based invocation with safer, parameterized system APIs that do not invoke a shell or interpret metacharacters.
  • Apply strict input validation on Isp_Name and similar parameters, allowing only expected characters (e.g., alphanumeric plus a minimal, vetted set of punctuation).
  • Normalize and reject inputs containing shell metacharacters, control characters, or command delimiters, rather than attempting ad-hoc escaping.
  • Minimize the privileges of the web server process so that, if compromised, its ability to affect the system is reduced.
  • Limit network exposure of the management interface via firewall rules, VPN-only access, or management VLANs to reduce reachable attack surface.

These patterns reduce both the risk of injection and the blast radius if a flaw is present.

How teams detect issues like this

Detection typically combines code-centric and operational monitoring approaches:

  • Static analysis: Configure SAST tools or linters to flag direct use of shell execution functions (e.g., system, popen, backticks) that concatenate user input, especially in request handlers like /goform/*.
  • Code review: During manual review, look for:
  • String-building of command lines using HTTP parameters such as Isp_Name.
  • Conditional logic that passes user input into process execution APIs without a fixed, whitelisted argument set.
  • Runtime monitoring: Enable logging around management HTTP requests and system command execution; look for anomalous values in Isp_Name or unexpected shell metacharacters.
  • Policy enforcement: Adopt coding standards that mandate input validation and prohibit raw shell invocation in request-handling code, with automated checks in CI to enforce these standards.

Sources

SourceLink
github.comgithub.com/cha0yang1/UTT810CVE/blob/main/CVEreadme1.md
github.comgithub.com/cha0yang1/UTT810CVE/blob/main/CVEreadme1.md#poc
vuldb.comvuldb.com/?ctiid.344693
vuldb.comvuldb.com/?id.344693
vuldb.comvuldb.com/?submit.746802

Frequently asked

questions

Yes. If the web management interface is reachable over the network and the vulnerable endpoint is accessible, an attacker can send crafted HTTP requests to exploit the command injection.

It depends on how the device is configured. In some deployments, the vulnerable endpoint may require an authenticated session; in others, weak or absent access control could allow unauthenticated exploitation. Network proximity to the management interface is always required.

Avoid constructing shell commands from user input. Use parameterized system APIs or dedicated libraries that accept arguments as structured data, and apply strict allowlist-based validation on any value that influences system-level operations.

Establish secure coding guidelines that prohibit unvalidated input in shell commands, enforce allowlist validation for all externally supplied parameters, reduce service privileges, and integrate static analysis plus security-focused code review into the development lifecycle to catch injection patterns early.

Find out what's already
exploitable in your codebase.