Skip to main content

Text::CSV_XS CVE-2026-110755

| EUVDEUVD-2026-103195 HIGH
Inefficient Algorithmic Complexity (CWE-407)
2026-10-16 CPANSec GHSA-chcw-qm6q-pg64
7.5
CVSS 3.1 · Vendor: CPANSec
View

Attack ChainAIDerived

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

  1. Access
    Submit crafted CR-only CSV to import endpoint
  2. Delivery
    Application calls getline with default eol
  3. Exploit
    Parser recopies unparsed remainder per record
  4. Execution
    Quadratic CPU growth exhausts resources
  5. Impact
    Service degradation or denial

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
Exploitation Conditions

Exploitation requires the target application to parse attacker-controlled CSV via Text::CSV_XS getline() with the default eol (record separator) unset AND the input to use CR-only (classic Mac, \r) line endings, which causes the whole stream to arrive as a single chunk and triggers the per-record quadratic remainder copy. Limiting factors: input using LF or CRLF line endings is NOT affected (the patch's own tests confirm LF behaves normally); the application must expose getline() to untrusted/large CSV, and because cost scales with the square of input size, meaningful DoS requires the attacker to supply reasonably large input (seconds of CPU per megabyte, escalating with size). No authentication or user interaction is required by the library itself.

Impact

This is a genuine but modest-priority issue, best characterized as a high-CVSS, low-real-world-urgency denial-of-service. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) is availability-only, consistent with CWE-407 (algorithmic/quadratic complexity): no confidentiality or integrity impact. Exploitation signals are weak - EPSS is 0.19% (8th percentile), there is no CISA KEV listing, and no public weaponized exploit has been identified, so this is no public exploit identified at time of analysis (note the upstream patch ships a regression test that demonstrates the quadratic condition, but that is not an attack tool). The signals are internally consistent rather than conflicting: a low EPSS and absent KEV align with a non-RCE resource-exhaustion bug in a library. One metadata conflict stands out: the input Tag 'Information Disclosure' directly contradicts the CVSS (C:N) and CWE-407 - this is a CPU-exhaustion DoS, not a disclosure flaw, so treat that tag as erroneous. The A:H rating is defensible because the quadratic scaling means larger inputs (tens to hundreds of MB) escalate from seconds to minutes/hours of CPU, but single-request impact on a small file is limited; prioritize only where untrusted CSV is parsed with default options.

Exploit ScenarioDerived

An application that accepts user-supplied CSV (e.g. a file-upload or import endpoint) and parses it with Text::CSV_XS getline() using default options receives a file that uses classic Mac CR-only (\r) line endings. Because the default record separator leaves CR-only input as one chunk, the parser re-copies the entire unparsed remainder after every record, so a few megabytes of crafted input consume seconds-to-minutes of CPU and degrade or deny service. No public weaponized exploit exists, but the mechanism is fully disclosed and the patch includes a test reproducing the quadratic behavior.

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

Quadratic CPU consumption in Text::CSV_XS releases before 1.65 lets remote attackers exhaust CPU on Perl applications that parse attacker-supplied CSV through getline() with the default (unset) eol and classic Mac CR-only line endings. Because CR-only input arrives from Perl's default line reader as a single chunk, the parser re-copies the entire unparsed remainder after every record, so parsing cost grows with the square of the input size - seconds of CPU per megabyte and escalating rapidly with larger payloads. The CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (7.5), and EPSS is low at 0.19% (8th percentile); no public exploit code or CISA KEV entry has been identified at time of analysis, making this a high-scored but low-urgency availability issue.

RemediationAI

Vendor-released patch: Text::CSV_XS 1.65 - upgrade (cpanm Text::CSV_XS@1.65, or the distribution package such as libtext-csv-xs-perl once rebuilt to 1.65+) and restart any long-running Perl workers, since the module is loaded at process start. Distributors and vendors embedding the parser can apply the upstream commit directly (https://github.com/cpan-authors/Text-CSV_XS/commit/f25e00aacd6fc15857b22487cb2e5ca263f377e0.patch), which replaces the per-record tail copy with an in-place sv_chop() when _AHEAD already owns the remainder. If upgrading is not immediately possible, the most effective workaround is to construct the parser with an explicit eol (e.g. eol => "\n") so CR-only streams are not delivered as one chunk - the trade-off is that legitimate CR-terminated files will then be parsed differently or rejected, and embedded/newline handling changes. Alternatively, normalize or reject CR-only line endings at the ingestion boundary, enforce a maximum upload/stream size or read input in bounded chunks before parsing - this caps the quadratic blowup but may reject legitimately large files - or wrap parsing in an alarm/timeout (e.g. Perl's alarm or a SIGALRM handler) to bound CPU per request, with the side effect that slow but legitimate large imports can be aborted. The upstream regression test t/46_eol_si.t can be used to verify that a backported build no longer re-copies the remainder.

Affected ProductsAI

Text::CSV_XS (CPAN distribution by HMBRAND, packaged in many distributions as libtext-csv-xs-perl) versions before 1.65 are affected on all platforms. Exposure requires the calling application to use the default configuration, i.e. eol unset, and to feed attacker-controlled input through getline() or header() - the header() path hands its remainder over the same way and is covered by the same fix. Input using LF or CRLF line endings does not trigger the quadratic behavior, as the patch's own tests confirm, so only deployments that may receive CR-only (classic Mac) CSV are in scope. The vendor changelog for 1.65 is at https://metacpan.org/release/HMBRAND/Text-CSV_XS-1.65/changes and the public advisory is at https://seqlists.org equivalent, https://seclists.org/oss-sec/2026/q4/213; the NVD/EUVD record is https://nvd.nist.gov/vuln/detail/CVE-2026-110755 (EUVD-2026-103195).

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 Perl XS (C) extension binding the CSV_XS parser, one of the most widely deployed CSV parsers in the Perl ecosystem. The root cause is CWE-407 (Inefficient Algorithmic Complexity): when eol is left unset, getline() relies on Perl's default input record separator ($/ = "\n"), so a stream terminated only with CR (\r) is delivered to the parser as one large chunk rather than line by line. After emitting each record, the parser allocates a new SV containing the whole unparsed tail and stores it under the _AHEAD key; the next call parses from that buffer and copies the remaining tail again, producing O(n²) time and repeated large allocations. The upstream fix (commit f25e00aa) detects when _AHEAD already holds the remainder (same SV, refcount 1) and instead uses sv_chop() to discard the parsed prefix in place, making the operation linear; the accompanying regression test t/46_eol_si.t asserts the remainder is kept rather than re-copied and confirms LF input is unaffected. Note the supplied tag 'Information Disclosure' is inconsistent with the CWE and the assessed vector, which show availability impact only (C:N/I:N/A:H). No CPE strings were provided with this record; the affected component is the CPAN distribution Text-CSV_XS, which is also commonly packaged by Linux distributions as libtext-csv-xs-perl.

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

Attacker remotely supplies crafted CR-only CSV to a default-config reader with no auth or interaction; only CPU/availability is affected (A:H), with no confidentiality or integrity impact.

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 5.3 MEDIUM

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:07 cve.org
HIGH 7.5
CVE Published
Oct 16, 2026 - 22:07 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

Text::CSV_XS versions before 1.65 for Perl allow quadratic CPU use by copying the unparsed remainder per record of CR-only input in getline.

With eol unset, the default, getline reads with Perl's default line separator, so input with CR-only line endings arrives as one chunk. After each record the parser copies the whole unparsed remainder into a new buffer, which the next call parses and copies again, so the work grows with the square of the input size.

A reader with default options that is sent CSV with classic Mac line endings spends seconds of CPU time on a megabyte of input.

Executive ViewAI

Why It Matters

Perl applications that depend on the Text::CSV_XS module (releases before 1.65) are exposed to a CPU-exhaustion denial-of-service condition when parsing attacker-supplied CSV data that uses classic Mac CR-only line endings. The flaw is unauthenticated and remotely triggerable, so any service accepting external CSV input could be slowed or taken offline, degrading availability for customers and internal operations. Despite a HIGH CVSS score of 7.5, current exploitation likelihood is low-no public exploit identified at time of analysis and no CISA KEV entry-so leadership should treat this as a routine but important patch-management priority while confirming exposure across the Perl application estate.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 92% exploitable
Prevalence
Medium
popular Perl CSV library, but scoped to Perl apps parsing untrusted CSV
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

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