#!/usr/bin/env python3
"""Проверка полноты обезличивания: что закрыто токенами, а что осталось открытым.
Смысл: обезличивание делают люди, и оно бывает неполным — закрывают то, о чём
подумали. Скрипт ничего не закрывает, он ПОКАЗЫВАЕТ, что осталось открытым,
чтобы это увидел человек до отправки документа во внешнюю модель.
Использование:
python scan_open_pii.py "<файл.docx>" полный отчёт
python scan_open_pii.py "<файл.docx>" --summary только счётчики, без значений
python scan_open_pii.py "<файл.docx>" --header строка для шапки отчёта
python scan_open_pii.py "<файл.docx>" --json машинный вывод
Поддерживается .docx (весь пакет: текст, таблицы, колонтитулы, метаданные) и .txt.
--- Два правила, заложенные в код ---
1. Разбираются И абзацы, И таблицы. В ТЗ содержимое лежит в ячейках таблиц, а не
в абзацах; проверка только по абзацам даёт пустой результат и читается как
«всё чисто».
2. Регистр сворачивается питоном (`lower()`), а не средствами ОС: `grep -i` в
Windows-окружении не сворачивает кириллицу, и счётчик молча выходит нулевым.
--- Чего скрипт НЕ делает ---
Ноль находок означает «шаблоны не сработали», а НЕ «документ чист». Заказчик,
названный описательно («Инвестор проекта в районе станции»), под шаблон не
попадёт. Поэтому код возврата 0 при пустом результате — это «проверка прошла»,
а не «утечек нет». Ненулевой код (1) отдаётся только по флагу --fail-on-open.
"""
import argparse
import json
import re
import sys
import zipfile
from collections import Counter, defaultdict
from pathlib import Path
from xml.etree import ElementTree as ET
W = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
# ---------------------------------------------------------------- шаблоны
# Пары (категория, регулярное выражение). Регистр НЕ указываем: текст заранее
# приводится к нижнему — так надёжнее, чем флаги в самом шаблоне.
PATTERNS = [
# Название в кавычках захватывается вместе с формой: без него в отчёте стоит
# голое «ООО», и человек не может отличить заказчика от «АО «Мосводоканал»»,
# которое в любом ТЗ Москвы и объект не идентифицирует.
("орг. форма", r"\b(ооо|оао|зао|пао|ао|ип|гбу|гку|фгбу|фгбоу|фгуп|муп|гуп|нко|сро|тсж|ано)\b"
r"\s*(?:«[^»\n]{1,120}»|\"[^\"\n]{1,120}\")?"),
("инициалы", r"\b[а-яё]\.\s?[а-яё]\.\s?[а-яё][а-яё-]{2,}"),
("фамилия с инициалами", r"\b[а-яё][а-яё-]{2,}\s[а-яё]\.\s?[а-яё]\."),
("кадастровый номер", r"\b\d{2}:\d{2}:\d{6,7}:\d+"),
("ГПЗУ", r"\bгпзу\b[^\n]{0,60}"),
# \d{1,4} и полный номер телефона: с одиночной \d находка обрывалась до
# «д. 1» и «+7 (4» — в отчёте это бесполезно.
("адрес", r"\b(?:г\.|гор\.|город|ул\.|улица|пер\.|переулок|проезд|шоссе|проспект|д\.|дом|корп\.|корпус|стр\.|строение|владение|помещение)\s*\.?\s*\d{1,4}"),
# Границы по [\w-] обязательны: без них индекс «123456» находился внутри
# номера ГПЗУ «RU77-123456» — это ложная находка.
("почтовый индекс", r"(?<![\w-])\d{6}(?![\w-])"),
("телефон", r"\+7[\s(-]*\d{3}[\s)-]*\d{3}[\s-]*\d{2}[\s-]*\d{2}"
r"|\b8[\s(-]*\(?\d{3}\)?[\s-]*\d{3}[\s-]*\d{2}[\s-]*\d{2}"),
("электронная почта", r"[\w.+-]+@[\w-]+\.[\w.]{2,}"),
("реквизиты", r"\b(инн|огрн|кпп|снилс|бик)\b\s*:?\s*\d+"),
("счёт", r"\bр/?с\b\s*:?\s*\d{20}|\b\d{20}\b"),
]
# Токены обезличивания: [АДРЕС-003], [ЗАКАЗЧИК-1], [ОБЪЕКТ-012] и подобные.
TOKEN_RE = re.compile(r"\[([а-яёa-z][а-яёa-z0-9 _-]*?)-(\d{1,4})\]")
# Второй способ замены — подчёркивания. Он наш: структура таблиц и формуляров
# не едет, значения просто исчезают. Проверять только токены нельзя: на нашей
# обезличенной копии EIR токенов 0, а подчёркиваний 39 — и проверка объявила бы
# чистый документ оригиналом.
UNDERSCORE_RE = re.compile(r"_{3,}")
# Категории, которые скрипт НЕ считает утечкой по своей природе — их наличие
# нормально, но человек должен про них знать (ресурсоснабжающие организации
# есть в любом ТЗ Москвы и объект не идентифицируют).
BENIGN_HINT = ("мосгоргеотрест", "мосводоканал", "мосэнергосбыт", "мэш",
"мосгаз", "ростелеком", "почта россии")
def read_docx(path: Path):
"""Текст .docx по частям: возвращает список (часть, вид, номер, текст).
Абзацы и ячейки таблиц разделяются честно: у стандартного ElementTree нет
родительских ссылок, поэтому карта предков строится один раз. Без этого
ячейка таблицы помечалась бы как обычный абзац — а в ТЗ содержимое лежит
именно в таблицах, и по виду записи это должно быть видно.
"""
blocks = []
with zipfile.ZipFile(path) as z:
names = z.namelist()
wanted = [n for n in names
if n in ("word/document.xml", "docProps/core.xml", "docProps/app.xml")
or re.fullmatch(r"word/(header|footer)\d*\.xml", n)]
for name in wanted:
try:
root = ET.fromstring(z.read(name))
except ET.ParseError:
continue
if name.startswith("docProps"):
for el in root.iter():
tag = el.tag.split("}")[-1]
if tag in ("creator", "lastModifiedBy", "Manager", "Company") and (el.text or "").strip():
blocks.append((name, "метаданные", tag, el.text.strip()))
continue
parent = {c: p for p in root.iter() for c in p}
for i, par in enumerate(root.iter(f"{W}p")):
text = "".join(t.text or "" for t in par.iter(f"{W}t"))
if not text.strip():
continue
node, in_table = par, False
while node in parent:
node = parent[node]
if node.tag == f"{W}tc":
in_table = True
break
blocks.append((name, "ячейка таблицы" if in_table else "абзац", i, text))
return blocks
def read_txt(path: Path):
text = path.read_text(encoding="utf-8", errors="replace")
return [(path.name, "строка", i, line) for i, line in enumerate(text.splitlines(), 1) if line.strip()]
def scan(blocks):
"""Возвращает (закрыто, открыто).
«Закрыто» — это ДВА законных способа замены, и считаются оба: скобочные
токены [АДРЕС-003] (по ним видно, что за значение) и подчёркивания ______
(наш способ — структура формуляров не едет).
"""
closed = Counter()
open_hits = defaultdict(list) # категория -> [(где, что, контекст)]
for part, kind, num, text in blocks:
low = text.lower()
for m in TOKEN_RE.finditer(low):
closed[f"токен {m.group(1).strip().upper()}"] += 1
n_under = len(UNDERSCORE_RE.findall(text))
if n_under:
closed["подчёркивания"] += n_under
for category, pattern in PATTERNS:
for m in re.finditer(pattern, low):
found = text[m.start():m.end()].strip()
ctx = text[max(0, m.start() - 40):m.end() + 40].strip()
open_hits[category].append((f"{kind} {part}:{num}", found, ctx))
return closed, open_hits
def is_benign(found: str) -> bool:
return any(h in found.lower() for h in BENIGN_HINT)
def main() -> int:
ap = argparse.ArgumentParser(description="Проверка полноты обезличивания документа")
ap.add_argument("file", help=".docx или .txt — обезличенная копия")
ap.add_argument("--summary", action="store_true", help="только счётчики, без значений")
ap.add_argument("--header", action="store_true", help="строка для шапки отчёта")
ap.add_argument("--json", action="store_true", help="машинный вывод")
ap.add_argument("--fail-on-open", action="store_true", help="код 1, если есть открытые находки")
args = ap.parse_args()
path = Path(args.file)
if not path.exists():
print(f"файл не найден: {path}", file=sys.stderr)
return 2
if path.suffix.lower() == ".docx":
blocks = read_docx(path)
elif path.suffix.lower() in (".txt", ".md"):
blocks = read_txt(path)
else:
print(f"формат не поддержан: {path.suffix} (нужен .docx или .txt)", file=sys.stderr)
return 2
closed, open_hits = scan(blocks)
total_closed = sum(closed.values())
total_open = sum(len(v) for v in open_hits.values())
benign = sum(1 for cat, items in open_hits.items() for item in items if is_benign(item[1]))
if not total_closed:
note = ("Признаков обезличивания в документе НЕТ (ни подчёркиваний, ни "
"токенов). Если это должна быть обезличенная копия — скорее всего "
"перед вами оригинал. Работа остановлена, файл дальше не проверялся.")
if args.json:
print(json.dumps({"file": str(path), "error": "no_anonymization_markers",
"note": note}, ensure_ascii=False, indent=2))
else:
print(note)
return 1
cats = {c: len(v) for c, v in sorted(open_hits.items(), key=lambda x: -len(x[1]))}
kinds = ", ".join(f"{k} — {v}" for k, v in closed.most_common())
if args.json:
print(json.dumps({
"file": str(path),
"blocks": len(blocks),
"closed": {"total": total_closed, "kinds": dict(closed)},
"open": {"total": total_open, "by_category": cats, "likely_benign": benign},
"findings": {c: [{"where": w, "found": f} for w, f, _ in v]
for c, v in open_hits.items()},
}, ensure_ascii=False, indent=2))
elif args.header:
if total_open:
opened = ", ".join(f"{c} ({n})" for c, n in cats.items())
print(f"Обезличивание: закрыто — {total_closed} замен ({kinds}). "
f"ОТКРЫТО: {opened}. Цитаты из мест с открытыми данными не берутся.")
else:
print(f"Обезличивание: закрыто — {total_closed} замен ({kinds}). Открытых "
f"значений шаблоны не нашли — это НЕ доказательство полноты, "
f"описательные упоминания проверяются глазами.")
elif args.summary:
print(f"документ: {path.name} | блоков текста: {len(blocks)}")
print(f"закрыто: {total_closed} ({kinds})")
print(f"осталось открытым: {total_open} совпадений по {len(cats)} категориям")
for c, n in cats.items():
print(f" {c}: {n}")
if benign:
print(f" из них похожи на ресурсоснабжающие (обычно не утечка): {benign}")
else:
print(f"ФАЙЛ: {path}")
print(f"блоков текста: {len(blocks)}\n")
print(f"ЗАКРЫТО: {total_closed}")
for k, v in closed.most_common():
print(f" {k}: {v}")
print(f"\nОСТАЛОСЬ ОТКРЫТЫМ: {total_open} совпадений\n")
for category, items in sorted(open_hits.items(), key=lambda x: -len(x[1])):
print(f"--- {category}: {len(items)} ---")
for where, found, ctx in items[:12]:
flag = " (похоже на ресурсоснабжающую)" if is_benign(found) else ""
print(f" [{where}] {found}{flag}")
print(f" …{ctx}…")
if len(items) > 12:
print(f" … ещё {len(items) - 12}")
print()
print("Ноль находок означает «шаблоны не сработали», а не «документ чист».")
print("Описательные упоминания объекта и заказчика проверяются глазами.")
if args.fail_on_open and total_open:
return 1
return 0
if __name__ == "__main__":
raise SystemExit(main())
