CVE-2026-102758
UnknownSummary
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.
Risk Assessment
A remote attacker can send a specially crafted certificate, causing an out-of-bounds memory read. This may lead to disclosure of sensitive data, denial of service, or potentially arbitrary code execution depending on the context.
Recommendation
Immediately update NetX Secure to a patched version that moves the tag read after the buffer length check. If patching is not possible, restrict trusted certificate sources and implement additional filtering mechanisms.
Other vulnerabilities in NetX Secure
See all- CVE-2026-102760High
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.
- CVE-2026-102728Unknown
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.
- CVE-2026-102719Medium
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.
Original NVD description (English source)
The `_nx_secure_x509_asn1_tlv_block_parse()` function parses ASN.1 TLV (tag-length-value) blocks out of DER-encoded data. It is the primitive underneath all X.509 certificate parsing in NetX Secure, and therefore runs on certificates supplied by a remote peer during the TLS handshake. The function reads the one-byte ASN.1 tag from the caller's buffer *before* checking that the buffer holds at least one byte. When a caller passes a remaining length of zero, the guard correctly returns `NX_SECURE_X509_ASN1_LENGTH_TOO_LONG`, but the read has already happened one byte past the end of the buffer. code: nx_secure/src/nx_secure_x509_asn1_tlv_block_parse.c ``` UINT _nx_secure_x509_asn1_tlv_block_parse(const UCHAR *buffer, ULONG *buffer_length, USHORT *tlv_type, USHORT *tlv_tag_class, ULONG *tlv_length, const UCHAR **tlv_data, ULONG *header_length) { UINT current_index; USHORT current_tag; ULONG length; ULONG length_bytes; current_index = 0; current_tag = buffer[current_index]; /* <-- read before the bounds check */ if (*buffer_length < 1) { return(NX_SECURE_X509_ASN1_LENGTH_TOO_LONG); } ``` The remainder of the function is correctly ordered. The multi-byte length path is guarded by `length_bytes > 4 || length_bytes > *buffer_length` before its read loop, the decoded value is checked against `length > *buffer_length`, and the second single-byte length read follows its own `*buffer_length < 1` guard. The tag read is the only load placed ahead of its check.
Vulnerability data from NVD (NIST) · CISA KEV · EPSS