# GHSA-R7W7-VPQ8-C5VV: mail-parser is vulnerable to polynomial ReDoS in email header parsing

- Database: GitHub
- Severity: high (stated by ghsa, no CVSS score)
- Published: 2026-11-16
- Modified: 2026-11-16

## Tracked as

- [CVE-2026-129295](https://cve.now/CVE-2026-129295.md): mail-parser denial of service in email header parsing

## Affected versions

- mail-parser (PyPI): from 4.2.0, fixed in 4.6.1

## Description

### Summary

Two regular expressions used while parsing email headers backtrack
polynomially on attacker-controlled input. Parsing a single small, well-formed
email can consume minutes to hours of CPU, denying service to any process that
parses untrusted mail.

Both are reachable from an ordinary `parse_from_string()`, `parse_from_bytes()`
or `parse_from_file()` call — no special API, option, or malformed structure is
required by the victim.

### Details

**1. Address-header fallback regex (`src/mailparser/utils.py`)**

`get_addresses()` falls back to `_ADDR_FALLBACK_RE` whenever
`email.utils.getaddresses(strict=True)` yields no usable address. The
alternative `([^<,]*?)\s*<([^>]+)>` overlaps a lazy quantifier with an adjacent
`\s*` — a space matches both. Driven by `finditer`, which retries at every
offset and rescans the remainder, matching degrades to **quadratic** on `<`
padding and **cubic** on whitespace padding.

The fallback engages on the feature's own happy path, e.g.
`From: alice@example.com <bob@example.com>`.

Measured (4.6.0, CPython 3.14, macOS arm64; reproduced identically on Linux and
on CPython 3.9, 3.11, 3.12, 3.13):

| Padding                | Parse time         |
| ---------------------- | ------------------ |
| valid address + 750 sp | 0.38 s             |
| + 1500 sp              | 2.97 s             |
| + 3000 sp              | 23.4 s (×7.9/2×)   |
| + 6 KB sp              | 185 s              |
| ~100 KB sp             | hours              |

Fully RFC 5322-compliant folded headers (all lines ≤ 71 octets) trigger the same
blowup, so the input passes normal MTA and library checks. ~100 KB of headers is
within Postfix's default `header_size_limit = 102400`.

All six address headers parsed by the library (`From`, `To`, `Cc`, `Bcc`,
`Reply-To`, `Delivered-To`) are affected and their cost adds up linearly.

**2. Received-header clause splitter (`src/mailparser/const.py`)**

`parse_received()` splits on `_CLAUSE_SPLITTER`,
`(?:^|\s+)(from|by|via|with|id|for|envelope-from)\s+`. Under `re.split` this
backtracks **quadratically** over any whitespace run that is not followed by a
clause keyword. The pre-existing normalization collapsed only `[\t\n]`, so
literal spaces — including folded-header padding — reached the splitter intact.

Measured: 24 000 spaces in one `Received:` header → 22 s; ~100 KB → minutes.

### Impact

Availability. A handful of small emails keeps every parsing worker of a mail
gateway, ticketing system, quarantine UI, or archiving pipeline permanently
busy. No confidentiality or integrity impact.

Anyone who parses email they did not author is affected — which is the library's
purpose.

### Patches

Fixed in **4.6.1**.

- The address fallback is now a linear scan: the header is split into
  comma-separated items (quote-aware, in Python), then each item is matched
  against a bounded angle-address `<([^<>\s]+)>` with the display name derived
  in Python, falling back to a bare-email match. Each pattern has a single
  non-nested quantifier over a negated character class → O(n).
  2000 padding spaces: `3.5 s → <0.01 s`. 256 KB padding: `hours → 0.087 s`.
  Output is preserved on every previously supported shape.
- `parse_received()` collapses whitespace runs to a single space before
  splitting, so the splitter's `\s+` only ever matches one character → O(n).
  The date is extracted from the raw header beforehand, so date formatting is
  unaffected. 24 000 spaces: `22 s → 0.003 s`; 200 000 spaces: `0.004 s`.

Regression tests assert linear-time behaviour for both paths.

### Workarounds

None within the library. Upgrade to `4.6.1`.

Users who cannot upgrade immediately should cap total header size before
parsing and enforce a wall-clock timeout around each parse.

## References

- https://github.com/SpamScope/mail-parser/security/advisories/GHSA-r7w7-vpq8-c5vv
- https://nvd.nist.gov/vuln/detail/CVE-2026-129295
- https://github.com/SpamScope/mail-parser/pull/166
- https://github.com/SpamScope/mail-parser/commit/037293158cb291caa96635a54449243d32cd4d96
- https://github.com/SpamScope/mail-parser/commit/5aab122f0d763991604d2c2bcc807c6bf2489464
- https://github.com/SpamScope/mail-parser/commit/85e53f820d78ae7c955dafbbcd0e20989a735c2c
- https://github.com/SpamScope/mail-parser
- https://github.com/SpamScope/mail-parser/releases/tag/4.6.1

Page: https://cve.now/GHSA-R7W7-VPQ8-C5VV
