CVE-2026-121505 in NTPsec
Summary
by MITRE • 11/03/2026
An out-of-bounds read in the NTS-KE client response parser (nts_client_process_response_core) in NTPsec before 1.2.4 allows a malicious NTS-KE server to read the client's stack memory, including pointers that defeat ASLR, which the client then sends in cleartext as NTS cookies, via an NTS-KE record whose declared length exceeds the data received.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 11/03/2026
The vulnerability identified within the Network Time Security Key Exchange protocol implementation of NTPsec prior to version 1.2.4 represents a critical memory safety failure located in the core response processing function nts_client_process_response_core. This flaw is classified as an out-of-bounds read, which falls under the Common Weakness Enumeration category CWE-125. The issue arises during the parsing of NTS Key Exchange records where the client validates incoming data from a server. Specifically, when a malicious NTS-KE server constructs a response record with a declared length field that exceeds the actual amount of data transmitted in the packet, the parser fails to perform adequate bounds checking before attempting to read or process the specified number of bytes. This discrepancy between the advertised payload size and the received buffer content triggers an access violation where the application reads beyond the allocated memory boundary into adjacent stack space.
The operational impact of this vulnerability is severe due to the specific nature of the data exposed through this out-of-bounds read. The NTPsec client inadvertently leaks sensitive information from its own process stack, including critical security pointers such as return addresses and function pointers. These values are subsequently embedded within Network Time Security cookies that are transmitted back to the server in cleartext during the key exchange handshake. This behavior directly facilitates an Information Disclosure attack, categorized under CWE-200, allowing a remote attacker to extract internal memory layouts from the victim system. The leakage of these pointers is particularly dangerous because it enables the attacker to bypass Address Space Layout Randomization, a fundamental operating system security feature designed to prevent code execution attacks by randomizing the memory locations where key data segments are loaded.
By obtaining valid stack addresses through this vulnerability, an adversary can perform precise analysis of the target process's memory layout. This capability significantly lowers the barrier for subsequent exploitation attempts, such as return-oriented programming or direct buffer overflow attacks, which rely on knowing exact memory offsets to achieve arbitrary code execution. The attack vector is remote and requires only network connectivity to the NTPsec service listening port, aligning with MITRE ATT&CK technique T1078 Valid Accounts if combined with credential theft, but primarily representing a reconnaissance phase where the attacker gathers intelligence about system defenses before launching more destructive payloads. This scenario highlights the risk of improper input validation in cryptographic protocol implementations, where malformed packets can lead to unintended memory exposure rather than just service disruption.
Mitigation for this vulnerability requires immediate upgrading of the NTPsec software suite to version 1.2.4 or later, where the parsing logic has been corrected to strictly enforce buffer boundaries and reject records with length fields that exceed available data. In environments where an upgrade is not immediately feasible, network-level controls such as firewalls should be configured to restrict inbound connections on the NTS-KE port to trusted sources only, thereby limiting exposure to untrusted or malicious servers. Additionally, deploying intrusion detection systems capable of identifying anomalous packet structures with mismatched length fields can provide a layer of defense against exploitation attempts while patching is underway. Developers implementing similar protocols should adhere to strict input validation practices and utilize memory-safe programming languages or static analysis tools to detect out-of-bounds access patterns during the software development lifecycle, ensuring that cryptographic implementations do not inadvertently leak sensitive internal state information through malformed inputs.