Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply CSV string ending in separator + lone CR
-
ExploitParser treats EOF as next byte
-
ExecutionEmpty last field receives spurious 0xFF
-
ImpactApplication ingests malformed/corrupted data
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Hardware access control granularity
|
| Exploitation Conditions | Triggers specifically when Text::CSV_XS->parse() (the in-memory string interface, NOT the useIO/getline streaming path, which the fix leaves untouched via 'unless (csv->useIO)') is given input that ends in a field separator immediately followed by a lone CR (0x0D) that is not part of a CRLF, AND the last field is empty - e.g. parse("a,\r"). The classic real-world trigger is a CRLF file read line-by-line and chomped (stripping the LF, leaving the bare CR) whose final column is empty. Non-empty last fields already error correctly and are unaffected. Limiting factors: the condition is narrow (empty trailing field + bare trailing CR), requires the string parse() API rather than getline, and the consequence is a corrupted byte/malformed UTF-8 rather than any control-flow or disclosure impact; versions 1.65 and later reject this input with error 2032. |
| Impact | The input CVSS 3.1 score of 9.8 (AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:H) is severely inflated relative to the actual defect. The described behavior is a parser correctness/data-integrity bug (CWE-1286): when parse() receives input ending in a separator plus a lone CR with an empty last field, Text::CSV_XS stores the EOF marker as a spurious 0xFF byte rather than reporting error 2032. This yields no code execution, no memory disclosure, and no inherent service outage - so the claimed C:H/I:H/A:H impact is not supported by the description. The other signals corroborate low real-world risk: EPSS is 0.19% (8th percentile), the CVE is NOT in CISA KEV, and the only 'proof' is the vendor's own regression test (t/97_parse_eof.t) in the patch, not a weaponized exploit. These signals conflict sharply with the 9.8 rating. No SSVC decision data was provided. Net: this is a high-CVSS-but-low-real-risk issue - a data-corruption edge case worth patching for integrity-sensitive pipelines, not an urgent RCE-class emergency. The spurious 0xFF can also produce malformed UTF-8 on upgraded strings, which could secondarily break downstream consumers, but that is a derived effect, not direct attacker-controlled impact. |
| Exploit ScenarioDerived | An application parses CSV with Text::CSV_XS->parse() on CRLF data that was read line-by-line and chomped, leaving a trailing lone CR; when the final column of the last record is empty, the parser returns a 0xFF byte that was never in the input, silently corrupting the field and producing malformed UTF-8 on UTF-8-flagged strings. The vendor's patch includes a regression test demonstrating the behavior (t/97_parse_eof.t), but no public weaponized exploit exists; realistic impact is data corruption in the consuming application rather than system compromise. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
Text::CSV_XS before 1.65 can inject a spurious 0xFF byte into parsed data when parse() is given a string ending in a field separator followed by a lone CR and the final field is empty, causing corrupted field values or malformed UTF-8. This affects the in-memory string parsing API in the Perl module, and an attacker who controls CSV input could alter application data integrity but cannot achieve code execution, confidentiality loss, or availability impact through this defect alone. No public exploit was identified at time of analysis, EPSS is 0.19% (8th percentile), and the independent assessment scores it CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N.
RemediationAI
Upgrade to Text::CSV_XS 1.65 or later, which rejects the malformed trailing-CR case with error 2032; the 1.65 ChangeLog is dated 2026-10-14 and is available at https://metacpan.org/release/HMBRAND/Text-CSV_XS-1.65/changes, with the upstream fix at https://github.com/cpan-authors/Text-CSV_XS/commit/7627f1a2bb8ffe4e81d9847318a060822043f7f3.patch. If upgrading is not immediately possible, avoid passing strings to parse() that end with a field separator followed by a lone CR when the last field is empty; ensure CRLF line endings remain intact or pre-screen and repair such inputs before parsing. Using the getline/useIO streaming interface avoids this specific non-useIO parse-path bug, at the cost of changing how data is supplied to the module. Applications can also validate returned fields for unexpected 0xFF bytes or malformed UTF-8, though that is a detection control rather than a fix.
Affected ProductsAI
Text::CSV_XS versions before 1.65 for Perl are affected. The vendor ChangeLog for 1.65 (https://metacpan.org/release/HMBRAND/Text-CSV_XS-1.65/changes) records the fix, and the upstream patch is commit 7627f1a2bb8ffe4e81d9847318a060822043f7f3 (https://github.com/cpan-authors/Text-CSV_XS/commit/7627f1a2bb8ffe4e81d9847318a060822043f7f3.patch). No CPE strings were supplied in the available data; the affected component is the Perl Text::CSV_XS distribution.
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 module for parsing and composing CSV. The bug is in the parser's handling of end-of-input after a separator: when the last field is empty and the input ends with a separator plus a bare CR (not CRLF), the parser advances past EOF and stores the end-of-file marker (0xFF) as a data byte. With binary enabled, parse("a,\r") yields fields "a" and "\xFF"; with UTF-8 flagged input, the last field is a UTF-8 flagged string containing the lone 0xFF byte, which is malformed UTF-8. A non-empty last field in the same shape (for example "a,b\r") already produces an error, and the fix adds ERROR_INSIDE_FIELD(2032) for the non-useIO parse path while leaving getline/useIO behavior unchanged. CWE-1286 (Improper Validation of Synthesized Input) captures the parser's failure to validate the field value it constructs from an EOF sentinel.
Know when the next one hits your stack
- 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
Sources disagree (Medium–Critical)AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
CSV input can be remotely supplied (AV:N) with no auth or interaction, but the only effect is a single spurious byte in an empty field, so C:N, I:L, A:N.
vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.
CVSS VectorVendor: CPANSec
Lifecycle Timeline
3DescriptionCVE.org
Text::CSV_XS versions before 1.65 for Perl return a 0xFF byte that is not in the input for an empty last field followed by a lone CR in parse.
When the input to parse ends in a separator and a lone CR, the parser treats the end of the input as the next character and stores the end-of-file marker in the field as the byte 0xFF. With binary set, parse("a,\r") returns the fields "a" and "\xFF". On UTF-8 flagged input the last field is a UTF-8 flagged string holding that lone byte, which is malformed UTF-8. The same input with a non-empty last field is rejected as an error.
A CRLF file read line by line and chomped ends this way when its last column is empty, so the application receives a byte that is not in its input.
Executive ViewAI
Text::CSV_XS, a widely deployed Perl module for CSV parsing, contains a data-integrity defect (CVE-2026-110759) that can silently corrupt parsed field values when applications process certain malformed inputs ending in a field separator, lone carriage return, and empty final field. Although the flaw carries a CRITICAL CVSS 9.8 rating, the independent vector reflects integrity-only impact with no code execution, confidentiality loss, or availability effect, and no public exploit identified at time of analysis. Leadership should care because affected data pipelines that ingest untrusted CSV-such as billing, reporting, or compliance feeds-could produce inaccurate records without visible errors, and the issue is unauthenticated to trigger via crafted input.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-103199
GHSA-v3f5-7p3g-9fm4
NVD
CVE.org
EPSS
Exploit-DB