Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify app exposing RFC 7111 fragment selector
-
ExploitSubmit oversized row= or col= range
-
ExecutionLibrary pre-allocates one slot per index
-
ImpactMemory 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
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.
Primary rating from Vendor (CPANSec).
CVSS VectorVendor: CPANSec
Lifecycle Timeline
3DescriptionCVE.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
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.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
The _compile function in Maketext.pm in the Locale::Maketext implementation in Perl before 5.17.7 does not properly hand
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
The VDir::MapPathA and VDir::MapPathW functions in Perl 5.22 allow remote attackers to cause a denial of service (out-of
Perl before 5.26.3 has a buffer overflow via a crafted regular expression that triggers invalid write operations. Rated
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
Silently incorrect regular-expression matching in the Perl interpreter (all versions through 5.43.9) lets an oversized a
Perl before 5.26.3 has a buffer over-read via a crafted regular expression that triggers disclosure of sensitive informa
Perl might allow context-dependent attackers to bypass the taint protection mechanism in a child process via duplicate e
CPAN.pm before 2.35 does not verify TLS certificates when downloading distributions over HTTPS. Rated high severity (CVS
The XSLoader::load method in XSLoader in Perl does not properly locate .so files when called in a string eval, which mig
In Perl through 5.26.2, the Archive::Tar module allows remote attackers to bypass a directory-traversal protection mecha
Perl before 5.30.3 on 32-bit platforms allows a heap-based buffer overflow because nested regular expression quantifiers
EUVD-2026-103192
GHSA-c8hf-63cr-rrfm
NVD
CVE.org
EPSS
Exploit-DB