Erlang/OTP vulnerabilities

Erlang OTP ssl (tls_handshake_1_3, ssl_handshake and tls_client_ticket_store modules) has an improper validation of consistency within input. A malicious TLS 1.3 server can cause a denial of service of the ssl application on the client node by sending a NewSessionTicket message with invalid extensions.

Improper certificate validation in the ssl application in Erlang/OTP allows a client holding a certificate trusted by one SNI virtual host to authenticate to a second SNI virtual host on the same listener by resuming its TLS 1.2 session there. A server serving multiple SNI names from one listen socket keeps one shared session cache and does not bind a cached session to the SNI name or client trust policy that established it. This affects OTP from 18.0 before 27.3.4.19, 28.5.0.8, and 29.1.2.

An incorrect authorization vulnerability in Erlang OTP (inets modules) allows unauthenticated access to CGI scripts protected by directory rules when served via script_alias. The path mismatch between access control evaluation and script execution allows bypassing protections.

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.

A vulnerability in the External Term Format (ETF) decoder in ERTS causes an integer underflow when processing crafted binary data. This leads to allocating huge memory and crashing the entire Erlang/VM node.

A Relative Path Traversal vulnerability in Erlang OTP (stdlib zip module) allows writing files outside the intended extraction directory via a crafted zip archive. The zip:unzip/1,2 and zip:extract/1,2 functions improperly validate paths, allowing bypass of protections.

In Erlang OTP (epmd), a connection slot exhaustion vulnerability allows an unauthenticated remote attacker to permanently terminate the epmd daemon. The do_accept function incorrectly treats EMFILE/ENFILE errors as fatal instead of recoverable.

Vulnerability in the Erlang/OTP ssl application. An unauthenticated attacker can send a crafted TLS 1.3 ClientHello, crashing the session ticket handler and making TLS 1.3 unusable until the ssl application is restarted.

TOCTOU race condition in the ssl module (dtls_packet_demux) in Erlang/OTP. An unauthenticated remote attacker can send multiple ClientHello messages from the same source, causing a race and crash of the demux process, terminating all active DTLS sessions on that listener. The attack is repeatable and requires no authentication.

Use of Default Cryptographic Key vulnerability in Erlang/OTP ssl (DTLS server) allows predictable DTLS cookie computation during the startup window, enabling source address verification bypass. On DTLS server startup, dtls_server_connection:initial_hello/3 initializes previous_cookie_secret to the empty binary instead of a random value. Because HMAC with an empty key is deterministic, anyone who observes the plaintext ClientHello can compute a valid DTLS cookie before the first rotation of the cookie secret.

A stack-based buffer overflow vulnerability in Erlang OTP (erl_interface) occurs in the ei_s_print_term function, which uses an internal 2000-character buffer. Very large integers can overflow the buffer, limiting exploitation to denial of service.

In Erlang OTP, the erts driver (inet_drv) contains a stack-based buffer overflow in sctp_parse_error_chunk, which writes cause codes into a fixed-size array without bounds checking. An unauthenticated remote attacker with an established SCTP association can send a crafted SCTP ERROR chunk and crash the BEAM VM. Limited leakage of VM memory fragments is also possible.

A vulnerability in Erlang/OTP ssl (inet_tls_dist module) allows bypassing the LAN allowlist for distribution over TLS. The function inet_tls_dist:check_ip/1 uses inet:sockname/1 instead of inet:peername/1, causing the subnet mask comparison to always succeed, allowing any holder of a CA-signed TLS certificate to gain access.

SSRF vulnerability in Erlang/OTP FTP module allows an attacker to redirect the data connection to any internal host and port via an unvalidated PASV response. The flaw exists in the default configuration (passive mode, IPv4, no FTP extensions) and enables FTP bounce attacks and internal network scanning.

A vulnerability in Erlang OTP's public_key module (pubkey_ocsp) allows forged OCSP responses signed with an expired responder certificate to be accepted as valid. The validity period of the OCSP responder certificate is not checked.

Improper certificate validation in Erlang OTP public_key (pubkey_ocsp module) allows OCSP designated-responder authorization bypass due to missing signature verification. An attacker can intercept OCSP responses and forge them to mark revoked certificates as valid.

Vulnerability in Erlang/OTP DNS module (inet_res, inet_db) allows DNS cache poisoning. It uses a sequential, process-global 16-bit transaction ID without source port randomization, making it easy for an attacker to predict the ID and inject forged responses.

Erlang OTP SSH (ssh_transport module) advertises legacy zlib compression by default, allowing a decompression bomb attack pre-authentication. Each SSH packet can decompress ~255 MB from 256 KB of data (1029:1 ratio), leading to memory exhaustion and DoS. Affects OTP from 17.0 before 28.4.1, 27.3.4.9, and 26.2.5.18.

The ssh_sftpd module in Erlang OTP before OTP 28.4.1, 27.3.4.9, and 26.2.5.18 uses string prefix matching instead of proper path component validation. Authenticated users can access sibling directories that share a common name prefix with the configured root directory.

Erlang/OTP has a relative path traversal vulnerability in the tftp_file modules, allowing access to files outside the intended directory. This affects OTP versions from 17.0 before 28.3.2, 27.3.4.8, and 26.2.5.17.

Resource exhaustion vulnerability in the SSH module of Erlang OTP (ssh_sftp) allows an attacker to perform a flooding attack. The issue affects the file lib/ssh/src/ssh_sftpd.erl and occurs in OTP versions 17.0 through 28.0.3, 27.3.4.3, and 26.2.5.15.

In OTP SSH (ssh_sftp modules) before certain versions, there is an uncontrolled resource consumption vulnerability leading to excessive allocation and flooding. The vulnerability is in the file lib/ssh/src/ssh_sftpd.erl.

The ssh_sftp module in Erlang OTP before OTP 28.0.3, 27.3.4.3, and 26.2.5.15 does not limit resource allocation, allowing excessive allocation and resource leak. The vulnerability is in lib/ssh/src/ssh_sftpd.erl.

The ssh_sftp module in Erlang OTP before OTP 28.0.3, 27.3.4.3, and 26.2.5.15 does not limit resource allocation, allowing excessive allocation and resource leak. The vulnerability is in lib/ssh/src/ssh_sftpd.erl.