Loop with Unreachable Exit Condition ('Infinite Loop') vulnerability in Erlang OTP stdlib (erl_tar module), hexpm hex_core (hex_erl_tar module), hexpm hex (mix_hex_erl_tar module) and erlang rebar3 (r3_hex_erl_tar module) allows an attacker who supplies a tar archive to cause a denial of service via a crafted GNU sparse member.
When erl_tar:extract/1,2 writes a member to disk, erl_tar:stream_to_file_loop/3 reads it in chunks of 65536 bytes by default. For a GNU sparse member whose sparse map ends before its real size, erl_tar:do_sparse_read/3 matches its trailing-hole clause before its zero-length clause. After the chunk is used up, the trailing-hole clause reads zero bytes, does not advance the position, and recurses forever. A 2048-byte archive keeps the extracting process and one scheduler busy until the process is killed. The {max_size, N} option prevents this only when N is below the real size of the member. Extraction with the memory option is not affected.
hex_core ships its own copy of erl_tar as hex_erl_tar, and Hex and rebar3 ship hex_core with prefixed module names (mix_hex_erl_tar and r3_hex_erl_tar). These copies contain the same code and do not call stdlib's erl_tar, so they are affected on any OTP version. OTP 28 is not affected, but an application running on OTP 28 is affected if it extracts archives through an affected version of hex_core, Hex or rebar3.
This issue affects OTP from OTP 29.0 before OTP 29.1.2, corresponding to rebar3 from 3.27.1 before 3.28.0, and stdlib from 8.0 before 8.1.1, and hex from 2.4.2 before 2.5.3; hex_core: from 0.14.0 before 0.20.1.
CVE-2026-105236 is an improper certificate validation vulnerability in the ssl application of Erlang/OTP. It allows a client trusted by one SNI virtual host to authenticate to another SNI virtual host on the same listener by resuming a TLS 1.2 session. The issue arises because the server's session cache is shared across SNI names without binding sessions to specific SNI names or client trust policies. This affects Erlang/OTP versions from 18.0 up to but not including 27.3.4.19 and ssl versions from 7.0 up to but not including 11.2.12.14. TLS 1.3 is not affected. The vulnerability has a CVSS 4.0 score of 6.3 (medium severity).
CVE-2026-94200 is a high-severity vulnerability in Erlang OTP's ssl application affecting TLS 1.3 client implementations. It involves improper validation of consistency within input, specifically in how the client processes NewSessionTicket message extensions. This flaw allows a malicious TLS 1.3 server to cause a denial of service by crashing the ssl application on the client node through repeated crashes of the tls_client_ticket_store. The issue affects OTP versions from 23.3 up to but not including 27.3.4.19 and ssl versions from 10.3 up to but not including 11.2.12.14. No explicit patch links are provided, so patch status should be verified with the vendor. The vulnerability has a CVSS 4.0 score of 8.2, indicating high severity.
Inefficient algorithmic complexity in the Erlang/OTP asn1 OBJECT IDENTIFIER decoder allows a remote unauthenticated attacker to cause denial of service by sending a crafted OID during the TLS handshake.
The BER OID decoder asn1rtt_ber:dec_subidentifiers/3 in lib/asn1/src/asn1rtt_ber.erl and the equivalent PER helper asn1rtt_per_common:dec_subidentifiers/3 in lib/asn1/src/asn1rtt_per_common.erl accumulate a base-128 subidentifier into an unbounded integer using (Av bsl 7) + H per continuation byte. Each shift and addition on the growing accumulator is linear in the number of bits already accumulated, giving quadratic total work in the size of a single subidentifier. The JER helper asn1rtt_jer:json2oid/1 in lib/asn1/src/asn1rtt_jer.erl exhibits the same class of unbounded-integer parsing when decoding a dot-separated OID from JSON. A DER-encoded OBJECT IDENTIFIER with one very large arc (approximately 262 KB of continuation bytes) consumes roughly 13 seconds of CPU on typical hardware.
The vulnerable decoder is generated into every ASN.1 module that contains an OBJECT IDENTIFIER, including OTP-PUB-KEY which is reached during X.509 certificate parsing via public_key:pkix_decode_cert/2. This decoder runs before any signature or trust chain verification, so any Erlang service that parses peer TLS certificates is exposed: the default for TLS clients (which always parse the server certificate) and for mutual-TLS servers (which parse client certificates).
This vulnerability is associated with program files lib/asn1/src/asn1rtt_ber.erl, lib/asn1/src/asn1rtt_per_common.erl and lib/asn1/src/asn1rtt_jer.erl and program routines asn1rtt_ber:dec_subidentifiers/3, asn1rtt_per_common:dec_subidentifiers/3 and asn1rtt_jer:json2oid/1.
This issue affects OTP from OTP 17.0 before OTP 27.3.4.18, OTP 28.5.0.7, and OTP 29.1.1, corresponding to asn1 from 3.0 before 5.3.4.3, 5.4.3.1, and 5.5.2. Whether OTP before OTP 17.0, corresponding to asn1 before 3.0, is affected is unknown.
Allocation of Resources Without Limits or Throttling vulnerability in Erlang/OTP ssh allows an authenticated remote attacker to exhaust node memory by repeatedly opening session channels that are never assigned a handler.
The "session" clause of ssh_connection:handle_msg/4 checks only minimal_remote_max_packet_size before calling setup_session/5, which unconditionally builds a #channel{} record and stores it in the ETS channel cache. The max_channels daemon option is consulted only by ssh_channel_sup:max_num_channels_not_exceeded/2, which counts supervisor children, so a channel that never gets a shell, exec, or subsystem handler is invisible to the limit and setting the option to a finite value does not mitigate the attack. RFC 4254 section 5.1 permits many session channels per connection, and each record costs only a few hundred bytes, so a single authenticated connection can accumulate channels until the node runs out of memory and the emulator terminates, affecting every application on it. No file contents, credentials, or write access are obtainable.
This issue affects OTP from OTP 18.1.2 before OTP 27.3.4.18, OTP 28.5.0.7, and OTP 29.1.1, corresponding to ssh from 4.1.1 before 5.2.11.13, 5.5.2.6, and 6.0.6. Whether OTP before OTP 18.1.2, corresponding to ssh before 4.1.1, is affected is unknown.
Key Exchange without Entity Authentication vulnerability in Erlang/OTP ssl allows a peer that answers a TLS 1.3 client connection to impersonate the intended server. A pre_shared_key extension in the ServerHello that the client never offered causes the client to complete the handshake without validating the server's certificate, so ssl:connect returns {ok, Socket} against a peer holding no certificate, no private key and no prior session.
tls_client_connection_1_3:handle_server_hello/2 passes the received extension to tls_gen_connection_1_3:handle_resumption/2, which sets resumption = true on its mere presence without checking that the client offered a PSK. tls_handshake_1_3:get_pre_shared_key/4 meanwhile falls back to the all-zero "no PSK" value and keys the handshake with the ordinary non-PSK schedule, so the attacker's own ephemeral key suffices. The resumption flag then routes maybe_resumption/1 straight to wait_finished, skipping the certificate-handling states, so certificate path validation, verify_fun, hostname verification, partial_chain, CRL checking and OCSP stapling are all bypassed. The default client configuration is affected; clients restricted to TLS 1.2 are not.
This issue affects OTP from OTP 22.2 before OTP 27.3.4.18, OTP 28.5.0.7, and OTP 29.1.1, corresponding to ssl from 9.5 before 11.2.12.13, 11.6.0.6, and 11.7.7.
CVE-2026-73812 is a high-severity vulnerability in Erlang OTP's HTTP server (httpd) involving inconsistent interpretation of HTTP requests, specifically HTTP request/response smuggling. The vulnerability occurs because the httpd function check_header/3 rejects duplicate Content-Length headers but does not check for the simultaneous presence of Transfer-Encoding and Content-Length headers, which RFC 9112 §6.3 identifies as a probable smuggling attempt. This can lead to desynchronization between front-end and back-end HTTP processing when a Content-Length-preferring front-end is paired with a chunked-preferring back-end. Multiple OTP and inets versions are affected. No explicit patch information is provided.
CVE-2026-73276 is a high-severity vulnerability in Erlang OTP that involves inconsistent interpretation of HTTP requests, specifically in the Gracefulness code. This flaw allows HTTP Request Smuggling attacks by ignoring certain cases that should have been rejected. The vulnerability affects multiple OTP versions from 22.2 up to but not including 27.3.4.17, 28.0 up to but not including 28.5.0.6, and 29.0 up to but not including 29.0.6, as well as corresponding inets versions. It has a CVSS 4.0 score of 8.3, indicating high severity. No vendor advisory or patch information is currently available.
CVE-2026-66357 is a high-severity vulnerability in Erlang OTP's httpd component related to inconsistent interpretation of HTTP requests, specifically HTTP request/response smuggling. The issue arises because httpd never implemented obs-fold (header continuation lines) as specified in RFC 2616 and RFC 7230, causing every CRLF followed by a non-CRLF octet to start a new header unconditionally. This behavior can lead to security concerns as it deviates from expected HTTP parsing, potentially enabling request smuggling attacks. The vulnerability affects multiple OTP and inets versions prior to specific fixed releases.
CVE-2026-55951 is a high-severity vulnerability in the Erlang/OTP httpc HTTP client where no limit is enforced on the total size of response headers from a server. This allows a malicious or compromised HTTP server to send an arbitrarily large number or size of headers, causing unbounded memory allocation in the client process. This can lead to system memory exhaustion or a crash of the BEAM VM. The vulnerability affects multiple OTP versions from 17.0 up to but excluding 27.3.4.17, 28.0 up to but excluding 28.5.0.6, and 29.0 up to but excluding 29.0.6, as well as corresponding inets versions. Any application using httpc:request/4,5 to connect to untrusted servers is vulnerable without requiring authentication.
CVE-2026-74994 is an incorrect authorization vulnerability in the mod_auth module of Erlang OTP's inets httpd server. When configured with dets or mnesia authentication backends and multiple directory configuration blocks, all directory blocks share a single user/group namespace. This causes a user authorized for one protected directory to be accepted for all other protected directories on the same server instance. The vulnerability affects multiple OTP and inets versions prior to specific fixed releases.
CVE-2026-74835 is a high-severity vulnerability in the Erlang OTP inets HTTP server where the configured body-size limit on chunked HTTP requests is not enforced. This flaw allows resource exhaustion due to allocation without limits or throttling. The issue affects multiple OTP and inets versions and has a CVSS 4.0 base score of 8.7. The vulnerability is fixed in OTP versions 27.3.4.17, 28.5.0.6, 29.0.6 and inets versions 9.3.2.7, 9.6.2.3, and 9.7.2. No known exploits are reported in the wild.
CVE-2026-66835 is a path equivalence vulnerability in the Erlang/OTP inets httpd server that allows remote unauthenticated attackers to bypass mod_auth directory protections by using multiple leading slashes in the request path. This causes the authentication check to fail due to a mismatch in path normalization and regex matching, enabling unauthorized file reads within protected directories. The vulnerability affects multiple OTP and inets versions prior to specific fixed releases.
Missing Release of Resource after Effective Lifetime vulnerability in Erlang/OTP inets httpd allows an unauthenticated remote attacker to cause denial of service by sending a request with a chunked body whose chunk-size line is not a hexadecimal number. The worker serving the connection is never released and no timeout reclaims it, so repeating the request across connections occupies every available worker and denies service to legitimate clients. No authentication is required and the default configuration is affected.
The chunk-size line must arrive in a write separate from the headers. When the body accompanies the headers, httpd_request_handler:handle_body/3 calls http_chunk:decode/3 inside a try ... catch throw:Error, so the {error, {chunk_size, _}} thrown by http_chunk:decode_size/4 is answered with 400 Bad Request. When the chunk size arrives later, the decoder is resumed through a bare catch in httpd_request_handler:handle_info/2, which converts the throw into a return value rather than raising it; the resulting error tuple is then treated as the next decoder continuation, the socket is re-armed, and the worker waits for data that never comes. The request timeout has already been cancelled at the point the headers were accepted, and the periodic byte-rate check is only armed when minimum_bytes_per_second is configured, which it is not by default.
This issue affects OTP from OTP 18.1.4 before OTP 27.3.4.17, OTP 28.5.0.6, and OTP 29.0.6, corresponding to inets from 6.0.3 before 9.3.2.7, 9.6.2.3, and 9.7.2.
CVE-2026-70409 is a medium-severity vulnerability in Erlang/OTP's eldap module involving improper validation of the port component in LDAP referral URLs. A malicious or compromised LDAP server can supply a referral URL with an excessively long numeric port, causing the eldap:parse_port/2 function to perform costly arbitrary-precision integer conversions. This can degrade application availability by consuming significant processing time. The flaw affects multiple OTP versions from 17.0 up to but excluding patched versions 27.3.4.17, 28.5.0.6, and 29.0.6, as well as corresponding eldap library versions. Exploitation requires the application to pass server-supplied referrals to eldap:parse_ldap_url/1, which eldap itself does not call internally. No known exploits are reported in the wild.
CVE-2026-70405 is a medium severity vulnerability in Erlang/OTP's SNMP component caused by improper validation of the specified quantity in input. A remote attacker can send an SNMP message with a BER INTEGER whose length field is arbitrarily large, leading to excessive resource consumption during decoding. This can degrade system availability. The issue affects multiple OTP and SNMP versions prior to specific fixed releases.
CVE-2026-73270 is a high-severity vulnerability in Erlang/OTP's inets httpd module that improperly handles case sensitivity on case-insensitive filesystems. It allows remote unauthenticated attackers to bypass mod_auth directory protections by requesting files with different casing, leading to unauthorized file disclosure. This affects multiple OTP and inets versions prior to specific fixed releases. Case-sensitive filesystems are not affected.
CVE-2026-75538 is an integer overflow vulnerability in Erlang OTP's inet driver when using {packet,4} mode on an open TCP port. An attacker can trigger a signed overflow in packet length calculation, causing a buffer overflow that corrupts the BEAM VM allocator metadata and likely crashes the VM. Exploitation for remote code execution is considered extremely unlikely. This affects multiple OTP and erts versions prior to specific fixed releases.
CVE-2026-59696 is a medium severity vulnerability in Erlang/OTP's stdlib where improper validation of the port component in a URI allows a remote attacker to degrade service availability. The vulnerability arises because the function uri_string:get_port/1 converts a very long numeric port string to an integer without length bounds, causing excessive CPU consumption. This affects all applications parsing attacker-supplied URIs using uri_string:parse/1. The issue impacts OTP versions from 21.0 up to but not including 27.3.4.17, 28.0 up to 28.5.0.6, and 29.0 up to 29.0.6, as well as corresponding stdlib versions. No exploits are known in the wild, and no explicit patch links are provided in the data.
CVE-2026-71380 is a high-severity vulnerability in Erlang/OTP's inets httpd component that allows an unauthenticated remote attacker to cause a denial of service. The flaw arises from improper resource release after receiving partial HTTP request bodies with large Content-Length headers, leading to indefinite worker occupation. This affects multiple OTP and inets versions prior to specific fixed releases.