"""Couche A : detection deterministe regex + checksums (analyse §2.A). Regle de decision (2026-07-28) : - Les patterns AVEC checksum (IBAN, NIR, SIREN/SIRET, TVA, CB) decident seuls : un match syntaxique dont le checksum est valide est retenu, point. - Email, IP (octets valides), plaque SIV (AA-123-BC), cadastre ("section X n° N" porte son contexte) decident seuls aussi : formats assez distinctifs. - Les patterns SANS checksum ni format fort (telephone compact 10 chiffres, n° RG, ancienne plaque 123 ABC 75) exigent un mot de contexte dans les 30 caracteres precedents. Un telephone +33 ou avec separateurs decide seul. Resolution de chevauchements : le span le plus long gagne (un CB 4x4 matche dans un IBAN groupe par 4 ; le SIREN vit dans le SIRET et la TVA). Pre-normalisation OCR : les confusions classiques (O/0, l/1, S/5, B/8) sont corrigees token par token selon la dominante du token (lettres ou chiffres), puis la detection tourne sur le texte d'origine ET sur la forme normalisee (meme longueur, memes offsets). Le checksum reste le juge : un token corrige qui ne valide pas n'est pas retenu. Voir doc/memory/matrice_comparaison.md. Sortie : liste de spans au format du harness. Ce module servira tel quel de couche A du produit ; ici il est branche sur le benchmark comme premier candidat de la matrice de comparaison (§5.3). """ import re from bench.pii import checksums as ck _CONTEXT_WINDOW = 30 _PATTERNS: list[tuple[str, re.Pattern, str | None]] = [] def _p(etype: str, pattern: str, context: str | None = None, flags: int = 0): _PATTERNS.append((etype, re.compile(pattern, flags), context)) # --- checksum : decident seuls ------------------------------------------- _p("IBAN", r"\b[A-Z]{2}\d{2}(?: ?[A-Z0-9]{4}){2,7}(?: ?[A-Z0-9]{1,3})?\b") _p("NIR", r"\b[12](?: ?\d{2}){2} ?(?:\d{2}|2A|2B)(?: ?\d{3}){2} ?\d{2}\b") _p("SIRET", r"\b\d{3} ?\d{3} ?\d{3} ?\d{5}\b") _p("TVA", r"\bFR ?\d{2} ?\d{3} ?\d{3} ?\d{3}\b") _p("SIREN", r"\b\d{3} ?\d{3} ?\d{3}\b") _p("CARD", r"\b\d{4}(?: ?\d{4}){3}\b") _VALIDATORS = { "IBAN": ck.iban_valid, "NIR": ck.nir_valid, "SIRET": lambda s: ck.siret_valid(s.replace(" ", "")), "TVA": ck.tva_fr_valid, "SIREN": lambda s: ck.siren_valid(s.replace(" ", "")), "CARD": lambda s: ck.luhn_valid(s.replace(" ", "")), } # --- format fort : decident seuls ---------------------------------------- _p("EMAIL", r"\b[\w.+-]+@[\w-]+\.[\w.]{1,10}\b") _p("PLATE", r"\b[A-Z]{2}-\d{3}-[A-Z]{2}\b", flags=re.IGNORECASE) _p("CADASTRE", r"\bsection [A-Z]{1,2} n° ?\d{1,3}\b", flags=re.IGNORECASE) _p("ADDRESS", r"\b(?:CS|BP|TSA|CEDEX) ?\d{2,6}\b") _p("IP", r"\b(?:\d{1,3}\.){3}\d{1,3}\b") _p("PHONE", r"(?:\+33|0033) ?[1-9](?:[ .]?\d{2}){4}\b") _p("PHONE", r"\b0[1-9](?:[ .]\d{2}){4}\b") # formats internationaux reels (audit emails 2026-07-29) : "+33(0)1 23...", # "+ 33 6...", numeros belges/lux/suisses, groupements irreguliers _p("PHONE", r"\+ ?\d{2,3} ?\(0\) ?\d(?:[ .]?\d{2,3}){3,5}\b") _p("PHONE", r"\+ ?\d{2,3}(?:[ .]?\d{2,3}){4,6}\b") _p("PHONE", r"\+ ?\d{2,3} ?\d(?:[ .]?\d{2}){4}\b") # formats etrangers a groupes irreguliers (+32 471 12 34 56, +41 79 123 45 67) _p("PHONE", r"\+ ?\d{2,3}(?:[ .]\d{2,4}){3,5}\b") # URLs : angle mort releve par l'audit emails (3 liens porteurs de jetons # jamais captures). Type URL, maskable par politique ; les liens avec longs # segments aleatoires (jetons) sont le vrai danger. _p("URL", r"\bhttps?://[^\s<>\"')\]]+") _p("URL", r"\bwww\.[\w.-]+\.[a-z]{2,6}\b", flags=re.IGNORECASE) # Domaines nus, sans schema ni www : « app.easywage.fr », « console.mistral.ai ». # Audit du 31/07 : 16 des 21 URL non protegees etaient de cette forme. La # liste de TLD evite d'avaler « document.pdf » ou « fichier.tar.gz ». _TLD = (r"fr|com|net|org|io|dev|app|eu|be|ch|lu|ca|ai|co|me|tech|cloud|" r"info|biz|shop|store|agency|studio|solutions|consulting") _p("URL", rf"\b(?\"')\]]*[^\s<>\"')\].,;:!?])?", flags=re.IGNORECASE) # Telephones internationaux espaces et format nord-americain. _p("PHONE", r"\(\+ ?\d{1,3}\) ?\d(?:[ .]?\d{2,3}){3,5}\b") _p("PHONE", r"\b\d{3}-\d{3}-\d{4}\b") # indicatif puis groupes de longueur libre : « + 32 2 808 66 05 » _p("PHONE", r"\+ ?\d{2,3}(?: \d{1,4}){3,6}\b") # Identifiants techniques : un UUID est toujours une reference opaque. _p("REF", r"\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b", flags=re.IGNORECASE) # --- formats etendus (pas des identifiants, mais deterministes) ---------- # Le NER (Anonym-IA V2) ignore quasi totalement dates et montants sur notre # benchmark (~98 % de fuite) : on les prend en regex. Sur-masquage assume : # masquer une date non personnelle est benin, la rater ne l'est pas. _MOIS = ("janvier|février|fevrier|mars|avril|mai|juin|juillet|août|aout|" "septembre|octobre|novembre|décembre|decembre") _p("DATE", r"\b\d{1,2}[/.]\d{1,2}[/.]\d{2,4}\b") # dates sans annee "12/07" (contexte le/du/au) et mois anglais (titres de # reunions exportees) — audit emails 2026-07-29 _p("DATE", r"\b\d{1,2}/\d{1,2}\b") _p("DATE", r"\b\d{1,2}\.\d{1,2}\b", context=r"\ble\b|\bdu\b|\bau\b|\bdès\b|avant|depuis|jusqu") _MOIS_EN = "January|February|March|April|May|June|July|August|September|October|November|December" _p("DATE", rf"\b\d{{1,2}} (?:{_MOIS_EN}) \d{{4}}\b", flags=re.IGNORECASE) _p("DATE", rf"\b(?:{_MOIS}) \d{{4}}\b", flags=re.IGNORECASE) _JOURS = "lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche" _p("DATE", rf"\b(?:{_JOURS}) \d{{1,2}}(?: (?:{_MOIS}))?\b", flags=re.IGNORECASE) _p("DATE", rf"\b\d{{1,2}}(?:er)? (?:{_MOIS}) \d{{4}}\b", flags=re.IGNORECASE) # Dates sans annee et mois seuls. Audit du 31/07 : DATE fuyait a 42,9 % sur # la correspondance reelle, uniquement sur ces formes-la. « le 17 juin », # « courant juillet », « en 2025 » sont des dates aux yeux de l'annotation. _p("DATE", rf"\b\d{{1,2}}(?:er)? (?:{_MOIS})\b", flags=re.IGNORECASE) _p("DATE", rf"\b\d{{1,2}} ?[-–—] ?\d{{1,2}} (?:{_MOIS})\b", flags=re.IGNORECASE) _p("DATE", rf"\b(?:{_MOIS})\b", flags=re.IGNORECASE) _p("DATE", r"(?,;]{6,80})") # user-agent (navigateur/robot) : signature tres reconnaissable _p("USERAGENT", r"Mozilla/\d[^\n]{10,200}") _p("USERAGENT", r"\b(?:curl|Wget|PostmanRuntime|python-requests|okhttp|axios)/[\d.]+") # adresses techniques _p("MAC", r"\b(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\b") _p("IPV6", r"\b(?:[0-9A-Fa-f]{1,4}:){2,7}[0-9A-Fa-f]{1,4}\b") # identifiants opaques : cles et jetons longs (base64/hex) annonces ou nus _p("SECRET", r"\b(?:sk|pk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b") _p("SECRET", r"\bgh[pousr]_[A-Za-z0-9]{30,}\b") _p("SECRET", r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b") _p("SECRET", r"\b[0-9a-f]{32,64}\b", context=r"cl[eé]|key|token|secret|hash|signature|empreinte|md5|sha") # age en contexte RH/dossier ("45 ans", "age : 45") _p("AGE", r"\b\d{1,3} ans\b", context=r"[aâ]g[eé]|ann[eé]es|naissance|salari|candidat|patient|enfant|\best\b|\ba\b") _p("AGE", r"(?i:[aâ]ge\s*(?::|est de)\s*)(\d{1,3})\b") # IBAN etranger sans checksum FR mais format IBAN valide (deja couvert), # et numero de compte annonce ("compte n° 12345678") _p("ACCOUNT", r"(?i:(?:compte|account)\s*(?:bancaire\s*)?(?:n°|no|num[eé]ro|#|:)\s*)([0-9]{6,17})") # --- sans checksum : contexte requis ------------------------------------- _p("PHONE", r"\b0[1-9]\d{8}\b", context=r"t[eé]l|portable|mobile|fixe|appel|joign|rappel|contact|num[eé]ro|\bau\b") # identifiants internes rattaches a une personne (audit 2026-07-29 : # matricule, n° de police, contrat, reference client = PII RGPD) _p("REF", r"\b\d{4,8}\b", context=(r"matricule|police|contrat|dossier|r[eé]f[eé]rence|r[eé]f\.|" r"abonn|adh[eé]rent|client|sinistre|avenant")) _p("RG", r"\b\d{2}/\d{5}\b", context=(r"\bRG\b|r[oô]le|r[eé]pertoire|dossier|tribunal|jugement|" r"instance|enr[oô]l|audience|greffe|affaire|contentieux")) _p("PLATE", r"\b\d{3} [A-Z]{3} \d{2}\b", context=r"immatricul|v[eé]hicule|plaque") def _ip_valid(s: str) -> bool: return all(int(o) <= 255 for o in s.split(".")) _TO_DIGIT = str.maketrans("OolISsBb", "00115588") _TO_LETTER = str.maketrans("0158", "olsb") _TOKEN_RE = re.compile(r"[A-Za-z0-9]+") def ocr_normalize(text: str) -> str: """Corrige les confusions OCR token par token, longueur conservee. Token a dominante chiffres -> lettres confusables vers chiffres (O->0...). Token a dominante lettres -> chiffres confusables vers lettres (0->o...). Le checksum/pattern reste le juge en aval : on ne decide rien ici. """ out = list(text) for m in _TOKEN_RE.finditer(text): tok = m.group(0) if len(tok) < 2: continue digits = sum(c.isdigit() for c in tok) fixed = tok.translate(_TO_DIGIT) if digits * 2 >= len(tok) else tok.translate(_TO_LETTER) if fixed != tok: out[m.start():m.end()] = fixed return "".join(out) def _scan(text: str, original: str) -> list[dict]: candidates = [] for etype, pattern, context in _PATTERNS: for m in pattern.finditer(text): # si le pattern a un groupe de capture, le span est le groupe 1 # (permet un mot-cle declencheur hors masque, ex. "Dénomination :") grp = 1 if m.groups() else 0 value = m.group(grp) if not value: continue if etype in _VALIDATORS and not _VALIDATORS[etype](value): continue if etype == "IP" and not _ip_valid(value): continue if context is not None: before = text[max(0, m.start() - _CONTEXT_WINDOW):m.start()] if not re.search(context, before, re.IGNORECASE): continue candidates.append( {"start": m.start(grp), "end": m.end(grp), "type": etype, "value": original[m.start(grp):m.end(grp)]} ) return candidates def detect(text: str) -> list[dict]: # variantes a longueur constante (offsets communs) : correction OCR, et # sauts de ligne aplatis — une valeur coupee par un \n (PDF, courrier) # doit etre detectee ("MEYER\nTRANSPORTS", "26\nnovembre 2025") variants = [text] for base in (text, ocr_normalize(text)): for v in (base, base.replace("\n", " ")): if v not in variants: variants.append(v) candidates = _scan(text, text) seen = {(c["start"], c["end"], c["type"]) for c in candidates} for v in variants[1:]: flattened = "\n" in text and "\n" not in v for c in _scan(v, text): # la passe "sauts de ligne aplatis" ne sert qu'aux valeurs # coupees par un \n dans un PDF (identifiants, dates, montants). # Sur les types a mots (ADDRESS, COMPANY, CITY) elle recollait # deux lignes distinctes ("75011 Paris" + "Tél") — audit reel. if flattened and c["type"] in ("ADDRESS", "COMPANY", "CITY", "URL", "REF", "USERAGENT", "SECRET", "AGE"): continue if (c["start"], c["end"], c["type"]) not in seen: seen.add((c["start"], c["end"], c["type"])) candidates.append(c) # le span le plus long gagne ; a longueur egale, premier arrive (ordre # de declaration = priorite : checksum avant format avant contexte) candidates.sort(key=lambda c: (-(c["end"] - c["start"]), c["start"])) kept: list[dict] = [] occupied: set[int] = set() for c in candidates: span = set(range(c["start"], c["end"])) if span & occupied: continue kept.append(c) occupied |= span kept.sort(key=lambda c: c["start"]) return kept