Skip to main content

Excelize EUVDEUVD-2026-94530

| CVE-2026-107213 HIGH
NULL Pointer Dereference (CWE-476)
2026-10-07 GitHub_M GHSA-r7x5-4969-99p7
8.7
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Upload crafted XLSX with extLst but no drawing element
  2. Exploit
    Application invokes File.GetSlicers on the file
  3. Execution
    Nil ws.Drawing pointer dereferenced resolving drawing RID
  4. Impact
    Unrecovered panic crashes process (DoS)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Null pointer safety, defensive checks
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires ALL of: (1) the application uses Excelize version 2.9.0 through 2.11.0; (2) the application calls File.GetSlicers on a worksheet whose content is attacker-influenced; (3) the crafted worksheet XML contains a worksheet extLst element while the independently optional worksheet drawing element is absent (so ws.ExtLst is non-nil but ws.Drawing is nil); and (4) the hosting process is 'unprotected' - i.e. it does not wrap the call in a recover(), so the panic terminates it. Limiting factors: GetSlicers is not part of the default file-open/parse path, so an application that never calls it is not exposed; impact is limited to a crash (no code execution, data disclosure, or integrity loss); and any panic-recovery middleware neutralizes the DoS.

Impact

The signals are consistent but point to a moderate, impact-limited risk rather than a top priority. The provided CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N) with VA:H and VC:N/VI:N yields a high score (8.7) driven ENTIRELY by availability - this is a pure denial-of-service nil-pointer dereference (CWE-476), with no confidentiality or integrity impact. No EPSS score was provided, and the CVE is NOT in CISA KEV, so there is no evidence of active exploitation; exploitation status is 'no public exploit identified at time of analysis' (the GitHub artifacts are the vendor fix PR and a regression test, not weaponized exploit code). A key caveat on the CVSS vector: the AV:N / PR:N / UI:N rating assumes the vulnerable function is reachable with attacker-controlled input over a network without interaction, but the flaw is only triggered when an application explicitly calls File.GetSlicers on an attacker-supplied spreadsheet - real-world reachability is therefore application-dependent and narrower than AV:N/UI:N implies; verify against actual deployment. The single most aggravating factor is that, per the advisory, NO fixed version is available as of this review, so no clean upgrade path exists yet. Net: a legitimate DoS bug worth patching when a release lands, but not a drop-everything emergency given DoS-only impact, no known exploitation, and conditional reachability.

Exploit ScenarioDerived

A Go backend service built on Excelize 2.9.0-2.11.0 accepts user-uploaded .xlsx files and calls File.GetSlicers to enumerate slicers. An attacker uploads a crafted workbook whose worksheet contains an extLst element but no drawing element; when GetSlicers dereferences the nil ws.Drawing pointer, the process panics and the unprotected service crashes. No public exploit code was identified, but the trigger is trivial to construct and the fix PR/test publicly demonstrate the exact malformed structure.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 07, 2026

Denial of service in Excelize 2.9.0 through 2.11.0 allows a crafted spreadsheet to panic and terminate a Go process that calls File.GetSlicers. When a worksheet contains an extLst element but the independently optional drawing element is absent, GetSlicers dereferences the nil ws.Drawing pointer while resolving the drawing relationship, producing a runtime panic; the CVSS v4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H) indicates remote, unauthenticated triggering with high availability impact but no confidentiality, integrity, or scope impact. Exploitation is not confirmed to be occurring in real-world campaigns and no public exploit code has been identified at time of analysis, though the upstream fix commit and pull request are public, which lowers the bar for crafting a malicious XLSX; the independent assessment rates this as a moderate, impact-limited risk because GetSlicers is not part of the default file-open or parse path and any recover() wrapper neutralizes the crash.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed - the vendor reports no fixed version as of this review, so the practical remediation is to track and adopt the release that incorporates commit 8ffeb07ec9a350410f6922313f6b7e4f5cc79241 (PR #2434 in https://github.com/qax-os/excelize/pull/2434; advisory https://github.com/qax-os/excelize/security/advisories/GHSA-r7x5-4969-99p7), or vendor the one-line guard that changes the GetSlicers check to reject worksheets where ws.Drawing is nil as well as ws.ExtLst, so the function returns an empty result instead of dereferencing a nil pointer. If upgrading or patching immediately is not possible, the highest-value compensating control is to wrap every GetSlicers call in a recover() (or run ingestion of untrusted workbooks in an isolated worker/process that can restart), which converts the panic into a handled error with the trade-off of suppressed stack context unless logging is added; a second control is to avoid calling GetSlicers on attacker-controlled sheets entirely, or to pre-validate/normalize the worksheet XML so that any worksheet containing an extLst element also contains a drawing element, at the cost of rejecting or rewriting some otherwise valid files. Because GetSlicers is not invoked by default file-open or parse APIs, auditing call sites and confirming that no untrusted-input path reaches it removes exposure without any code change, and no network-side mitigation applies since the trigger travels inside the workbook file itself.

Affected VersionsENISA

excelize 2.9.0, ≤ 2.11.0

Affected Packages

go github.com/xuri/excelize/v2 fix: 2.11.1-0.20260929015830-8ffeb07ec9a3
euvd excelize_2_9_0 no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in go, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Excelize is a pure-Go library for reading and writing Microsoft Excel (XLSX/OOXML) files, widely embedded in backend services that ingest user-supplied spreadsheets. This is a CWE-476 null pointer dereference rooted in how the library models the OOXML worksheet schema: the internal xlsxWorksheet structure exposes both ExtLst (worksheet extension list) and Drawing (the worksheet drawing part reference) as independently optional elements. In File.GetSlicers, the code guarded only ws.ExtLst (checking ws.ExtLst nil) and then proceeded to read ws.Drawing.RID when resolving the drawing relationship for the slicer. A worksheet XML that carries an <extLst> element but omits the <drawing> element therefore leaves ws.ExtLst non-nil and ws.Drawing nil, so the dereference of ws.Drawing panics. In Go, an unrecovered panic aborts the process rather than returning an error, which converts a malformed-input condition into a process-level denial of service. The v2 CPE cpe:2.3:a:qax-os:excelize:*:*:*:*:*:*:*:* maps to the qax-os/excelize GitHub project across the affected 2.9.0-2.11.0 range. The upstream patch (commit 8ffeb07ec9a350410f6922313f6b7e4f5cc79241, PR #2434) simply extends the guard to 'if ws.ExtLst nil || ws.Drawing == nil', returning an empty slicer list instead of panicking, and adds a regression test that sets only ExtLst on the in-memory worksheet.

Know when Excelize 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 (GitHub_M) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

A crafted file processed by a network-facing app triggers an unrecovered nil-pointer panic with no privileges or interaction; impact is availability-only, hence C:N/I:N/A:H.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

DescriptionCVE.org

Excelize is a Go language library for reading and writing Microsoft Excel spreadsheets. From 2.9.0 to 2.11.0, GetSlicers checks for ExtLst but dereferences ws.Drawing without checking whether the independently optional drawing element exists. File.GetSlicers reads ws.Drawing.RID after seeing a worksheet extLst element even when the independently optional worksheet drawing element is absent. When a crafted worksheet contains an extLst element without a drawing element and the application calls GetSlicers, the nil ws.Drawing pointer is dereferenced while resolving the drawing relationship, allowing an attacker to panic and terminate an unprotected process. No fixed version is available as of this review.

Technical POC Analysis

CWE-476 (NULL pointer dereference) in github.com/xuri/excelize/v2, function (File).GetSlicers in slicer.go.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Excelize, a widely used Go library for Excel file processing, contains a denial-of-service vulnerability in versions 2.9.0 through 2.11.0 that can crash applications calling File.GetSlicers when processing a crafted spreadsheet. With no public exploit identified at time of analysis, the vulnerability is remotely triggerable without authentication and could disrupt availability of affected services. Leadership should ensure that any business-critical applications using GetSlicers on untrusted files implement mitigations or patch promptly once available.

Business Impact: Medium
Compensating Controls

Implement recover() wrappers around File.GetSlicers calls, enforce strict input validation to reject malformed XLSX files, avoid calling GetSlicers on untrusted spreadsheets, and monitor for vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 80% exploitable
Prevalence
Medium
popular open-source Go Excel library embedded in many backend apps
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High

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 No
EPSS 0.3%
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

A null pointer dereference occurs when a program attempts to access memory through a pointer that has been set to NULL (address 0x0).

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

CVE-2026-54063 HIGH POC
7.5 Jul 10

Denial of service in the Excelize Go library (github.com/xuri/excelize/v2, a.k.a. qax-os/excelize) before 2.11.0 allows

CVE-2026-107212 HIGH POC
7.5 Oct 07

Denial of service in the Excelize Go library (versions 2.1.0 through 2.11.0) allows an attacker-controlled spreadsheet t

CVE-2026-107221 MEDIUM POC
6.5 Oct 07

A crafted Excel (.xlsx) file can crash any Go application that parses it with Excelize 2.0.0 through 2.11.0 using a non-

CVE-2026-59161 HIGH POC
8.7 Jul 10

Uncontrolled memory and CPU consumption in Excelize (qax-os/excelize), the widely used Go library for reading and writin

CVE-2026-107211 HIGH
8.7 Oct 07

Go slice-bounds panic in the Excelize spreadsheet library versions 2.8.1 through 2.11.0 lets a crafted .xlsx workbook cr

CVE-2026-107219 HIGH
7.5 Oct 07

Denial of service in the Excelize Go library (versions 2.3.1 through 2.11.0) allows unauthenticated remote attackers to

CVE-2026-107217 HIGH
7.5 Oct 07

Denial of service in the Excelize Go spreadsheet library (github.com/xuri/excelize/v2 2.0.0-2.11.0 and github.com/xuri/e

CVE-2026-107216 HIGH
7.5 Oct 07

Uncontrolled recursion in the Excelize Go library (versions 2.8.1 through 2.11.0) allows a fatal Go stack overflow that

CVE-2026-107214 HIGH
7.5 Oct 07

Denial of service in Excelize versions 2.3.1 through 2.11.0 allows unauthenticated remote attackers to terminate the cal

CVE-2026-107215 HIGH
7.5 Oct 07

Memory exhaustion and runtime panic in the Excelize Go library (versions 2.3.1 through 2.11.0) let unauthenticated remot

CVE-2026-107223 HIGH
7.1 Oct 07

Resource exhaustion in the Excelize Go library (versions 2.1.0 through 2.11.0) lets a crafted .xlsx workbook drive exces

CVE-2026-59162 MEDIUM
6.9 Jul 10

Panic-triggering denial of service in the Excelize Go library (all versions prior to 2.11.0) allows any actor who can su

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