refactor(core): extraire safe_parse_xml en cercle 1 + appliquer aux 3 sites XXE résiduels

Audit F1 — ``safe_parse_xml`` n'existait que dans ``picarones/web/corpus_utils.py``,
ce qui empêchait son réemploi depuis cercle 2 (``measurements/``) et cercle 3
(``extras/``). Trois sites parsaient encore du XML reçu d'une source externe via
``ET.fromstring`` direct :

- ``picarones/extras/importers/gallica.py`` (réponse SRU + métadonnées OAI),
- ``picarones/measurements/alto_metrics.py`` (extraction de texte d'un ALTO).

Création de ``picarones/core/xml_utils.py`` (cercle 1, abstraction pure, déléguée
à ``defusedxml`` exactement comme l'implémentation web). Les trois sites importent
désormais ``safe_parse_xml`` et délèguent leurs erreurs au logger à la place du
``except: pass`` ou du double-try imbriqué. ``picarones/web/corpus_utils.py``
réexporte ``safe_parse_xml`` dans son ``__all__`` pour rétrocompat.

Verrou levé : un module ``BaseModule`` tiers qui produit un ALTO depuis une
source non vérifiée (preuve de concept Sprint 33+) ne peut plus déclencher de
XXE, Billion Laughs ou DTD retrieval lors du calcul des métriques
``alto_text_*``.

3354 passed, 2 skipped, 0 failed. ``ruff check`` clean.

https://claude.ai/code/session_01Hsd7kL8yeCbXn1mA7GQK9L

picarones/core/xml_utils.py

@@ -0,0 +1,44 @@
+"""Parsing XML sécurisé — anti-XXE / Billion Laughs / DTD retrieval.
+
+Helper transverse appliqué partout où Picarones parse du XML reçu
+depuis une source externe (corpus uploadé via le web, manifeste
+Gallica, ALTO produit par un module ``BaseModule`` tiers, etc.).
+
+Délègue à :mod:`defusedxml` (dépendance dure du projet) qui durcit
+le parser stdlib contre :
+
+- **XXE** (``XML External Entity``) — résolution d'entités vers
+  des fichiers locaux ou des URL distantes ;
+- **Billion Laughs** — expansion exponentielle d'entités ;
+- **DTD retrieval** — fetch d'une DTD distante.
+
+Discipline : tout module qui parse du XML doit utiliser
+``safe_parse_xml`` plutôt que ``xml.etree.ElementTree.fromstring``
+directement. La règle est appliquée par un audit récurrent
+(grep ``ET.fromstring`` dans ``picarones/``).
+"""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from typing import Optional
+
+import defusedxml
+import defusedxml.ElementTree as _SafeET
+
+
+def safe_parse_xml(xml_bytes: bytes) -> Optional[ET.Element]:
+    """Parse du XML en bloquant les entités externes.
+
+    Retourne ``None`` si le payload n'est pas un XML valide ou si
+    ``defusedxml`` détecte une attaque
+    (``EntitiesForbidden``, ``ExternalReferenceForbidden``,
+    ``DTDForbidden``, ``NotSupportedError``).
+    """
+    try:
+        return _SafeET.fromstring(xml_bytes)
+    except (ET.ParseError, defusedxml.DefusedXmlException):
+        return None
+
+
+__all__ = ["safe_parse_xml"]

picarones/extras/importers/gallica.py

@@ -30,6 +30,8 @@ import urllib.error
 import urllib.parse
 import urllib.request
 import xml.etree.ElementTree as ET
+
+from picarones.core.xml_utils import safe_parse_xml
 from dataclasses import dataclass
 from typing import Optional
 
@@ -261,10 +263,12 @@ class GallicaClient:
     def _parse_sru_response(self, xml_bytes: bytes, max_results: int) -> list[GallicaRecord]:
         """Parse la réponse SRU XML de Gallica."""
         records: list[GallicaRecord] = []
-        try:
-            root = ET.fromstring(xml_bytes)
-        except ET.ParseError as exc:
-            logger.error("Impossible de parser la réponse SRU: %s", exc)
+        # ``safe_parse_xml`` neutralise XXE / Billion Laughs / DTD
+        # retrieval — Gallica est de confiance institutionnelle mais
+        # on ne baisse pas la garde sur du XML reçu via le réseau.
+        root = safe_parse_xml(xml_bytes)
+        if root is None:
+            logger.error("Impossible de parser la réponse SRU (XML invalide ou défense XXE déclenchée)")
             return records
 
         # Les enregistrements sont dans srw:records/srw:record/srw:recordData
@@ -446,9 +450,15 @@ class GallicaClient:
         url = f"{_GALLICA_BASE}/services/OAIRecord?ark=ark:/12148/{ark}"
         try:
             raw = self._fetch_url(url)
-            root = ET.fromstring(raw)
-        except (RuntimeError, ET.ParseError) as exc:
-            logger.error("Erreur métadonnées OAI %s: %s", ark, exc)
+        except RuntimeError as exc:
+            logger.error("Erreur fetch métadonnées OAI %s: %s", ark, exc)
+            return {"ark": ark}
+        root = safe_parse_xml(raw)
+        if root is None:
+            logger.error(
+                "Erreur parse XML métadonnées OAI %s (XML invalide ou défense XXE déclenchée)",
+                ark,
+            )
             return {"ark": ark}
 
         def find_text(tag_suffix: str) -> str:

picarones/measurements/alto_metrics.py

@@ -51,7 +51,8 @@ from __future__ import annotations
 import logging
 import re
 from typing import Any
-from xml.etree import ElementTree as ET
+
+from picarones.core.xml_utils import safe_parse_xml
 
 from picarones.core.metric_registry import register_metric
 from picarones.core.modules import ArtifactType
@@ -125,12 +126,14 @@ def extract_text_from_alto(payload: Any) -> str:
     xml = _coerce_alto_to_str(payload).strip()
     if not xml:
         return ""
-    try:
-        root = ET.fromstring(xml)
-    except ET.ParseError as exc:
+    # ``safe_parse_xml`` neutralise XXE / Billion Laughs / DTD
+    # retrieval — l'ALTO peut venir d'un module ``BaseModule`` tiers
+    # qui n'a pas de garantie de provenance.
+    root = safe_parse_xml(xml.encode("utf-8") if isinstance(xml, str) else xml)
+    if root is None:
         logger.warning(
-            "[alto_metrics] ALTO non parsable (%s) — texte extrait vide",
-            exc,
+            "[alto_metrics] ALTO non parsable (XML invalide ou défense XXE "
+            "déclenchée) — texte extrait vide",
         )
         return ""
 

picarones/web/corpus_utils.py

@@ -1,21 +1,18 @@
 """Utilitaires de manipulation de corpus côté web.
 
-Parsing sécurisé d'XML (anti-XXE), détection ALTO/PAGE, extraction de
-texte GT, analyse de la structure d'un dossier corpus, extraction de
-ZIP avec garde-fous (taille décompressée, nombre de fichiers).
+Détection ALTO/PAGE, extraction de texte GT, analyse de la structure
+d'un dossier corpus, extraction de ZIP avec garde-fous (taille
+décompressée, nombre de fichiers). Le parsing XML sécurisé délègue
+à :func:`picarones.core.xml_utils.safe_parse_xml`.
 """
 
 from __future__ import annotations
 
+import xml.etree.ElementTree as ET
 import zipfile
 from pathlib import Path
-from typing import Optional
-
-import xml.etree.ElementTree as ET
-
-import defusedxml
-import defusedxml.ElementTree as _SafeET
 
+from picarones.core.xml_utils import safe_parse_xml
 from picarones.web.state import IMAGE_EXTS
 
 # Garde-fous ZIP-bomb pour l'upload
@@ -27,30 +24,9 @@ MAX_ZIP_FILES = 2000
 
 
 # ──────────────────────────────────────────────────────────────────────────
-# Parsing XML sécurisé (ALTO / PAGE)
+# Détection ALTO / PAGE depuis bytes XML
 # ──────────────────────────────────────────────────────────────────────────
 
-def safe_parse_xml(xml_bytes: bytes) -> Optional[ET.Element]:
-    """Parse du XML en bloquant les entités externes (protection XXE).
-
-    Délègue à :mod:`defusedxml` (dépendance dure du projet) qui durcit
-    le parser stdlib contre :
-
-    - **XXE** (``XML External Entity``) — résolution d'entités vers
-      des fichiers locaux ou des URL distantes ;
-    - **Billion Laughs** — expansion exponentielle d'entités ;
-    - **DTD retrieval** — fetch d'une DTD distante.
-
-    Retourne ``None`` si le payload n'est pas un XML valide ou si
-    ``defusedxml`` détecte une attaque (``EntitiesForbidden``,
-    ``ExternalReferenceForbidden``, etc.).
-    """
-    try:
-        return _SafeET.fromstring(xml_bytes)
-    except (ET.ParseError, defusedxml.DefusedXmlException):
-        return None
-
-
 def detect_xml_gt(xml_bytes: bytes) -> tuple[str, str] | None:
     """Détecte si ``xml_bytes`` est un fichier ALTO ou PAGE XML.
 

tests/core/test_public_api.py

@@ -406,6 +406,7 @@ class TestCercle1IsLean:
     EXPECTED_CERCLE1 = {
         "corpus.py", "facts.py", "metric_hooks.py", "metric_registry.py",
         "metrics.py", "modules.py", "pipeline.py", "results.py",
+        "xml_utils.py",
     }
 
     def test_cercle1_files_lean(self):