NetCDF-C
CVE-2025-14936
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver malicious NetCDF file to victim
-
ExploitVictim opens file in NetCDF-C app
-
ExecutionOverlong attribute name overflows stack buffer
-
ImpactExecute code as current user
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Stack 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 NetCDF file (or visit a page that triggers such processing) using an application built on NetCDF-C; the attacker must supply a file whose attribute name exceeds the fixed-length stack buffer. Key LIMITING factors confirmed by the CVSS vector: the vector is local (AV:L) - there is no listening network service to attack directly - and user interaction (UI:R) is mandatory, so the victim must be induced to open the malicious file. No special NetCDF configuration is cited as required; the flaw is in core attribute-name parsing. Code executes only with the privileges of the user running the parser, limiting impact on properly least-privileged accounts. Exact affected/fixed versions are not confirmed from the available data. |
| Impact | This is a stack-based buffer overflow (CWE-121) in NetCDF-C's attribute-name parsing, carrying a CVSS 3.0 base of 7.8 (HIGH). Critically, the vector is AV:L/UI:R, NOT network-exploitable: despite the title calling this a 'Remote Code Execution' flaw and the description saying 'remote attackers,' the CVSS vector confirms exploitation requires local processing of attacker-controlled data (opening a malicious file or loading a malicious dataset) plus victim interaction. This is the standard ZDI framing for client-side file-parsing bugs and should not be read as a server-side remote exploit. Exploitation signals are modest: EPSS is low at 0.35% (27th percentile), there is no CISA KEV listing, and no public exploit code is referenced - only the ZDI advisory. No SSVC decision data was provided. Net assessment: this is a genuine code-execution bug worth patching on systems that ingest untrusted NetCDF files, but it is NOT an urgent internet-facing emergency - the local vector, required user interaction, and low EPSS all point to opportunistic or targeted file-delivery risk rather than mass exploitation. Prioritize for workstations and pipelines that parse third-party scientific data; deprioritize relative to true unauthenticated network RCEs. |
| Exploit ScenarioDerived | An attacker crafts a malicious NetCDF file containing an overly long attribute name and delivers it to a victim (e.g., via email, a shared dataset repository, or a download link). When the victim opens or processes the file with a NetCDF-C-based application, the oversized attribute name overflows a fixed-length stack buffer, enabling arbitrary code execution in the context of the current user. No public proof-of-concept is referenced at time of analysis, and exploitation hinges on the victim choosing to open the attacker-supplied file. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Code execution in NSF Unidata NetCDF-C can be triggered when a user opens or processes a crafted NetCDF file containing an oversized attribute name; the flaw is a stack-based buffer overflow (CWE-121) in attribute-name parsing. The assessed CVSS 3.0 score is 7.8 with AV:L/PR:N/UI:R, so attack delivery is local and requires user interaction, and no public exploit code or CISA KEV entry was identified at time of analysis (EPSS 0.35%).
RemediationAI
No vendor-released patch was identified at time of analysis. Confirm fix status through the ZDI advisory ZDI-25-1155 (https://www.zerodayinitiative.com/advisories/ZDI-25-1155/) and NSF Unidata release channels. Until a patched version is available, avoid opening or processing untrusted NetCDF files with NetCDF-C-based tools; pre-screen files with an independent hardened parser or header inspection that rejects attribute names exceeding expected bounds (trade-off: may reject legitimate long attribute names and requires ongoing maintenance). Run parsing workloads in a low-privilege sandbox or container with seccomp/AppArmor restrictions and no unnecessary network or filesystem access (trade-off: operational overhead and possible compatibility issues). Enforce file provenance controls and user awareness to reduce the mandatory user-interaction trigger, and monitor for vendor updates so patched builds can be tested and deployed promptly.
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
NetCDF-C is the C reference implementation of the NetCDF scientific data format, used by applications that read and write array-oriented scientific data. CWE-121 indicates a stack-based buffer overflow: the parser copies a user-supplied attribute name into a fixed-length stack buffer without first validating its length, so an overly long name overwrites stack memory and can redirect execution. Because the flaw is in core attribute-name parsing, any application linked against an affected NetCDF-C build that opens attacker-controlled files can serve as a vector. The supplied CVSS vector is local (AV:L) with user interaction (UI:R), meaning there is no direct listening-service exploitation path; delivery is via a malicious file or a page that causes file processing. The issue was reported through ZDI as ZDI-CAN-27269 and published as ZDI-25-1155.
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
AV:L and UI:R because exploitation requires the victim to locally open a crafted file; PR:N since no authentication is needed, and C/I/A:H reflect full user-context code execution.
Primary rating from Vendor (trendmicro).
CVSS VectorVendor: trendmicro
DescriptionCVE.org
NSF Unidata NetCDF-C Attribute Name Stack-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 attribute 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 stack-based buffer. An attacker can leverage this vulnerability to execute code in the context of the current user. Was ZDI-CAN-27269.
Executive ViewAI
NSF Unidata NetCDF-C contains an unpatched stack-based buffer overflow that can enable code execution on systems where users open crafted NetCDF files. Because NetCDF-C is widely used in scientific, engineering, and analytics workflows, a malicious dataset could compromise a user workstation and expose data or credentials, although exploitation requires local file opening and user interaction. At time of analysis, no public exploit identified at time of analysis.
No vendor-released patch identified at time of analysis; interim mitigations include blocking untrusted NetCDF files, validating attribute-name lengths before parsing, sandboxing or containerizing NetCDF processing, applying least privilege, and monitoring NSF Unidata and CISA advisories for a vendor patch.
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 stack-based buffer overflow occurs when a program writes more data to a buffer located on the stack than it was allocated to hold.
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
Heap-based buffer overflow in NSF Unidata NetCDF-C's dimension-name parsing allows code execution in the context of the
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