/

CVE-2026-11452

Severity:

HIGH RISK

(7.3)

OS Command Injection (CWE-77) in GL.iNet GL-MT3000 SET_USER_PWD Handler

CVE-2026-11452

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-74, CWE-77

Impact:

Remote Command 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 GL.iNet GL-MT3000 router's /cgi-bin/glc SET_USER_PWD handler allows attacker-controlled password input to be incorporated into a shell command.

When exposed over the network, this flaw can let a remote attacker execute arbitrary system commands with the privileges of the web service, depending on how the device is deployed and authenticated.

Affected context

The vulnerability occurs in the GL-MT3000 firmware (up to version 4.4.5) within the CGI endpoint /cgi-bin/glc, specifically in the SET_USER_PWD handler function (FUN_0042e200).

The handler constructs a shell command that includes the Password argument, and although single quotes are escaped and the input is placed inside a single-quoted shell context, the overall design still pipes user-controlled data into a shell.

In deployments where this CGI is reachable over the LAN or exposed externally, and where authentication is weak, attackers may be able to submit crafted Password values to influence command execution.

Exploit preconditions

  • Attack surface: HTTP-based management interface on the GL-MT3000, specifically the /cgi-bin/glc endpoint using the SET_USER_PWD action.
  • Required access: Ability to send HTTP requests to the router's management interface; depending on configuration, this may require valid credentials or network proximity (e.g., being on the same LAN or Wi-Fi).
  • Trigger point: The vulnerable code path is invoked when the router processes a request that sets or changes the user password and passes the supplied Password parameter into a shell command.
  • Why exploitation is possible: The implementation uses shell command construction with embedded user data instead of a safer, parameterized system call, leaving room for command injection patterns, even though single quotes are escaped and the parameter is placed in a single-quote context. This maps to CWE-77 (Improper Neutralization of Special Elements used in a Command) and CWE-74 (Improper Neutralization of Data within Output Used by a Downstream Component).

Why this happens

The root cause is reliance on shell command composition that directly embeds user-controlled input, rather than using APIs that separate code and data.

In the SET_USER_PWD handler, the Password parameter is sanitized only for single quotes and then interpolated into a shell single-quoted context. While this mitigates some trivial injections, the design still treats user input as part of a shell command, which is inherently risky.

This pattern fits CWE-77: Improper Neutralization of Special Elements used in a Command ('Command Injection'), because the neutralization strategy is incomplete and fragile, and CWE-74: Improper Neutralization of Data within Output Used by a Downstream Component, as untrusted data is passed into a shell (a downstream interpreter) without robust isolation.

Potential impact

  • Remote execution of arbitrary shell commands within the router's firmware environment.
  • Complete compromise of the device's configuration and stored credentials.
  • Use of the router as a foothold for lateral movement inside the local network.
  • Deployment of persistent malware or participation in botnets (e.g., for DDoS).
  • Disruption of network connectivity or denial of service by manipulating system settings.

General mitigation guidance

Mitigations focus on removing the need to invoke a shell with user-controlled data and ensuring strict separation between user input and command logic:

  • Replace shell-based command construction with direct system or library calls that accept structured parameters (e.g., using dedicated APIs for user management instead of invoking /bin/sh or similar).
  • If shell invocation is unavoidable, construct commands as fixed templates and pass user data via safe channels (such as environment variables or argument arrays) without allowing it to affect the shell's parsing.
  • Apply strict input validation and normalization for fields like passwords, limiting allowed characters and length to what is operationally necessary and rejecting anything outside a defined whitelist.
  • Run web-facing components and associated scripts with least-privilege accounts, so that even if an injection occurs, the impact is constrained.
  • Restrict management interface exposure to trusted networks and enforce strong authentication mechanisms, reducing the number of potential attackers who can reach vulnerable handlers.

How teams detect issues like this

Detection is typically achieved by combining code-level review with behavioral monitoring:

  • Static analysis: Configure rules to flag any use of shell execution functions (e.g., system, popen, exec*, or equivalent) that include variables derived from HTTP parameters such as Password, especially in CGI handlers.
  • Code review signals: During manual reviews, look for string concatenation or formatting operations that build shell commands from request parameters; pay special attention to "escape and embed" patterns that attempt to sanitize but still rely on the shell.
  • Policy enforcement: Enforce coding standards that prohibit shelling out from web handlers unless an explicit security exception is granted and documented, and require security review for any such cases.
  • Runtime monitoring: Use logging or intrusion detection to track anomalous command executions originating from web endpoints, correlating unusual shell invocations with HTTP requests that contain suspicious characters or patterns in parameters like Password.

Sources

SourceLink
github.comgithub.com/StrTzz123/iot_vul/blob/main/GL-iNet/MT3000/4.4.5/nas_set_user_pwd_glc_rce/Readme.md
vuldb.comvuldb.com/cve/CVE-2026-11452
vuldb.comvuldb.com/submit/826378
vuldb.comvuldb.com/vuln/369072
vuldb.comvuldb.com/vuln/369072/cti

Frequently asked

questions

Yes, it can be triggered remotely when an attacker can reach the router's management interface and send requests to the /cgi-bin/glc endpoint invoking the SET_USER_PWD handler. Whether this is internet-exposed or limited to local networks depends on the device configuration.

It depends on how the management interface is configured. In many deployments, changing user passwords is an authenticated operation, so valid credentials or session access may be required. Misconfigurations, weak passwords, or other flaws could reduce this barrier.

The most robust fix is to eliminate shell-based handling of user input entirely by using native APIs or parameterized system calls for user and configuration management. Any remaining interaction with the shell should treat user input strictly as data, not as part of the command line.

Adopt a development guideline that forbids direct shell command construction from web parameters, enforce secure coding training around injection flaws, and integrate static analysis and security code review into the firmware development lifecycle to catch shell invocation patterns early.

Find out what's already
exploitable in your codebase.