Unidata NetCDF-C CVE-2025-14935
HIGHAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious NetCDF file with oversized dimension name
-
DeliveryDeliver via email, web page, or shared dataset
-
ExploitVictim opens file in NetCDF-C-based application
-
ExecutionOverlong name copied into fixed-length heap buffer
-
PersistHeap overflow corrupts memory and hijacks control flow
-
ImpactExecute arbitrary code as current user
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 an attacker-supplied, malformed NetCDF file (or visit a page that serves one) using an application linked against the vulnerable NetCDF-C library; the trigger is a dimension name whose length exceeds the fixed-size heap buffer in the dimension-name parsing code. Limiting factors: mandatory user interaction (UI:R) - the file must be actively opened; the attack vector is local (AV:L), not a network-exposed service, so there is no unauthenticated remote-service exposure; and code executes only in the context of the current user (S:U, no privilege escalation). Risk is concentrated in workflows that automatically or routinely parse untrusted NetCDF/scientific data files; environments that never process externally sourced NetCDF files are largely unaffected. |
| Impact | This is a CWE-122 heap-based buffer overflow in NSF Unidata NetCDF-C's dimension-name parser, scored CVSS 7.8 (CVSS:3.0/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H). The vector is LOCAL (AV:L) despite the ZDI title calling it 'Remote Code Execution' - the 'remote' aspect is purely the file-delivery mechanism (victim opens a malicious .nc file or visits a page serving one), so real exploitation always requires user interaction (UI:R). This is a file-format/client-side RCE, not a network-listening service bug; treat it as such. EPSS is low at 0.35% (27th percentile), it is NOT on CISA KEV, and no public exploit code was identified in the provided sources - so there is no evidence of active or imminent widespread exploitation. The high CVSS is driven entirely by the full C:H/I:H/A:H impact of arbitrary code execution, not by ease or likelihood of mass exploitation. Net assessment: a genuine but conditional risk. It matters most for environments that routinely ingest untrusted NetCDF files (research/HPC/data pipelines), where it should be patched promptly; for most general enterprises it is a lower-urgency, patch-on-cycle issue rather than an emergency. Note the apparent tension to verify: title says 'Remote' but CVSS says AV:L - this is consistent once understood as a malicious-file bug, but defenders should not mistake it for an unauthenticated network RCE. |
| Exploit ScenarioDerived | An attacker crafts a malicious NetCDF file containing an overlong dimension name and delivers it via email, a download link, or a shared dataset repository. When a victim opens the file with an application built on NetCDF-C, the oversized name is copied into a fixed-length heap buffer, corrupting heap memory and allowing arbitrary code execution in the context of the current user. No public proof-of-concept was identified in the provided data; exploitation requires the victim to open the file (UI:R) and no special privileges (PR:N). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Heap-based buffer overflow in NSF Unidata NetCDF-C's dimension-name parsing allows code execution in the context of the current user when a victim opens a crafted NetCDF file or a page that serves one. The CVSS 7.8 vector is local (AV:L) with mandatory user interaction (UI:R) and no scope change (S:U), so exposure is concentrated in workflows that routinely parse untrusted scientific data rather than network services. No public exploit was identified at the time of analysis, and EPSS is low at 0.35% (27th percentile); the CPE has no version restriction, so NetCDF-C installations should be treated as potentially affected until a fixed release is confirmed.
RemediationAI
No vendor-released patch identified at time of analysis, and no exact fixed version is provided in the available data. Track the ZDI advisory at https://www.zerodayinitiative.com/advisories/ZDI-25-1154/ and NSF Unidata's release channel, then upgrade to the first NetCDF-C release that explicitly addresses ZDI-CAN-27168/CVE-2025-14935 once published and rebuild or relink dependent applications. Until then, apply specific compensating controls: disable automatic opening, preview, or thumbnail generation of untrusted .nc files and require explicit user action, which reduces the UI:R trigger but does not eliminate risk; pre-screen externally sourced NetCDF files by rejecting dimension names longer than the application's expected maximum or by validating file structure before handing them to libnetcdf, at the cost of rejecting some legitimate but unusually named datasets; and run parsing of untrusted files in a low-privilege sandboxed process or container with no access to sensitive files, accepting performance and integration overhead. Because exploitation is local and requires user interaction, restricting file associations and training users not to open unsolicited NetCDF files are practical interim measures.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is CWE-122, a heap-based buffer overflow in netCDF-C's parsing of dimension names. In the netCDF file format, dimension names are metadata read from the file and copied into a fixed-length heap buffer; the parser does not validate the supplied name length before the copy, so an oversized dimension name can overflow the allocation and corrupt heap metadata or adjacent objects. Because libnetcdf is embedded in many scientific, GIS, visualization, and data-analysis applications, the vulnerable code path is reached through normal file parsing rather than a listening service. The CVSS metrics AV:L/UI:R/PR:N/S:U mean exploitation requires the target to open a malicious file and yields code execution only as the current user, with no privilege escalation. The supplied CPE cpe:2.3:a:unidata:netcdf:-:*:*:*:*:*:*:* omits a version bound, so the available data does not narrow affected releases.
Know when Netcdf 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:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Malicious-file bug: AV:L and UI:R because a user must open the file, PR:N as no auth is needed, and C/I/A:H from arbitrary code execution as the current user.
Primary rating from Vendor (trendmicro).
CVSS VectorVendor: trendmicro
DescriptionCVE.org
NSF Unidata NetCDF-C Dimension Name Heap-based Buffer Overflow Remote Code Execution Vulnerability. This vulnerability allows remote attackers to execute arbitrary code on affected installations of NSF Unidata NetCDF-C. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file.
The specific flaw exists within the parsing of dimension names. The issue results from the lack of proper validation of the length of user-supplied data prior to copying it to a fixed-length heap-based buffer. An attacker can leverage this vulnerability to execute code in the context of the current user. Was ZDI-CAN-27168.
Executive ViewAI
NSF Unidata NetCDF-C, a library used to process scientific data, contains a high-severity heap buffer overflow that can let a crafted file execute code under the victim's user account. The exposure is concentrated in research, engineering, and data-science workflows that open untrusted NetCDF datasets, so leadership should treat affected analyst workstations and automated ingestion pipelines as the priority while no vendor patch is available.
No vendor-released patch identified; restrict opening untrusted NetCDF files, sandbox NetCDF parsing in a low-privilege process, apply least privilege, scan inbound files, and monitor for crashes or anomalous child processes until a fixed release is confirmed.
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.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Affected Products (CPE)CVE.org
Integer overflow in NSF Unidata NetCDF-C during parsing of NC variable definitions can lead to arbitrary code execution
Code execution in NSF Unidata NetCDF-C can be triggered when a user opens or processes a crafted NetCDF file containing
A stack-based buffer overflow in NSF Unidata NetCDF-C occurs when parsing a variable name longer than the library's fixe
Stack-based buffer overflow in NSF Unidata NetCDF-C's time-unit parsing routine allows arbitrary code execution at the p
NVD
CVE.org
EPSS
GitHub PoC
Exploit-DB