Skip to main content

Text::CSV_XS EUVDEUVD-2026-103192

| CVE-2026-110752 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-10-16 CPANSec GHSA-c8hf-63cr-rrfm
7.5
CVSS 3.1 · Vendor: CPANSec
View

Attack ChainAIDerived

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

  1. Access
    Identify app exposing RFC 7111 fragment selector
  2. Exploit
    Submit oversized row= or col= range
  3. Execution
    Library pre-allocates one slot per index
  4. Impact
    Memory exhausted, process killed (uncatchable OOM)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
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

The affected application must pass a request-supplied (attacker-controlled) RFC 7111 fragment string to Text::CSV_XS's fragment() or csv() method using a row=, col=, or cell= range selector; the library then expands the selector into one array element per index before reading data, and does not clamp an explicit end column in a cell= selector to the row. Exploitation is LIMITED to deployments that route untrusted input into this fragment feature - libraries or applications that do not use RFC 7111 selectors, or that build selectors only from trusted values, are not exploitable. No authentication or user interaction is required by the library itself (PR:N/UI:N per CVSS). A notable aggravating factor: the Out-of-memory failure terminates the process and cannot be caught by Perl eval, so application-level exception handling is not a mitigation - only upgrading to 1.65 or validating/bounding selector ranges before use is.

Impact

This is a genuine but conditional availability risk, not a top-tier emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/C:N/I:N/A:H, score 7.5) reflects a pure denial-of-service: no confidentiality or integrity impact, only process termination via memory exhaustion (CWE-770). The signals are internally consistent on impact but diverge on likelihood: EPSS is very low (0.19%, 8th percentile) and the CVE is NOT on CISA KEV, indicating no observed or probable widespread exploitation. There is no standalone weaponized exploit, although the vendor patch ships a regression test that demonstrates the exact trigger (row=1-400000000 on a two-line file). The AV:N rating is defensible only because the vulnerable fragment/csv selector can be request-supplied by a web-facing application - but exploitability hinges entirely on whether an application actually routes untrusted input into the RFC 7111 fragment selector, which is NOT the default or common usage pattern for this library. An aggravating factor noted in the description: the resulting Out-of-memory error ends the process and cannot be caught by Perl eval, so defensive exception handling does not mitigate it. Net: prioritize patching for any Perl service that exposes CSV fragment selectors to untrusted input; for all other deployments this is low urgency.

Exploit ScenarioDerived

A Perl web application lets users specify an RFC 7111 fragment (e.g. a row/column range) and passes it straight to Text::CSV_XS fragment() or csv(). An attacker submits a selector such as row=1-400000000, causing the library to pre-allocate one array element per selector index - roughly 400 million entries - before reading any data, exhausting memory and killing the worker process with an uncatchable Out-of-memory error. No public weaponized exploit exists, but the vendor's own patch includes a regression test proving the condition.

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

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

Alert me

AnalysisAIv1 – Oct 20, 2026

Memory exhaustion in the Perl Text::CSV_XS library before version 1.65 allows remote attackers to terminate a process by supplying an oversized RFC 7111 fragment selector. The fragment() and csv() methods expand row=, col=, and cell= selectors into one array element per requested index before any data is read, so a selector such as row=1-400000000 against a two-line file allocates 400 million elements and ends the process with an out-of-memory error that Perl's eval cannot catch. Only applications that pass request-supplied fragment strings into this feature are affected; no public exploit code or confirmed active exploitation was identified at time of analysis, and EPSS is low at 0.19% (8th percentile).

RemediationAI

Upgrade to Text::CSV_XS 1.65 or later, which implements the upstream fix: ranges are kept as [from, to] pairs and tested by membership instead of being expanded into one element per index, and explicit end columns in cell= selectors are clamped to the row width. Install via cpanm Text::CSV_XS@1.65 or your distribution's updated package, then verify the loaded version with perl -MText::CSV_XS -e 'print $Text::CSV_XS::VERSION'. If upgrading is not immediately possible, do not pass attacker-controlled fragment strings into fragment() or csv(); where selectors must remain user-driven, validate them against an allowlist and reject or truncate any row=, col=, or cell= range whose bounds exceed the known dimensions of the data set, and cap the total number of requested indices before the call. Note that wrapping the call in eval is not a viable mitigation because the Out of memory abort terminates the process and cannot be trapped; process-level supervision and memory limits (for example, ulimit -v or container memory caps) will convert the crash into a controlled restart but do not prevent the denial of service. Refer to the vendor change log at https://metacpan.org/release/HMBRAND/Text-CSV_XS-1.65/changes and the patch at https://github.com/cpan-authors/Text-CSV_XS/commit/d9d3d66f9ff6a8a1bc255a6ef05100f9b102b92b.patch for details.

Affected ProductsAI

All versions of the Perl Text::CSV_XS module prior to 1.65 are affected whenever the fragment() or csv() methods process an untrusted RFC 7111 selector; the flaw resides in the fragment expansion logic in CSV_XS.pm. The fixed release is Text::CSV_XS 1.65 by HMBRAND, documented at https://metacpan.org/release/HMBRAND/Text-CSV_XS-1.65/changes, with the code change visible in https://github.com/cpan-authors/Text-CSV_XS/commit/d9d3d66f9ff6a8a1bc255a6ef05100f9b102b92b.patch. Deployments that never call fragment()/csv() with selectors, or that construct selectors only from trusted constants, are not exposed regardless of installed version. Distribution-level packages (Debian, Fedora, cpanm-installed copies, and vendored dependencies of Perl web applications) should be inventoried for versions below 1.65; consult https://seclists.org/oss-sec/2026/q4/213 and https://nvd.nist.gov/vuln/detail/CVE-2026-110752 for vendor tracking.

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

Text::CSV_XS is a fast XS-backed Perl module for parsing and writing CSV, and its fragment() method (also reachable through csv()) accepts RFC 7111 URI fragment selectors - row=, col=, cell=, with ranges, wildcards, and semicolon-separated lists - to project specific rows and columns out of a CSV stream. The root cause is CWE-770 (Allocation of Resources Without Limits or Throttling): the pre-1.65 implementation validated only the syntax and ordering of ranges, then materialised the selector by writing one array element per integer in the range ($r[$_] = 1 for $from .. $to) before reading any row data, and it failed to clamp an explicit end column in a cell= selector to the actual width of the row. Memory consumption therefore scaled with the numbers written into the selector rather than with the size of the CSV input. Because the allocation is attempted up front, the failure mode is a hard Out of memory process abort rather than a catchable Perl exception. The upstream fix (commit d9d3d66f9ff6a8a1bc255a6ef05100f9b102b92b, released in 1.65) stops materialising indices, storing ranges as [from, to] pairs and testing membership per row or column with a running maximum bound, and clamps explicit column ends to the parsed row width so col=1-9 returns only the four fields actually present. New tests in t/78_fragment.t exercise row=1-400000000 and cell=1,1-1,400000000 under a ulimit -v of 512 MB to confirm memory now tracks the data, not the selector.

Know when Perl 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 (CPANSec) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Selector can be request-supplied so AV:N/AC:L/PR:N/UI:N; impact is solely process-killing memory exhaustion, hence C:N/I:N/A:H and S:U.

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
Red Hat 7.5 HIGH

Primary rating from Vendor (CPANSec).

CVSS VectorVendor: CPANSec

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

3
CVSS changed
Oct 20, 2026 - 19:22 NVD
7.5 (HIGH)
CVE Published
Oct 16, 2026 - 22:06 cve.org
HIGH 7.5
CVE Published
Oct 16, 2026 - 22:06 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

Text::CSV_XS versions before 1.65 for Perl allow memory exhaustion by allocating one entry per index of an RFC 7111 selector in fragment.

fragment expands a row= or col= selector into an array with one element per selected index before it reads any data, and it does not clamp an explicit end column in a cell= selector to the row. Only the syntax and order of the ranges are checked, so row=1-400000000 on a two-line file allocates 400 million elements.

An application that passes a request-supplied fragment to fragment or csv can be made to exhaust memory, which ends the process with an Out of memory error that eval cannot catch.

Executive ViewAI

Why It Matters

Text::CSV_XS versions before 1.65 contain a memory-exhaustion flaw that can terminate a process when applications pass attacker-supplied fragment selectors, creating a targeted availability risk. Only applications that expose this library's fragment() or csv() selector handling to request input are affected, and no public exploit identified at time of analysis keeps the current likelihood low. Leadership should prioritize inventory and upgrade because the flaw can cause service disruption in impacted Perl applications.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 92% exploitable
Prevalence
Medium
popular CPAN CSV parser, but fragment feature rarely exposed to untrusted input
Social Media
1
Sightings
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 No
EPSS 0.2%
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
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
Medium

Priority Score

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

Attack Technique

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

More in Perl

View all
CVE-2012-6329 HIGH POC
7.5 Jan 04

The _compile function in Maketext.pm in the Locale::Maketext implementation in Perl before 5.17.7 does not properly hand

CVE-2017-12814 CRITICAL POC
9.8 Sep 28

Stack-based buffer overflow in the CPerlHost::Add method in win32/perlhost.h in Perl before 5.24.3-RC1 and 5.26.x before

CVE-2015-8608 CRITICAL POC
9.8 Feb 07

The VDir::MapPathA and VDir::MapPathW functions in Perl 5.22 allow remote attackers to cause a denial of service (out-of

CVE-2018-18314 CRITICAL POC
9.8 Dec 07

Perl before 5.26.3 has a buffer overflow via a crafted regular expression that triggers invalid write operations. Rated

CVE-2018-18312 CRITICAL POC
9.8 Dec 05

Perl before 5.26.3 and 5.28.0 before 5.28.1 has a buffer overflow via a crafted regular expression that triggers invalid

CVE-2026-13221 CRITICAL POC
9.1 Jul 13

Silently incorrect regular-expression matching in the Perl interpreter (all versions through 5.43.9) lets an oversized a

CVE-2018-18313 CRITICAL POC
9.1 Dec 07

Perl before 5.26.3 has a buffer over-read via a crafted regular expression that triggers disclosure of sensitive informa

CVE-2016-2381 HIGH
7.5 Apr 08

Perl might allow context-dependent attackers to bypass the taint protection mechanism in a child process via duplicate e

CVE-2023-31484 HIGH POC
8.1 Apr 29

CPAN.pm before 2.35 does not verify TLS certificates when downloading distributions over HTTPS. Rated high severity (CVS

CVE-2016-6185 HIGH POC
7.8 Aug 02

The XSLoader::load method in XSLoader in Perl does not properly locate .so files when called in a string eval, which mig

CVE-2018-12015 HIGH POC
7.5 Jun 07

In Perl through 5.26.2, the Archive::Tar module allows remote attackers to bypass a directory-traversal protection mecha

CVE-2020-10543 HIGH
8.2 Jun 05

Perl before 5.30.3 on 32-bit platforms allows a heap-based buffer overflow because nested regular expression quantifiers

Vendor StatusVendor

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