llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · eml-parser

GHSA-M4G8-47F9-H588

eml_parser: Algorithmic-complexity DoS (O(n^4) regex backtracking) in Received-header parsing

Parche disponible
Descargar PNG JSON
CVSS 3.1
5.3
Media
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -73 d de la divulgación
Exposición9 hDesde la divulgación, 19 nov 2026, 5:47 p. m.
Detección1 minDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche 3.0.4
Monitoreo
Detectada
Fuente: GitHub Security Advisories +2
7 sept 26
18 nov 26
19 nov 26
20 nov 26
7 sept 26
26 sept 26
14 oct 26
1 nov 26
20 nov 26
FechaFaseEventoDetalle
Remediación Parche 3.0.4 eml-parser · -73 d desde divulgación
Monitoreo Detectada Ingresó al índice
Divulgación Publicada GHSA-M4G8-47F9-H588 divulgada · CVSS 5.3 (GitHub)
Divulgación Modificada Última actualización del registro
Monitoreo Fuente: GitHub Security Advisories Registro visto por primera vez en GitHub Security Advisories
Monitoreo Fuente: OSV Registro visto por primera vez en OSV
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés
Summary

`eml_parser.routing.parserouting()` dynamically builds a regex from up to four greedy `.*` groups (`from (?P<from>.*)by (?P<by>.*)with (?P<with>.*)for (?P<for>.*)`) terminated by an escaped literal of the date extracted from a normalized copy of the `Received` header. Because the date literal comes from the normalized text but is searched in the original line, a crafted header can make the trailing literal unmatchable; the search then fails at every start position only after exhaustively backtracking the four nested greedy groups — O(n^4) in header length. A single ~5.9 KB email pins one CPU core for ~12 seconds; doubling the input multiplies the cost ~25x, so a ~13 KB header takes minutes and a ~25 KB header effectively hangs the parse worker.

Details

Root cause: `eml_parser/routing.py:140-148` (v3.0.3):

reg = ''
for item in tout:
    reg += item[1] + '(?P<' + item[1].strip() + '>.*)'   # e.g. 'from (?P<from>.*)'
if npdate:
    reg += eml_parser.regexes.escape_special_regex_chars.sub(r"""\\\1""", npdate)
reparse = re.compile(reg)
reparseg = reparse.search(line)   # searched in the ORIGINAL line

`npdate` is extracted from `npline`, a normalized copy of the header (spacing added around `(`, `)`, `;` at routing.py:79-81; parenthesized text removed at line 82; whitespace collapsed at line 83), so it is not guaranteed to be a substring of `line`. An unbalanced `(` in the date tail (e.g. `+0000(comment`) becomes ` ( comment` in `npline` but stays `(comment` in `line`, making the mandatory trailing literal unmatchable.

Data flow: attacker-controlled `Received:` header (arbitrary length; the custom policy sets `max_line_length=0`) -> `parser.py:352-355` (lowercased, whitespace-flattened, no size cap - unlike body text, which is sliced) -> `parser.py:365` `routing.parserouting(...)` -> O(n^4) search. Every Received header is processed, multiplying the cost, and the behavior cannot be disabled via any `EmlParser` option.

Measured on Python 3.14 (identical with stdlib `re` and the optional `regex` module):

| Segments | Header size | Wall time |
|---|---|---|
| 20 | 1.4 KB | 0.022 s |
| 40 | 2.9 KB | 0.43 s |
| 80 | 5.8 KB | 12 s |
| 160 (extrapolated) | 13 KB | ~5 min |

cProfile attributes 83% of wall time to `re.Pattern.search` called from `routing.parserouting`. The parse completes normally (no exception) - it is pure CPU exhaustion.

This is distinct from GHSA-g47v-rwmh-r9f8 (recursion DoS in `get_raw_body_text()`, fixed via `MULTIPART_RECURSION_LIMIT` - different function and mechanism) and from issue #48 (old `url_regex_simple` body-path hang; body regexes now run on ~600-char slices, capping impact - the Received-header path is unsliced).

PoC
import eml_parser

seg = 'from h{0}.example.com by mx{0}.example.com with esmtp for u{0}@example.com '
received = ''.join(seg.format(i) for i in range(80)) + ';Mon, 01 Jan 2024 00:00:00 +0000(comment'
# NB: unbalanced '(' in the date tail -> the normalized date literal never occurs in the
# searched line, so the dynamic 4-group greedy regex can never match and backtracks O(n^4).

eml = (
    'Received: ' + received + '\r\n'
    'From: attacker@evil.example\r\n'
    'To: victim@target.example\r\n'
    'Subject: poc\r\n'
    'Content-Type: text/plain\r\n'
    '\r\n'
    'hello\r\n'
).encode()

import time
t0 = time.perf_counter()
eml_parser.EmlParser().decode_email_bytes(eml)
print(f'{time.perf_counter() - t0:.2f}s')   # ~12 s for a 5.9 KB input

Observed on v3.0.3: `eml size: 5887 bytes`, `decode_email_bytes() wall time: 12.33s`, message parses fine. Affected APIs: `decode_email`, `decode_email_bytes`, `parse_email`.

Impact

Algorithmic-complexity denial of service. Any application that parses untrusted email with eml_parser (mail gateways, phishing-analysis and forensics pipelines, ticketing systems) can have a parser worker pinned by a single small email; an attacker sending a steady trickle of such messages keeps workers permanently busy (CPU exhaustion, queue backlog) even behind per-message timeouts. No crash, corruption, or information leak - availability impact only.

Reporter credit: Niranjan Ganesan (https://securityinsights.io/, @iam-niranjan)

Resolution

An algorithmic complexity vulnerability ($O(n^4)$ ReDoS) in `eml_parser.routing.parserouting()` was resolved.

Previously, `parserouting()` dynamically constructed a regex using multiple greedy `.*` capture groups appended with a normalized date string (`npdate`). Because `npdate` was extracted from a normalized copy of the `Received` header line, formatting mismatches between `npdate` and the un-normalized input line could render the trailing literal unmatchable. This forced the engine into exhaustive backtracking across nested greedy groups on unmatchable inputs, causing high CPU consumption and potential worker hangs on malicious headers.

Fix:

  1. Dynamic Regex Construction: Removed the static `npdate` suffix from the compiled pattern, replacing it with non-greedy field capture groups (`.*?`) terminated lazily by a semicolon or end-of-line anchor (`(?:;|$)`).
  2. Keyword Ordering Logic: Streamlined the routing keyword position detection to a single-pass `str.find()` search, removing $O(k^2)$ matrix evaluations.

These changes eliminate catastrophic backtracking and reduce processing time from $O(n^4)$ to linear $O(n)$ complexity.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:N
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:L
AltoBajoNinguno
Versiones

Rangos afectados

Afectada Corregida Última
eml-parser< 3.0.4
3.0.4
4.7.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypieml-parser
Corregida 3.0.4 -73 d 4.7.0 no afectada
Versiones corregidas3.0.4
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://nvd.nist.gov/vuln/detail/CVE-2026-129307
Otrahttps://github.com/GOVCERT-LU/eml_parser/security/advisories/GHSA-m4g8-47f9-h588
Otrahttps://github.com/GOVCERT-LU/eml_parser/commit/54ea6e9f54fecda3059283ccdb6a6fd99e7ce92f
Otrahttps://github.com/GOVCERT-LU/eml_parser
Otrahttps://github.com/GOVCERT-LU/eml_parser/releases/tag/v3.0.4

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.