/

CVE-2026-51599

Severity:

CRITICAL RISK

(9.8)

Input Validation Flaw (CWE-20) in MIPC252W RTSP Service

CVE-2026-51599

Deferred

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20

Impact:

Denial of Service (Connection Starvation)

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

An input validation flaw in the RTSP service of MERCURY MIPC252W allows malformed requests with a declared Content-Length but no body to place the parser into an indefinite body-waiting state.

A remote, unauthenticated attacker can abuse this behavior to consume and stall individual TCP connections until the server times them out, temporarily denying service on those connections.

Affected context

This vulnerability occurs in the RTSP service of MERCURY MIPC252W devices when handling incoming RTSP requests that include a Content-Length header.

The parser assumes that a corresponding message body will follow and does not validate that the body is present or consistent with the header.

As a result, when a client sends such a malformed request and then continues sending data, the service treats subsequent bytes on that TCP connection as body content until a server-side timeout is reached.

Exploit preconditions

  • Attack surface: Network-exposed RTSP service on the MIPC252W device
  • Required access: None; the RTSP endpoint is reachable without authentication
  • Trigger point: Sending an RTSP request containing a Content-Length header without a matching message body
  • Why exploitation is possible: The RTSP parser transitions into a body-waiting state solely based on the header, failing to enforce sanity checks on message framing and allowing the connection to be tied up until timeout

Why this happens

The underlying issue is improper input validation (CWE-20) in the RTSP request parser, specifically in how it interprets and trusts the Content-Length header.

Instead of validating that the specified length is satisfied by the incoming payload, the implementation assumes the header is correct and transitions into a state where it indefinitely consumes data as body content.

This lack of validation on message completeness and framing allows a single malformed request to monopolize the connection and prevents proper processing of subsequent protocol data on that TCP channel.

Potential impact

  • Individual TCP connections to the RTSP service can be held in a waiting state until server-side timeout
  • Remote attackers can cause temporary denial of service on targeted connections
  • Resource consumption on the device may increase due to many concurrent stalled connections
  • RTSP streaming sessions or control channels can become unreliable or unavailable under sustained attack

General mitigation guidance

Mitigation generally focuses on tightening message parsing and reducing trust in client-supplied headers.

Useful patterns include:

  • Validating that Content-Length is consistent with the actual number of bytes received and rejecting requests that cannot be satisfied within reasonable bounds
  • Implementing strict state machines for RTSP message parsing that promptly abort malformed requests rather than waiting indefinitely
  • Enforcing per-connection and per-client limits on pending requests, body size, and wait times to prevent long-lived half-open transactions
  • Applying conservative timeouts and connection caps at the transport layer so that misbehaving connections cannot starve legitimate traffic

How teams detect issues like this

Detection can leverage both network- and code-centric approaches:

  • Network monitoring for RTSP connections that remain active but idle in terms of completed requests, especially with mismatched Content-Length usage
  • Logging and alerting on parse errors, incomplete RTSP messages, or repeated timeouts triggered while waiting for request bodies
  • Static or manual review of RTSP parsing code for assumptions that trust header values without verifying message completeness
  • Automated testing that fuzzes RTSP headers and body framing to surface cases where the parser becomes stuck or fails to reject malformed input

Sources

SourceLink
github.comgithub.com/kkkk2222874/cve_ID_report/blob/main/MERCURY_MIPC252W/MERCURY_MIPC252W_7th/README.md

Frequently asked

questions

Yes. Any remote attacker who can reach the RTSP service over the network can send malformed RTSP requests to trigger the connection-stalling behavior.

No. The vulnerability is triggered before authentication and only requires the ability to open an RTSP TCP connection and send crafted requests.

The safest pattern is to enforce strict validation of RTSP message framing: verify that Content-Length is sane, ensure the declared body is fully received within defined limits, and immediately close or reject connections that do not complete a well-formed request.

Implement robust protocol parsers with explicit state machines, use defensive coding practices that treat all client input as untrusted, apply systematic fuzz testing of protocol handlers, and define conservative timeouts and resource limits for network services.

Find out what's already
exploitable in your codebase.