/

CVE-2026-51606

Severity:

HIGH RISK

(7.5)

Improper Input Handling (CWE-20) in Tenda CP3 RTSP Service

CVE-2026-51606

Deferred

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20

Impact:

Service Disruption and Protocol Non-Compliance

Severity:

HIGH RISK

(7.5)

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

An improper input handling flaw in the RTSP service of Tenda CP3 V3.0 causes the device to drop TCP connections with a RST packet when RTSP requests contain oversized URL or header field values.

Instead of returning an RFC 2326-compliant error response, the abrupt termination can disrupt streaming sessions and make robust client-side error handling difficult, especially when interacting with untrusted or malformed RTSP traffic.

Affected context

The vulnerability occurs in the RTSP service of Tenda CP3 V3.0 (firmware V31.1.9.91) when processing inbound RTSP requests over TCP.

It is triggered when the request-line URL field or one of the header field values exceeds the size the implementation expects.

In these conditions, the service does not gracefully reject the request with a standards-compliant RTSP error; instead, it abruptly closes the TCP connection by sending a RST packet, affecting normal client-server interactions under malformed or fuzzed traffic.

Exploit preconditions

  • Attack surface: Network-exposed RTSP port on the Tenda CP3 device.
  • Required access: Ability to send crafted RTSP requests to the device (e.g., from the local network or any network segment where the RTSP service is reachable).
  • Trigger point: Submission of an RTSP request whose request-line URL or specific header field values are oversized beyond the parser's accepted threshold.
  • Why exploitation is possible: The RTSP parser does not robustly validate input lengths or handle boundary conditions, leading it to terminate the TCP session with a reset instead of returning a controlled, standards-compliant error response.

Why this happens

This issue stems from improper input validation and error handling when parsing RTSP request fields.

The implementation appears to assume that certain fields (such as the URL in the request line and various header values) will fall within implicit size limits, rather than enforcing explicit bounds and handling violations through graceful error paths.

When oversized values are encountered, the parser transitions into an error state that results in a forced TCP connection reset, instead of generating a valid RTSP error message.

Conceptually, this maps to CWE-20: Improper Input Validation, where external inputs are not checked against defined constraints before being processed, causing unexpected control flow and protocol non-compliance under abnormal conditions.

Potential impact

  • RTSP streaming sessions may be unexpectedly terminated when malformed or oversized requests are received.
  • Clients can experience repeated connection drops, complicating error recovery and potentially degrading user experience.
  • Automated systems relying on RTSP responses for monitoring or control may misinterpret abrupt resets as network or device failures.
  • Fuzzing or hostile traffic could be used to repeatedly disrupt RTSP service availability through connection resets.

General mitigation guidance

Mitigations generally focus on strict input validation and robust error handling around protocol parsing:

  • Enforce explicit, documented maximum lengths for RTSP request-line URLs and header fields before deeper parsing logic runs.
  • Handle any boundary violation by constructing and returning a standards-compliant RTSP error response, rather than tearing down the TCP connection abruptly.
  • Separate parsing and validation stages so that malformed input is detected early and routed through controlled error paths.
  • Implement defensive parsing patterns, such as length checks, safe buffer management, and fail-closed logic that preserves protocol semantics even under malformed input.
  • Limit exposure of RTSP services to trusted networks or intermediaries that can sanitize and validate protocol traffic.

How teams detect issues like this

Detection can rely on a combination of network-level observation and code-focused review:

  • Network monitoring: Use protocol-aware traffic inspection or logs to detect patterns where RTSP connections are consistently terminated with TCP RST packets after oversized or malformed requests.
  • Fuzz testing: Apply RTSP-specific fuzzers that vary URL and header lengths to reveal abnormal behaviors, such as resets instead of valid RTSP error responses.
  • Static analysis and code review: Examine RTSP parsing routines for missing length checks, unchecked copies, and error paths that jump to connection teardown instead of generating proper protocol responses.
  • Policy enforcement: Integrate automated review tools or CI checks that flag protocol parsers lacking explicit bounds validation and clear error-handling cases for invalid input.

Sources

SourceLink
github.comgithub.com/kkkk2222874/cve_ID_report/blob/main/Tenda_CP3_V3.0/Tenda_CP3_V3.0_5th/README.md

Frequently asked

questions

Yes, it can be triggered remotely by any party that can send RTSP requests to the exposed service, as long as network access to the RTSP port is available.

An attacker needs network-level access to the device's RTSP interface. No prior authentication is inherently required to send oversized RTSP requests, though other network controls may restrict who can reach the service.

The safest general fix is to introduce strict, centralized length validation for all RTSP request-line and header fields and to ensure that any violation leads to a controlled, standards-compliant RTSP error response rather than a TCP reset.

Future implementations should adopt defensive parsing practices: define explicit input size limits, validate data before processing, maintain clear error-handling paths that preserve protocol semantics, and use fuzz testing and static analysis as part of the development lifecycle to catch malformed-input behaviors early.

Find out what's already
exploitable in your codebase.