| import hashlib |
| import base64 |
| import os |
| import sys |
| from typing import Dict, List, Tuple |
| from presidio_anonymizer import AnonymizerEngine |
| from presidio_anonymizer.entities import OperatorConfig, RecognizerResult |
|
|
| sys.path.insert(0, os.path.dirname(__file__)) |
| from utils import DetectionResult, merge_overlapping_spans, validate_aes_key |
|
|
| |
| LABEL_NORM: Dict[str, str] = { |
| |
| "PERSON": "PERSON", |
| "EMAIL_ADDRESS": "EMAIL", |
| "PHONE_NUMBER": "PHONE", |
| "CREDIT_CARD": "CREDIT_CARD", |
| "LOCATION": "LOCATION", |
| "IP_ADDRESS": "IP", |
| "US_SSN": "SSN", |
| "IBAN_CODE": "IBAN", |
| "URL": "URL", |
| "NRP": "NRP", |
| "US_BANK_NUMBER": "BANK", |
| "US_ITIN": "ITIN", |
| "US_DRIVER_LICENSE": "DL", |
| "US_PASSPORT": "PASSPORT", |
| "CRYPTO": "CRYPTO", |
| "UK_NHS": "NHS", |
| "MEDICAL_LICENSE": "MEDICAL_LICENSE", |
| |
| "PER": "PERSON", |
| "ORG": "ORG", |
| "LOC": "LOCATION", |
| "MISC": "MISC", |
| |
| "PII": "PII", |
| |
| "PROJECT_ID": "PROJECT_ID", |
| "PASSPORT_NUMBER": "PASSPORT", |
| "DRIVERS_LICENSE": "DL", |
| "MEDICAL_RECORD_NUMBER": "MRN", |
| "BANK_ACCOUNT": "BANK", |
| "INSURANCE_NUMBER": "INSURANCE", |
| "EMPLOYEE_ID": "EMP_ID", |
| "DATE_OF_BIRTH": "DOB", |
| "TAX_ID": "TAX_ID", |
| "VIN": "VIN", |
| "API_KEY": "API_KEY", |
| "USERNAME": "USERNAME", |
| "MAC_ADDRESS": "MAC", |
| "SECURITY_BADGE": "BADGE", |
| "GRANT_NUMBER": "GRANT", |
| "AWS_KEY": "AWS_KEY", |
| "SERVICE_API_KEY": "API_KEY", |
| "DB_CONNECTION": "DB_CONN", |
| "LICENSE_PLATE": "PLATE", |
| "PROFESSIONAL_LICENSE": "PROF_LICENSE", |
| "CVV": "CVV", |
| "MEDICARE_NUMBER": "MEDICARE", |
| "PATENT_NUMBER": "PATENT", |
| } |
|
|
|
|
| class PIIPseudonymizer: |
| """ |
| Replaces detected PII spans with readable tokens like [PERSON_a1b2c3d4] |
| and maintains a map of { token -> AES-encrypted original value }. |
| |
| Token IDs are derived from an MD5 hash of the raw value, so the same |
| value always maps to the same token across runs (reproducible datasets). |
| |
| Usage: |
| p = PIIPseudonymizer(b"16ByteSecureKey!") |
| tokenized, token_map = p.pseudonymize(text, detector.detect(text)) |
| """ |
|
|
| def __init__(self, aes_key: bytes) -> None: |
| validate_aes_key(aes_key) |
| self._aes_key = aes_key |
| self._key_b64 = base64.b64encode(aes_key).decode("utf-8") |
| self._anonymizer = AnonymizerEngine() |
| self._value_to_token: Dict[str, str] = {} |
| self._token_map: Dict[str, str] = {} |
|
|
| def _normalize_label(self, label: str) -> str: |
| normalized = LABEL_NORM.get(label, label.upper()) |
| return normalized[:20] |
|
|
| def _make_token(self, label: str, value: str) -> str: |
| short_id = hashlib.md5(value.encode()).hexdigest()[:8] |
| return f"[{self._normalize_label(label)}_{short_id}]" |
|
|
| def _encrypt_value(self, value: str) -> str: |
| fake_result = [RecognizerResult(entity_type="PII", start=0, end=len(value), score=1.0)] |
| op_config = {"DEFAULT": OperatorConfig("encrypt", {"key": self._key_b64})} |
| result = self._anonymizer.anonymize( |
| text=value, analyzer_results=fake_result, operators=op_config |
| ) |
| return result.text |
|
|
| def pseudonymize( |
| self, text: str, detections: List[DetectionResult] |
| ) -> Tuple[str, Dict[str, str]]: |
| """ |
| Replace each detected PII span with a token and record the AES-encrypted |
| original in the token map. |
| |
| Returns: |
| (tokenized_text, token_map_snapshot) |
| """ |
| if not detections: |
| return text, dict(self._token_map) |
|
|
| merged = merge_overlapping_spans(detections, text) |
|
|
| tokenized = text |
| for span in reversed(merged): |
| raw_value = tokenized[span["start"]:span["end"]] |
| if raw_value not in self._value_to_token: |
| token = self._make_token(span["label"], raw_value) |
| self._value_to_token[raw_value] = token |
| self._token_map[token] = self._encrypt_value(raw_value) |
| token = self._value_to_token[raw_value] |
| tokenized = tokenized[: span["start"]] + token + tokenized[span["end"]:] |
|
|
| return tokenized, dict(self._token_map) |
|
|
| def reset(self) -> None: |
| """Clear accumulated state between independent files.""" |
| self._value_to_token.clear() |
| self._token_map.clear() |
|
|
| def get_token_map(self) -> Dict[str, str]: |
| return dict(self._token_map) |
|
|
| def get_plaintext_map(self) -> Dict[str, str]: |
| """Return {token: original_plaintext} — useful for exporting the recovery map.""" |
| return {token: value for value, token in self._value_to_token.items()} |
|
|
