Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted FITS file to victim
-
DeliveryVictim opens file in CFITSIO-linked application
-
ExploitRead of variable-length string column triggers ffgcls2
-
ExecutionOversized descriptor overflows 28,800-byte stack buffer
-
ImpactExecute arbitrary code
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that an application using CFITSIO (<= 4.7.0) read a variable-length string column (TFORM '1PA'/variable-length array) from an attacker-controlled FITS file, where the heap descriptor length field exceeds the 28,800-byte cbuff stack buffer; the pre-patch bounds check could be bypassed because ntodo*twidth could integer-overflow. Reaching the vulnerable ffgcls2() path requires the victim to open and read that specific column via the library (UI:P - passive user interaction). Limiting factors: no network vector (AV:L - the malicious file must be processed locally), exploitation is gated on the target application actually parsing variable-length string columns, and the affected product is a scientific library rather than a network-facing service. No privileges or authentication are required beyond getting the victim to process the file. |
| Impact | Severity signals are moderate-to-high and internally consistent. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P) correctly models this as a client-side file-parsing flaw: exploitation is local and requires a victim to process an attacker-supplied FITS file, not a remotely reachable service - so despite CWE-787 out-of-bounds write and VC/VI/VA:H (plausible RCE), this is not a wormable network bug. The vuln.today Decision label is 'this_week' (not act_now/emergency), aligning with that profile. Exploitation status: a public PoC reference exists (a GitHub gist), but it is not verified as working exploit code; the flaw is NOT in CISA KEV and there is no confirmed active exploitation. No EPSS score is provided in the input, so probabilistic exploitation likelihood cannot be quantified here - STATE EXPLICITLY: EPSS is missing. The source diff confirms the mechanism (an integer-overflow-prone bounds check, ntodo*twidth > sizeof(cbuff), was replaced with an overflow-safe division check), which raises confidence this is a real, patchable memory-corruption bug rather than a theoretical one. Net: a genuine high-severity library vulnerability warranting prompt patching for anyone processing untrusted FITS files, but lower real-world urgency than a network-exploitable CVE because it depends on local file handling and user interaction. |
| Exploit ScenarioDerived | An attacker crafts a malicious FITS file containing a variable-length string column ('1PA') whose heap descriptor advertises a length exceeding the fixed 28,800-byte stack buffer, then delivers it to a victim (e.g., as an astronomical dataset). When the victim opens or processes the file with any application linked against CFITSIO and reads that column (e.g., via ffgcvs/ffgcls2), the oversized descriptor is trusted and overflows the stack buffer and the caller's string array, enabling arbitrary code execution. A public PoC reference (gist) exists but is not verified as working exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 22, 2026
Out-of-bounds write in CFITSIO through 4.7.0 lets a crafted FITS file overflow both a fixed 28,800-byte stack buffer (cbuff) and the caller's string array when an application reads a variable-length string column, opening the door to arbitrary code execution in the victim process. The vulnerable path is ffgcls2() in getcols.c, which trusts heap-descriptor length values taken from the file instead of validating them against the destination buffer size. Exploitation is local in vector terms (CVSS:4.0/AV:L, CVSS:3.1/AV:L/AC:L/PR:N/UI:R) and requires the target application to actually parse a variable-length string column ('1PA'-style TFORM) from the file; no privileges are needed beyond inducing the victim to open the FITS file. A public PoC reference (a gist cited in the CVE record) exists but is not verified as working exploit code, EPSS/KEV data is absent, and the vendor has published an upstream fix in PR #184 (commit 579792e0f85bff0c6733ad5ebdf54c3b5c188686), which the vuln.today decision logic labels this_week.
RemediationAI
Apply the upstream fix in PR https://github.com/HEASARC/cfitsio/pull/184 / commit https://github.com/HEASARC/cfitsio/commit/579792e0f85bff0c6733ad5ebdf54c3b5c188686: this replaces the overflow-prone ntodo*twidth check in ffgcls2() (getcols.c) with twidth < 1 || ntodo < 1 || (size_t) ntodo > sizeof(cbuff)/twidth and adds the oversized-variable-length-string regression test. Patch status per the input is 'Available from vendor'; because the fix is published as a pull request and commit rather than a confirmed tagged release, rebuild and relink every application and pipeline component that links libcfitsio against a source tree containing that commit, and confirm the shipped library actually resolves to the patched build (statically linked tools keep the flaw until relinked). If an update cannot be deployed immediately, the exposure reduction that follows directly from the assessed prerequisites is to prevent untrusted FITS files from being processed by consumers that read variable-length string columns (TFORM such as '1PA') - for example by sandboxing or quarantining file-ingest pipelines and wrapping read calls so that failing ffgcvs() status codes abort the job; the trade-off is loss of functionality for legitimate variable-length string data, and it is a containment measure rather than a complete fix, as only the vendor's correction removes the out-of-bounds write.
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
CFITSIO is the reference C library (HEASARC/NASA) for reading and writing FITS files, the standard format in astronomy. FITS binary tables support variable-length array columns, whose per-row descriptors store a count and a width that the file itself supplies; ffgcls2() in getcols.c handles the string variant of those columns. Per the CWE-787 (out-of-bounds write) classification and the upstream diff, the pre-patch guard used the multiplication ntodo*twidth compared against sizeof(cbuff) - where cbuff is a fixed 28,800-byte stack buffer - so attacker-controlled values could drive that product past the intended limit via integer overflow (or otherwise satisfy the check while the real requirement was exceeded), after which data is written past the buffer and into the caller-supplied string array. The fix rewrites the validation to reject twidth < 1, ntodo < 1 and any case where (size_t) ntodo exceeds sizeof(cbuff)/twidth, replacing the overflow-prone multiplication with a division-based bound; the accompanying regression test (test_read_oversized_variable_length_string in tests/test_getcols.c) writes 28,801 bytes of 'A' into a 1PA column and asserts that ffgcvs()/ffgcvs()-style reads now fail with a non-zero status instead of corrupting memory. Because the flaw is reached through library calls made by a host application, exposure depends entirely on whether that application opens untrusted FITS files and reads variable-length string columns; the trigger is otherwise not described beyond the heap-descriptor length trust issue in the available sources.
Know when Cfitsio 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:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
File-parsing library flaw: AV:L and UI:R because a victim must process a crafted local FITS file; PR:N since no auth is needed; C/I/A:H reflecting arbitrary code execution.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
CFITSIO through 4.7.0 contains an out-of-bounds write vulnerability in ffgcls2() in getcols.c that trusts attacker-controlled heap descriptor lengths for variable-length string columns. Attackers can supply a crafted FITS file that overflows a fixed 28,800-byte stack buffer and the caller's string array, enabling arbitrary code execution.
Technical POC Analysis
CWE-787 out-of-bounds write in ffgcls2() in getcols.c (CFITSIO), the routine that reads a variable-length string column (TFORM of the P/1PA family) via ffgcvs().
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Latest POC
1 PoC candidate from github (unverified)
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
CVE-2026-115504 is a high-severity memory corruption flaw in the CFITSIO library, which is widely used in scientific and astronomical data processing. A crafted FITS file can trigger an out-of-bounds write when parsed, potentially allowing an attacker to execute arbitrary code within the context of the victim's application. This puts any organization that processes FITS files at risk, particularly research institutions and data-intensive teams; leadership should prioritize patching because a public proof-of-concept reference exists, even though it is not yet verified as working exploit code, and exploitation requires local access or user interaction to open a malicious file.
Apply 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.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Multiple exploitable buffer overflow vulnerabilities exist in image parsing functionality of the CFITSIO library version
In the ffghtb function in NASA CFITSIO 3.42, specially crafted images parsed via the library can cause a stack-based buf
In the ffghbn function in NASA CFITSIO 3.42, specially crafted images parsed via the library can cause a stack-based buf
In the ffgphd and ffgtkn functions in NASA CFITSIO 3.42, specially crafted images parsed via the library can cause a sta
Heap-based out-of-bounds read in the HCOMPRESS tile decoder of CFITSIO through 4.7.0 lets unauthenticated attackers trig
NASA CFITSIO prior to 3.43 is affected by: Buffer Overflow. Rated critical severity (CVSS 9.8), this vulnerability is re
CFITSIO through 4.7.0 contains a heap out-of-bounds read in its image decompression routines when processing a crafted F
EUVD-2026-108336
GHSA-wjcj-f49x-x56c
NVD
CVE.org
EPSS
Exploit-DB