CVE-2026-28808

In Erlang OTP (inets httpd module), an HTTP Request Smuggling vulnerability exists. The server does not reject or normalize duplicate Content-Length headers. The first value is used, while common proxies use the last, enabling front-end/back-end desynchronization and injection of attacker-controlled bytes as the start of the next request.

An issue was discovered in Erlang/OTP 18.x related to the generation of compiled regular expressions, which is vulnerable to a heap overflow. Regular expressions using a malformed extpattern can indirectly specify an offset used as an array index.

In Erlang/OTP, when using the inet driver with {packet,4} mode, an attacker connecting to an open TCP port can exploit a signed overflow in packet length calculation, potentially overflowing the receive buffer and crashing the BEAM VM.

The httpd HTTP server in the inets application fails to enforce a configured body-size limit on chunked requests. This may allow sending very large requests, potentially leading to server overload.

The check_header/3 function in httpd rejects duplicate Content-Length but does not check for the co-presence of Transfer-Encoding and Content-Length, which can lead to request smuggling desynchronization between front-end and back-end.

Gracefulness code ignored cases that should be rejected, resulting in possible HTTP Request Smuggling opportunities.

A vulnerability in the Erlang/OTP SSL application allows memory exhaustion by sending a crafted certificate chain during TLS/DTLS handshake. Lack of cycle detection in the certificate chain building function causes unbounded recursion, leading to BEAM node crash.

The TLS 1.2 (and earlier) and DTLS client in Erlang/OTP does not verify that the cipher suite selected by the server in ServerHello was among the suites offered by the client. An on-path attacker can select an anonymous cipher suite, bypassing certificate and hostname verification, allowing interception and modification of traffic.

In Erlang OTP, a signed to unsigned conversion error and out-of-bounds heap write vulnerability exists when decoding a crafted ETF binary via binary_to_term/1. This can corrupt the BEAM heap pointer and crash the virtual machine.