Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessClient connects to malicious NTS-KE server
-
DeliveryServer sends record with oversized declared length
-
ExploitTrigger out-of-bounds stack read in response parser
-
ExecutionLeaked pointers returned in cleartext NTS cookies
-
ImpactHarvest pointers to defeat client ASLR
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the NTPsec client (versions before 1.2.4) to initiate an NTS-KE handshake with an NTS-KE server the attacker controls - i.e., the client must be configured to use that server, or the attacker must impersonate a legitimate NTS-KE server with a TLS certificate the client trusts. The trigger is a server-supplied NTS-KE record whose declared length field exceeds the number of bytes actually received, which drives the parser to over-read client stack memory. Key limiting factors: NTS-KE runs over TLS, so a passive network position or plain MITM without a trusted certificate is insufficient; the data disclosed is low-value in itself (a stack over-read, no code execution) and is useful mainly to defeat ASLR when chained with another bug. No special condition is needed on the client beyond being an NTS client that connects to the malicious endpoint. |
| Impact | This is a genuinely low-priority finding, and the signals are consistent rather than conflicting. The CVSS 3.1 base score of 3.7 (AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N) describes a network-reachable but high-complexity information-disclosure bug with only low confidentiality impact and no integrity or availability impact, which matches the description: an out-of-bounds read (CWE-125) that leaks client stack memory. The vuln.today Decision label is 'monitor', the lowest urgency tier, and nothing contradicts it. There is no CISA KEV listing, so this is not confirmed as actively exploited; no EPSS score was supplied, so exploitation probability cannot be quantified from the input; and no public exploit code is identified - the three references are the NTPsec fix commit and two GitLab work items, not weaponized PoC. The one nuance worth flagging for defenders is that AV:N is technically correct but somewhat misleading in isolation: exploitation requires the victim client to establish an NTS-KE (TLS) session with an attacker-controlled server, which is a meaningful real-world precondition and is what justifies AC:H. The practical value of the leak is that disclosed pointers defeat ASLR, so its real risk is as a stepping stone for chaining with a separate memory-corruption bug, not as a standalone threat. |
| Exploit ScenarioDerived | A victim's NTPsec client (before 1.2.4) performs NTS key establishment against an NTS-KE server that the attacker controls or can impersonate over TLS. The malicious server returns an NTS-KE record whose declared length exceeds the bytes actually sent, causing the client parser to read past the buffer into adjacent stack memory, and the client then transmits those leaked bytes - including pointers that defeat ASLR - back in cleartext as NTS cookies for the attacker to harvest. No public exploit identified at time of analysis; the high attack complexity (AC:H) reflects that the victim must connect to the attacker's NTS-KE endpoint. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Out-of-bounds stack read in NTPsec's NTS-KE client response parser (nts_client_process_response_core) affects versions before 1.2.4 and lets a malicious NTS-KE server leak client stack memory - including pointers useful for defeating ASLR - which the client then transmits in cleartext as NTS cookies. Per the authoritative assessment, exploitation requires the NTPsec client to connect to an attacker-controlled NTS-KE server, either by configuration or by impersonating a legitimate server with a TLS certificate the client trusts, and NTS-KE's TLS layer blocks passive or certificate-less MITM attempts; impact is limited to low confidentiality with no code execution. No public exploit code is confirmed in the available data and the issue is not in CISA KEV, with the priority decision scored as monitor.
RemediationAI
Upgrade NTPsec to version 1.2.4 or later, which contains the upstream fix referenced by commit caf0eb5df3c6ddbfc2941389bff0f9146835c021 and tracked in https://gitlab.com/NTPsec/ntpsec/-/work_items/836 and https://gitlab.com/NTPsec/ntpsec/-/work_items/902. Because exploitation requires the client to perform an NTS-KE handshake with a server the attacker controls or impersonates with a TLS certificate the client trusts, exposure can be reduced in the interim by only configuring NTS-KE servers whose certificates are validated against a trusted CA and by avoiding untrusted or unauthenticated NTS-KE endpoints; note that this reduces but does not eliminate risk, since a compromised or attacker-obtained valid certificate still enables the over-read, and the disclosed data is low-value unless chained with another flaw. No vendor workaround beyond patching is documented in the supplied references.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
NTPsec implements Network Time Security (NTS), whose key establishment phase (NTS-KE) runs over TLS and negotiates cookies the client later presents to NTS-protected NTP servers. The flaw is a CWE-125 out-of-bounds read inside nts_client_process_response_core, the routine parsing NTS-KE response records: when a record's declared length field exceeds the bytes actually delivered, the parser reads past the received buffer into adjacent client stack memory. Because the over-read contents are subsequently echoed back to the server as NTS cookies in cleartext, a hostile NTS-KE server can harvest stack-resident pointer values that are useful primarily for defeating ASLR in combination with a separate memory-corruption flaw; the disclosure is informational in itself. Per the authoritative assessment, the trigger is specifically a length-field/data-length mismatch in a server-supplied record, and the attack path depends on TLS being established with the attacker's endpoint (client configured for it, or a trusted certificate held by the impersonator). The affected CPE range is ntpsec:ntpsec before 1.2.4, and the CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N vector reflects network reachability but high attack complexity with confidentiality-only, low impact.
Know when Ntpsec gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N
Victim must connect to an attacker-controlled NTS-KE server (AC:H) with no client privileges or user interaction (PR:N/UI:N); only a stack memory over-read is disclosed, so C:L with no integrity or availability impact.
Primary rating from Vendor (GitLab).
CVSS VectorVendor: GitLab
Lifecycle Timeline
1DescriptionCVE.org
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.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
An issue was discovered in NTPsec before 1.1.3. Rated critical severity (CVSS 9.1), this vulnerability is remotely explo
An issue was discovered in NTPsec before 1.1.3. Rated critical severity (CVSS 9.1), this vulnerability is remotely explo
An issue was discovered in NTPsec before 1.1.3. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploit
An issue was discovered in NTPsec before 1.1.3. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploit
Arbitrary shell command execution in gpsd's gpsprof profiling tool (through release-3.27.5) allows an attacker who contr
Remote denial of service in NTPsec ntpd 1.1.4 through 1.2.5 lets an unauthenticated network attacker crash the daemon by
Denial of service in NTPsec ntpd 1.1.4 through 1.2.5 allows a remote unauthenticated attacker to terminate the daemon by
ntpd will crash if the server is not NTS-enabled (no certificate) and it receives an NTS-enabled client request (mode 3)
Heap out-of-bounds read and write in NTPsec's NTS client extension-field parser (extens_client_recv) affects releases be
ntpkeygen can generate keys that ntpd fails to parse. Rated high severity (CVSS 7.4), this vulnerability is remotely exp
Heap-based memory corruption in NTPsec ntpd before 1.2.6 affects deployments that explicitly enable the non-default JJY
Out-of-bounds read in NTPsec ntpd before 1.2.6 can crash the daemon or disclose limited memory when an attacker controls
EUVD-2026-115826
GHSA-rjr3-53fv-wjrf
NVD
CVE.org
Exploit-DB