/

CVE-2026-11450

Severity:

HIGH RISK

(7.3)

Command Injection via Path Normalization Handler (CWE-77) in GL.iNet GL-MT3000 RPC Interface

CVE-2026-11450

Deferred

Vulnerability type

Category:

Command Injection

CWE:

CWE-74, CWE-77

Impact:

Remote Command Execution on Embedded Router

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

GL.iNet GL-MT3000 routers prior to firmware 4.7 contain a command injection vulnerability in the /usr/lib/oui-httpd/rpc/ path normalization handler, specifically in logic that uses dlopen and processes the dev_name argument.

A remote attacker who can invoke the affected RPC methods can inject crafted values into dev_name, leading to execution of arbitrary system commands on the device.

Affected context

The vulnerability exists in the GL-MT3000's embedded web/RPC service, where HTTP requests to the /rpc layer are mapped to backend functions using a path normalization handler.

The dev_name parameter is processed and ultimately influences dynamic library loading or command execution without sufficient sanitization.

Deployments are at risk when the device exposes its management or RPC interface to untrusted networks, or when an attacker can reach the default /rpc endpoint through the LAN or a VPN.

Exploit preconditions

  • Attack surface: HTTP /rpc interface of the GL-MT3000 router
  • Required access: Network-level access to the device's management/RPC port; no physical access required
  • Trigger point: Invocation of the affected RPC method(s) with a malicious dev_name parameter that passes minimal superficial validation
  • Why exploitation is possible: The dev_name value is incorporated into downstream command or library loading logic without robust validation, escaping or strict whitelisting, enabling crafted input to alter the intended command or code path

Why this happens

The underlying issue is improper neutralization of user-controlled input before it is used in command or dynamic loading contexts, mapping to CWE-77: Command Injection and CWE-74: Improper Neutralization of Data in Output Used by a Downstream Component.

The path normalization handler takes a dev_name argument supplied over HTTP and propagates it into sensitive operations, such as dlopen-based loading or shell-invoked utilities, without enforcing strict constraints on allowed values.

Instead of binding requests to a closed set of safe, pre-defined operations, the design permits flexible parameter-driven behavior, creating a channel where crafted data can escape its role as data and influence control flow.

Potential impact

  • Remote execution of arbitrary commands on the router
  • Unauthorized access to router configuration and stored credentials
  • Use of the device as a foothold for further attacks within the local network
  • Installation of persistent malware or backdoors on the router
  • Disruption of network services provided by the device

General mitigation guidance

Mitigation generally focuses on constraining how user input influences backend operations and reducing the reachable attack surface.

Pattern-based mitigations include:

  • Applying strict method-level whitelisting at RPC boundaries so only explicitly allowed operations can be invoked, independent of user-supplied parameters.
  • Validating parameters like dev_name against tight schemas or enumerated sets (e.g., known device identifiers), rejecting any value that does not conform.
  • Avoiding composition of shell commands or dynamic library paths directly from user input; instead, mapping user-facing tokens to internal constants or preconfigured paths.
  • Implementing robust input neutralization when interaction with downstream components is unavoidable, ensuring special characters and control metacharacters are either rejected or safely encoded.
  • Running web/RPC services with least privilege on the system so that, even if misuse occurs, the blast radius is minimized.
  • Restricting external exposure of the management/RPC interface through firewall rules, access control lists, or VPN-only access to administrative endpoints.

How teams detect issues like this

Detection efforts can target both code-level patterns and runtime behavior.

Possible strategies:

  • Static analysis rules that flag any use of dlopen, system, popen, or similar APIs where arguments incorporate HTTP or RPC parameters without clear validation or whitelisting.
  • Code review checklists that explicitly call out RPC handlers and path normalization logic, ensuring all callable methods are enumerated and guarded by allow-lists.
  • Configuration and policy checks that verify administrative interfaces, including /rpc endpoints, are not exposed directly to the internet and require authentication.
  • Runtime monitoring and logging of RPC invocations, including method names and key parameters, with anomaly detection for unusual dev_name values or patterns suggesting command injection attempts.
  • Use of automated firmware or embedded security testing tools to fuzz RPC endpoints and identify cases where user-controlled input reaches system-level calls.

Sources

SourceLink
github.comgithub.com/StrTzz123/iot_vul/tree/main/GL-iNet/MT3000/4.4.5/nas_eject_disk_do1_glc_rce
vuldb.comvuldb.com/cve/CVE-2026-11450
vuldb.comvuldb.com/submit/825536
vuldb.comvuldb.com/vuln/369070
vuldb.comvuldb.com/vuln/369070/cti

Frequently asked

questions

Yes. An attacker who can reach the GL-MT3000's RPC or management interface over the network can attempt to exploit the vulnerable path normalization handler by sending crafted HTTP requests.

Exploitability depends on how the device is configured. If the /rpc endpoint or related methods are accessible without strong authentication or are exposed to untrusted networks, an unauthenticated attacker may leverage this path. Strong access control significantly reduces practical risk.

The most robust pattern is to enforce strict method-level whitelisting and parameter validation at the RPC boundary, ensuring only predefined operations can be invoked and all parameters are constrained to safe, expected values. Additionally, decoupling user input from command or path construction helps eliminate injection opportunities.

Future designs should treat all data arriving over HTTP/RPC as untrusted, enforce clear separation between control logic and data, and adopt secure coding patterns for command execution and dynamic loading. Regular security reviews of management interfaces, combined with automated static analysis that targets injection patterns, can catch similar issues early in development.

Find out what's already
exploitable in your codebase.