/

CVE-2026-38065

Severity:

CRITICAL RISK

(9.8)

Command Injection (CWE-78) in Tenda 5G03 IMS APN Handler

CVE-2026-38065

Deferred

Vulnerability type

Category:

Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution on Network Device

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

Tenda 5G03 V05.03.02.04 (Version 1.0) contains a command injection flaw in the action_ims_on_with_apn function, where the ims_apn parameter is used in system-level commands without proper sanitization.

An attacker who can send crafted requests to the device's management interface may execute arbitrary OS commands with the privileges of the underlying system, leading to full compromise of the router.

Affected context

The vulnerability occurs in the web management interface logic of the Tenda 5G03 router, specifically when handling IMS configuration via the action_ims_on_with_apn function.

It is relevant in deployments where:

  • The administrative or configuration interface is reachable over the network (LAN or exposed WAN),
  • The ims_apn parameter is accepted from HTTP or similar management requests,
  • Input passed to system commands is not sufficiently validated, escaped, or constrained.

Actual exploitability depends on how the management interface is exposed and any surrounding authentication or access controls.

Exploit preconditions

  • Attack surface: Network-accessible management endpoint that processes the action_ims_on_with_apn request.
  • Required access: Ability to submit requests carrying a controlled ims_apn parameter (e.g., via HTTP to the router interface); authentication requirements depend on the specific configuration of the device.
  • Trigger point: Invocation of the action_ims_on_with_apn function when the router processes IMS/APN configuration data.
  • Why exploitation is possible: The ims_apn parameter is incorporated into OS command execution without adequate validation, encoding, or parameterization, allowing attacker-controlled metacharacters to alter command structure.

Why this happens

This issue stems from constructing operating system command lines using untrusted input from the ims_apn parameter and executing them directly.

Instead of treating the parameter as data and passing it through a strict validation and escaping routine or using safer OS interaction APIs, the code allows raw user-controlled content to influence the command string.

This behavior corresponds to CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), where unsanitized data can inject additional commands or arguments.

Potential impact

  • Remote execution of arbitrary system commands on the router.
  • Complete takeover of the device, including configuration changes and persistent backdoors.
  • Interception, redirection, or manipulation of network traffic routed through the device.
  • Use of the compromised router as a foothold for lateral movement within the local network.
  • Enrollment of the device into botnets or participation in large-scale DDoS attacks.

General mitigation guidance

Mitigation typically focuses on eliminating direct command construction from untrusted input and constraining device management interfaces.

Common defensive patterns include:

  • Replacing shell-based command execution with dedicated system APIs or libraries that accept structured parameters rather than raw command strings.
  • Applying strict allowlists for configurable fields such as APN values, rejecting any input containing control characters, shell metacharacters, or unexpected formats.
  • Normalizing and validating all management interface inputs using centralized validation routines with clear schemas.
  • Running command-executing components with least privilege and isolating them so that compromise has minimal blast radius.
  • Restricting access to the router's management interface to trusted networks and using strong authentication and encrypted channels to limit who can reach vulnerable endpoints.

How teams detect issues like this

High-level detection approaches can include:

  • Static analysis to identify string concatenation or formatting operations where untrusted parameters (such as ims_apn) flow into command execution functions or shell invocations.
  • Manual code review focusing on management handlers, checking for direct use of user input in system(), popen(), or similar APIs without robust validation and encoding.
  • Security testing and dynamic analysis (e.g., fuzzing or targeted penetration tests) that submit payloads containing shell metacharacters to management endpoints and monitor for anomalous behavior.
  • Enforcement of secure coding policies in the development process, such as banning direct shell calls with user input and requiring wrapper utilities or parameterized system APIs.

Sources

SourceLink
github.comgithub.com/sezangel/IOT-vul/tree/main/Tenda/5G03/action_ims_on_with_apn

Frequently asked

questions

It can be, if an attacker can reach the router's management interface that exposes the action_ims_on_with_apn functionality. Remote exploitation from the internet depends on whether the interface is exposed beyond the local network or accessible through other remote paths.

That depends on how the device is configured. If the vulnerable endpoint is protected by authentication, an attacker would first need valid credentials or another flaw to bypass login. If the endpoint is reachable without strong authentication, exploitation can occur with only network access.

The most robust pattern is to remove direct shell invocation with user-controlled data, use parameterized system APIs, and enforce strict allowlists and schema validation on configuration fields such as APN values.

Consistently apply secure coding practices around command execution, introduce centralized input validation for all management parameters, enforce code review rules that flag shell usage, and integrate static analysis focused on command injection into the development pipeline.

Find out what's already
exploitable in your codebase.