Vyper 0.4.0b1 through 0.5.0b1 miscompiles unfoldable constants and omitted default arguments from imported modules, because parse_Name resolves their names in the using function's scope rather than at declaration. When a contract's parameter, local, or loop variable shares such a name, attacker-influenced input can replace the intended value, including out-of-range values for narrow types such as uint8, corrupting validation or accounting logic.
Vyper versions 0.3.4 through 0.5.0b1 contain a vulnerability in the create_from_blueprint function where an unchecked uint256 subtraction can cause an integer wraparound. This allows an attacker controlling the code_offset parameter to deploy contracts with no runtime code, potentially trapping ETH and tokens.
Vyper 0.3.8 through 0.5.0b1 contains an optimizer miscompilation in which (msg.value | K) or (len(msg.data) | K), where K is any nonzero integer literal, is compiled to the constant 1 when used as a ternary expression branch under -O gas (the default) or -O codesize. Affected contracts use the wrong value in storage writes, arithmetic, indexes, return values, or events without warning or revert, which can record deposits incorrectly and lock funds.
Vyper versions from 0.1.0b1 up to but not including 0.1.0b17, and versions 0.4.1 through 0.5.0b1, have a vulnerability where the source-line table is built using str.splitlines(), which treats certain characters as line breaks differently than the Python parser. This discrepancy allows an attacker to hide special characters in comments, strings, or indentation to alter numeric literals silently.
Vyper 0.3.8 through 0.5.0b1 contains a compiler miscompilation vulnerability in parse_IfExp that reads nested arrays with narrower inner bounds using the wider result type's memory layout. When a ternary selects the narrower array, inner arrays after the first are read at wrong offsets, causing contracts to silently store corrupted values or revert.
Vyper versions 0.1.0b1 before 0.1.0b12, 0.1.0b14, and 0.4.1 through 0.5.0b1 have a vulnerability in the handling of Unicode encoding in the parsing of source code. The issue arises from mixing character-based line offsets with Python's UTF-8 byte column offsets, causing multi-byte characters to shift source slices used for reconstructing numeric literals. This allows an attacker to use non-ASCII identifiers that normalize to ASCII or invisible byte-order marks to silently substitute addresses, integers, or other constants in compiled code.
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.
CVE-2026-105274 is a low severity vulnerability in Erlang's rebar3, hex, and hex_core components involving improper handling of highly compressed data. An untrusted repository mirror or server can send a small compressed response that decompresses into a very large data structure, exhausting the Erlang VM memory before signature verification. This occurs because decompression and decoding steps do not limit the size of the decompressed or decoded data. The vulnerability affects rebar3 versions from 3.9.1 up to but not including 3.27.3, hex from 2.1.0 up to but not including 2.5.2, and hex_core from 0.1.0 up to but not including 0.20.0.
CVE-2026-103060 is a path traversal vulnerability in erlang rebar3 affecting versions from 3.7.0-rc1 up to but not including 3.27.2. It allows a malicious package publisher to delete directories outside the intended _build directory and extract package files there when dependencies are fetched. This occurs because rebar3 uses an unvalidated app field from package dependencies to construct directory paths, which can be manipulated to traverse directories. The vulnerability was publicly disclosed on 2026-10-12.
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.