Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious RINEX file (>64 sats/epoch)
-
DeliveryDeliver file to victim or pipeline
-
ExploitVictim opens file in rnx2rtkp/RTKPOST
-
Executionreadrnxobsb skips satellite-count clamp
-
PersistHeap overflow write and OOB stack read
-
ImpactApplication crash / denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
MITRE ATT&CK
1 technique across 1 tactic: Execution 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 victim to open or process an attacker-crafted RINEX observation file (UI:P - passive user interaction is mandatory; this is not a remotely triggerable network service). The specific trigger is a RINEX epoch header declaring a satellite count greater than 64 satellites per epoch, which the readrnxobsb function in src/rinex.c fails to clamp. Limiting factors: the attacker cannot self-trigger - a user or an automated pipeline must ingest the malicious file; impact is confined to availability (application crash/DoS, VA:H) with no confidentiality or integrity loss; and only RTKLIB-based consumers of the RINEX observation parser (e.g., rnx2rtkp, RTKPOST) up to 2.4.3 are affected. No authentication is required of the attacker to craft the file (PR:N), but reachability depends on the victim accepting untrusted RINEX input. |
| Impact | Signals are consistent and point to a real but bounded (denial-of-service) risk rather than a critical RCE. The CVSS 4.0 vector AV:N/AC:L/AT:N/PR:N/UI:P scores 7.1 (High) but the impact metrics confirm only availability damage (VC:N/VI:N/VA:H) - meaning crash/DoS, not code execution or data disclosure, despite the heap-overflow primitive. UI:P (passive user interaction) means a victim must open or process the attacker-supplied RINEX file, which limits mass automated exploitation. A public POC exists (GitHub issue #796, flagged as exploit by VulnCheck), raising the practical likelihood of crash exploitation, but there is no KEV listing and no EPSS score provided, and no evidence of active exploitation. Note a vector ambiguity: AV:N is assigned, yet exploitation is fundamentally file-parsing - the 'network' vector reflects that malicious RINEX files are typically distributed/downloaded, not a listening network service; verify the deployment path before treating this as remotely reachable without user action. Net priority is moderate: patch on a normal cycle unless RTKLIB processes untrusted third-party RINEX data in an automated pipeline. |
| Exploit ScenarioDerived | An attacker crafts a RINEX observation file whose epoch header declares more than 64 satellites and delivers it to a victim (for example via a shared dataset, email, or a download in an automated processing pipeline). When the victim opens or batch-processes the file with rnx2rtkp or RTKPOST, readrnxobsb overflows the heap buffer and performs out-of-bounds reads, crashing the application. Public exploit code referenced by VulnCheck (GitHub issue #796) demonstrates the trigger. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 25, 2026
Denial-of-service memory corruption in RTKLIB through version 2.4.3 lets an attacker crash GNSS post-processing applications such as rnx2rtkp and RTKPOST by supplying a malicious RINEX observation file. The readrnxobsb function in src/rinex.c fails to clamp the satellite-count value read from RINEX epoch headers, so a file declaring more than 64 satellites per epoch triggers a heap buffer overflow write and out-of-bounds stack reads. Publicly available exploit code exists (VulnCheck/GitHub issue #796); there is no public exploit identified as actively exploited, and the CVSS 4.0 impact is limited to availability (VA:H).
RemediationAI
No vendor-released patch version is identified at time of analysis; the upstream reference (https://github.com/tomojitakasu/RTKLIB/issues/796) is an issue report rather than a tagged release or merged fix commit, so monitor that issue and the RTKLIB repository for a patched build and upgrade as soon as one is published. As compensating controls, do not process RINEX observation files from untrusted or unauthenticated sources, and validate or pre-screen input files to reject epochs declaring more than 64 satellites before passing them to rnx2rtkp/RTKPOST (trade-off: requires an external pre-parser and may reject legitimately malformed-but-benign files). Run RTKLIB post-processing in a sandboxed or low-privilege context so that a crash cannot disrupt other workloads, and review the VulnCheck advisory (https://www.vulncheck.com/advisories/rtklib-heap-buffer-overflow-and-stack-read-via-oversized-rinex-epoch-satellite-count) for any updated fix guidance.
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
RTKLIB is an open-source GNSS (GPS/GLONASS/Galileo/BeiDou) positioning and post-processing library and toolkit authored by Tomoji Takasu, widely used in surveying, geodesy, and precise-positioning research. The affected component is the RINEX (Receiver Independent Exchange Format) observation-file parser in src/rinex.c. The vulnerability is CWE-122 (heap-based buffer overflow): readrnxobsb reads the per-epoch satellite count directly from attacker-controlled header fields and uses it to index/iterate into fixed-size buffers sized for the RINEX limit of 64 satellites per epoch, without validating or clamping the value. A declared count above 64 causes writes past the end of the heap allocation and out-of-bounds reads on the stack. The single affected product per CPE is cpe:2.3:a:tomojitakasu:rtklib:*:*:*:*:*:*:*:* across all versions up to and including 2.4.3.
Know when Rtklib 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Attacker-supplied file but victim must open it (UI:R); no auth to craft (PR:N); impact is crash only, so C:N/I:N/A:H with unchanged scope.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
RTKLIB through 2.4.3 contains a heap buffer overflow vulnerability in the readrnxobsb function in src/rinex.c that allows attackers to trigger memory corruption by failing to clamp satellite count values from RINEX epoch headers. Attackers can craft malicious RINEX files declaring more than 64 satellites per epoch to cause heap buffer overflow writes and out-of-bounds stack reads, crashing RTKLIB-based applications including rnx2rtkp and RTKPOST.
Executive ViewAI
RTKLIB, a GNSS post-processing platform used by surveying and positioning organizations, contains a denial-of-service vulnerability (CVE-2026-56789, CVSS 7.1) with publicly available exploit code. The flaw allows attackers to crash critical post-processing applications via malicious satellite observation files; no vendor patch is currently available, creating operational risk for organizations dependent on RTKLIB.
No vendor-released patch identified at time of analysis. Implement: (1) Source restriction-accept RINEX files only from verified, trusted suppliers; (2) Input validation-apply satellite count validation (≤64) at file intake to prevent malformed files from reaching processing applications; (3) Sandboxing-run RTKLIB in containerized environments with strict resource and privilege limitations to contain crash impact; (4) Monitoring-deploy application-level alerting for RTKLIB process failures and implement restart automation to minimize downtime.
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.
A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.
Out-of-bounds write in RTKLIB's decode_type1033 function affects all versions through 2.4.3, where unclamped length coun
Off-by-one out-of-bounds read in RTKLIB's decode_ssr3 function (src/rtcm3.c:1446) allows unauthenticated remote attacker
Out-of-bounds read in RTKLIB through 2.4.3 exposes users to denial of service and potential memory disclosure when proce
EUVD-2026-39531
GHSA-3fqf-8h5x-pq8x
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB