Skip to main content

CFITSIO EUVDEUVD-2026-108336

| CVE-2026-115504 HIGH
Out-of-bounds Write (CWE-787)
2026-10-22 VulnCheck GHSA-wjcj-f49x-x56c
8.5
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Deliver crafted FITS file to victim
  2. Delivery
    Victim opens file in CFITSIO-linked application
  3. Exploit
    Read of variable-length string column triggers ffgcls2
  4. Execution
    Oversized descriptor overflows 28,800-byte stack buffer
  5. Impact
    Execute 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
1 PoC candidate (unverified) Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

CFITSIO 0 ≤4.7.0

Affected Packages

euvd cfitsio no fix

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

Vendor (VulnCheck) PRIMARY 8.5 HIGH
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
vuln.today AI 7.8 HIGH

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.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Red Hat 7.8 HIGH

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Low
de-facto FITS I/O library but confined to astronomy/scientific software
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC Yes
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

62
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy