CVE-2026-92853

A missing bounds check in the TLS 1.3 Certificate-message parser of NetX Secure lets a malicious TLS 1.3 server trigger an unsigned-integer underflow and a subsequent heap out-of-bounds read in any peer that processes a remote Certificate message. It is reachable pre-authentication, during the normal handshake, before certificate verification completes.

When NetX Secure is built with `NX_SECURE_KEY_CLEAR`, every TLS record sent on an active session is wiped after it has been handed to TCP. By then the TCP layer owns the packet chain and may already have released it to the packet pool. The wipe therefore writes zeros into packets that are free or in use by another thread, and when a reused packet's pointers no longer describe the old data, the length of the wipe underflows and it runs past the end of the packet pool.

A vulnerability related to a predictable DTLS HelloVerifyRequest cookie in NetX Secure. The predictability of the cookie may allow an attacker to bypass the source address spoofing protection mechanism.

The X.509 parser in NetX Secure accepts an RSA public key of any size, but signature-verification paths decrypt into fixed-size buffers dimensioned for the NX_CRYPTO_MAX_RSA_MODULUS_SIZE default of 4096 bits. A certificate with a larger modulus causes an out-of-bounds write past a file-scope static during ordinary certificate-chain verification, reachable pre-authentication.

`_nx_secure_x509_parse_signature_data` computes the certificate signature's length as `tlv_length - 1` without first checking that `tlv_length` is non-zero. A certificate whose signature is an empty ASN.1 BIT STRING therefore parses successfully and leaves the certificate holding a signature length of `0xFFFFFFFF` and a signature pointer one byte past the end of the buffer. Certificates are parsed from the peer during the TLS handshake, so the input is remote and unauthenticated.

In the `_nx_secure_x509_asn1_tlv_block_parse()` function in NetX Secure, there is an out-of-bounds read. The function reads the ASN.1 tag byte before checking that the buffer holds at least one byte, causing a one-byte over-read when the remaining length is zero. This affects parsing of X.509 certificates supplied by a remote peer during the TLS handshake.

Two client-side TLS/DTLS handshake parsers in NetX Secure read fields from a server-supplied message before validating that the message is long enough to contain them. Both are bounded out-of-bounds reads on a remotely reachable path, both are reached from a TLS or DTLS client connecting to a malicious or malformed server, and both have the same shape: the bounds check exists and returns the correct status, but it runs after the read it is meant to guard.