/

CVE-2026-24105

Severity:

CRITICAL RISK

(9.8)

OS Command Injection in Tenda AC15 formsetUsbUnload Handler

CVE-2026-24105

Analyzed

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-94

Impact:

Remote Code Execution on Embedded Router

Severity:

CRITICAL RISK

(9.8)

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 flaw in the goform/formsetUsbUnload HTTP handler of the Tenda AC15 V1.0 (firmware V15.03.05.18_multi) router allows unvalidated input parameter v1 to flow into a system command execution routine.

If an attacker can send crafted HTTP requests to this endpoint, they may be able to execute arbitrary OS commands on the router with elevated privileges.

Affected context

This vulnerability occurs in the web management interface of the Tenda AC15 V1.0 router, specifically in the goform/formsetUsbUnload endpoint.

The issue arises when user-supplied data in parameter v1 is processed without adequate validation or sanitization and is later passed into a system command helper such as doSystemCmd.

Exploitation is generally possible where the router's HTTP interface is reachable (e.g., from the local network, and in some deployments from the internet if remote management or port forwarding is enabled).

Exploit preconditions

  • Attack surface: HTTP interface exposed by the Tenda AC15 web management service
  • Required access: Ability to send HTTP requests to goform/formsetUsbUnload (typically LAN access; WAN access if remote administration or UPnP/port forwarding exposes the interface)
  • Trigger point: Submission of a crafted v1 parameter value that is later passed to doSystemCmd or equivalent command execution routine
  • Why exploitation is possible: The v1 parameter is not validated, constrained, or safely encoded before being concatenated or interpolated into a shell command, allowing injection of additional command tokens

Why this happens

The root cause is improper handling of input used to construct operating system commands.

The v1 parameter accepted by goform/formsetUsbUnload is treated as trusted data and passed to a command execution helper such as doSystemCmd without robust validation, escaping, or use of a safe API that separates command and arguments.

This pattern corresponds to CWE-94: Improper Control of Generation of Code ('Code Injection'), where untrusted input influences dynamically generated and executed instructions—here represented by shell or OS commands.

In embedded web administration interfaces, such patterns often arise from convenience shortcuts that call system utilities directly, rather than implementing logic in native code with strict input handling.

Potential impact

  • Execution of arbitrary OS commands on the router
  • Complete takeover of the router's administrative interface
  • Installation of persistent malware or backdoors on the device
  • Interception, redirection, or manipulation of network traffic passing through the router
  • Use of the compromised device as part of a botnet or for further attacks inside the local network

General mitigation guidance

Effective mitigation focuses on preventing untrusted input from influencing command construction or execution:

  • Refactor command execution paths to avoid building shell commands with string concatenation; favor APIs that pass arguments as structured parameters rather than a single command string.
  • Apply strict whitelisting on inputs like v1, limiting values to a small set of expected tokens or enumerated options instead of free-form strings.
  • Normalize and validate all user-controlled parameters in the web interface, rejecting inputs that contain shell metacharacters or deviate from expected formats.
  • Minimize or remove direct calls to shell utilities from the HTTP handler layer, keeping command execution logic encapsulated and easier to audit.
  • Run the web management process with the least privileges necessary and compartmentalize sensitive operations to reduce the blast radius of potential injection.

How teams detect issues like this

To detect similar vulnerabilities in firmware or web administration code:

  • Use static analysis rules that flag string concatenation or interpolation when variables derived from HTTP parameters flow into command execution functions (e.g., wrappers like doSystemCmd, system, popen, exec*).
  • Review request handlers that accept parameters used in administrative operations (USB management, firmware updates, diagnostics) for direct invocation of shell commands.
  • Implement secure coding guidelines and code review checklists that explicitly call out OS command construction as a high-risk pattern requiring justification and strict validation.
  • Employ firmware analysis tools and source-scanning pipelines to identify dangerous sinks and unvalidated input paths in embedded C/C++ codebases.

Sources

SourceLink
github.comgithub.com/akuma-QAQ/CVEreport/tree/main/D-link/CVE-2026-24105
tenda.com.cntenda.com.cn/material/show/2710

Frequently asked

questions

It can be, depending on configuration. If the router's web management interface is exposed to the WAN—for example, via remote management features, misconfigured port forwarding, or UPnP—an external attacker could potentially exploit it. In default setups limited to LAN access, exploitation generally requires a presence on the local network.

The attacker needs the ability to send HTTP requests to the goform/formsetUsbUnload endpoint. This might be unauthenticated or require low-privilege credentials depending on how the router enforces authentication for that route.

Remove reliance on dynamically constructed shell commands for management operations and instead implement the required behavior directly in code using safe APIs. Where external utilities are unavoidable, pass parameters as structured arguments and enforce strict whitelists on all user-supplied values.

Adopt secure coding practices that treat all HTTP parameters as untrusted, forbid direct command construction with user input, and incorporate mandatory security reviews around any command execution logic. Combine these with automated static analysis integrated into the build process to catch injection patterns early in development.

Find out what's already
exploitable in your codebase.