Presidio 커스텀 Recognizer로 한국형 PII 잡기 — 정규표현식 + 체크섬 + 컨텍스트 3중 검증 구현

[1단계] 정규표현식 매칭 → 후보 추출 (score: 0.3)
         ↓
[2단계] validate_result → 체크섬 검증
         ├─ 통과 → score 유지 (0.3~0.4, 패턴에 설정한 초기값)
         └─ 실패 → 후보 제거 (결과에서 삭제)
         ↓
[3단계] Context Enhancement → 주변 텍스트 분석
         └─ 컨텍스트 단어 발견 시 score 상향 (최종 0.75~1.0)

from presidio_analyzer import Pattern, PatternRecognizer, RecognizerResult
from typing import List, Optional
 
 
class KrRrnRecognizer(PatternRecognizer):
    """주민등록번호 Recognizer — 체크섬 통과 여부에 따라 score를 분기합니다."""
 
    PATTERNS = [
        Pattern(
            "KR_RRN",
            r"\b(\d{2})(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])"
            r"\s?[-\u2013]?\s?([1-4]\d{6})\b",
            0.3,
        ),
    ]
    CONTEXT = [
        "주민등록번호", "주민번호", "주민",
        "resident registration", "RRN", "생년월일",
    ]
 
    def __init__(self):
        super().__init__(
            supported_entity="KR_RRN",
            patterns=self.PATTERNS,
            context=self.CONTEXT,
            supported_language="ko",
        )
 
    @staticmethod
    def _checksum_valid(digits: str) -> bool:
        weights = [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5]
        total = sum(int(d) * w for d, w in zip(digits[:12], weights))
        check = (11 - (total % 11)) % 10
        return check == int(digits[12])
 
    def validate_result(self, pattern_text: str) -> bool:
        digits = "".join(filter(str.isdigit, pattern_text))
        if len(digits) != 13:
            return False
        # 형식 검증만 수행 — score 분기는 analyze에서 처리
        return True
 
    def analyze(
        self, text: str, entities: List[str], nlp_artifacts=None, regex_flags=None,
    ) -> List[RecognizerResult]:
        results = super().analyze(
            text, entities, nlp_artifacts, regex_flags,
        )
        for result in results:
            matched = text[result.start : result.end]
            digits = "".join(filter(str.isdigit, matched))
            if len(digits) == 13 and self._checksum_valid(digits):
                result.score = max(result.score, 0.85)
            # 체크섬 실패 시 score 0.3 유지 → 컨텍스트 분석에 의존
        return results

from presidio_analyzer import Pattern, PatternRecognizer
 
 
class KrBrnRecognizer(PatternRecognizer):
    PATTERNS = [
        Pattern(
            "KR_BRN",
            r"\b(\d{3})[-\u2013]?(\d{2})[-\u2013]?(\d{5})\b",
            0.3,
        ),
    ]
    CONTEXT = [
        "사업자등록번호", "사업자번호", "사업자",
        "business registration", "BRN", "법인",
    ]
 
    def __init__(self):
        super().__init__(
            supported_entity="KR_BRN",
            patterns=self.PATTERNS,
            context=self.CONTEXT,
            supported_language="ko",
        )
 
    def validate_result(self, pattern_text: str) -> bool:
        digits = "".join(filter(str.isdigit, pattern_text))
        if len(digits) != 10:
            return False
 
        keys = [1, 3, 7, 1, 3, 7, 1, 3, 5]
        total = sum(int(d) * k for d, k in zip(digits[:9], keys))
        total += (int(digits[8]) * 5) // 10
 
        return (10 - (total % 10)) % 10 == int(digits[9])

from presidio_analyzer import Pattern, PatternRecognizer
 
 
class KrPassportRecognizer(PatternRecognizer):
    PATTERNS = [
        Pattern(
            "KR_PASSPORT_NEW",
            r"\b[A-Z]\d{3}[A-Z]\d{4}\b",
            0.4,
        ),
        Pattern(
            "KR_PASSPORT_OLD",
            r"\b[A-Z]{1}\d{8}\b",
            0.3,
        ),
    ]
    CONTEXT = [
        "여권", "여권번호", "passport", "PASSPORT", "travel document",
    ]
 
    def __init__(self):
        super().__init__(
            supported_entity="KR_PASSPORT",
            patterns=self.PATTERNS,
            context=self.CONTEXT,
            supported_language="ko",
        )

from presidio_analyzer import AnalyzerEngine
 
analyzer = AnalyzerEngine()
analyzer.registry.add_recognizer(KrRrnRecognizer())
analyzer.registry.add_recognizer(KrBrnRecognizer())
analyzer.registry.add_recognizer(KrPassportRecognizer())
 
 
def test_rrn_with_valid_checksum():
    """체크섬이 유효한 주민등록번호 — score가 0.85 이상이어야 합니다."""
    # 8211111111118: 체크섬 통과하는 테스트용 번호
    results = analyzer.analyze(
        text="주민등록번호: 821011-1234561",
        language="ko",
        entities=["KR_RRN"],
    )
    assert len(results) >= 1
    rrn_results = [r for r in results if r.entity_type == "KR_RRN"]
    # 컨텍스트("주민등록번호") + 체크섬 통과 시 높은 score
    print(f"[RRN 체크섬 통과] score: {rrn_results[0].score}")
 
 
def test_rrn_without_context():
    """컨텍스트 단어 없이 주민등록번호 패턴만 — score가 낮아야 합니다."""
    results = analyzer.analyze(
        text="참고번호 821011-1234561",
        language="ko",
        entities=["KR_RRN"],
    )
    rrn_results = [r for r in results if r.entity_type == "KR_RRN"]
    if rrn_results:
        print(f"[RRN 컨텍스트 없음] score: {rrn_results[0].score}")
        # 컨텍스트 없으면 체크섬 통과해도 0.85 수준에 머묾
    else:
        print("[RRN 컨텍스트 없음] 탐지 안 됨")
 
 
def test_brn_valid():
    """유효한 사업자등록번호 탐지."""
    results = analyzer.analyze(
        text="사업자등록번호: 123-45-67890",
        language="ko",
        entities=["KR_BRN"],
    )
    brn_results = [r for r in results if r.entity_type == "KR_BRN"]
    print(f"[BRN] 탐지 수: {len(brn_results)}")
    for r in brn_results:
        print(f"  matched: '{text[r.start:r.end]}', score: {r.score}")
 
 
def test_brn_false_positive():
    """전화번호가 사업자번호로 오탐되지 않아야 합니다."""
    results = analyzer.analyze(
        text="연락처: 010-1234-5678",
        language="ko",
        entities=["KR_BRN"],
    )
    brn_results = [r for r in results if r.entity_type == "KR_BRN"]
    print(f"[BRN false positive] 탐지 수: {len(brn_results)} (0이면 정상)")
 
 
def test_passport():
    """여권번호 탐지 — 컨텍스트가 있을 때 score가 높아야 합니다."""
    results = analyzer.analyze(
        text="여권번호는 M123A4567입니다",
        language="ko",
        entities=["KR_PASSPORT"],
    )
    pp_results = [r for r in results if r.entity_type == "KR_PASSPORT"]
    print(f"[여권] 탐지 수: {len(pp_results)}")
    for r in pp_results:
        print(f"  score: {r.score}")
 
 
if __name__ == "__main__":
    test_rrn_with_valid_checksum()
    test_rrn_without_context()
    test_brn_valid()
    test_brn_false_positive()
    test_passport()

# recognizers-config.yml
recognizers:
  - name: "KrPassportRecognizer"
    type: "custom"
    supported_entity: "KR_PASSPORT"
    supported_language: "ko"
    patterns:
      - name: "kr_passport_new"
        regex: "\\b[A-Z]\\d{3}[A-Z]\\d{4}\\b"
        score: 0.4
      - name: "kr_passport_old"
        regex: "\\b[A-Z]\\d{8}\\b"
        score: 0.3
    context:
      - "여권"
      - "여권번호"
      - "passport"

from presidio_analyzer import AnalyzerEngine
from presidio_analyzer.recognizer_registry import RecognizerRegistryProvider
 
provider = RecognizerRegistryProvider(conf_file="./recognizers-config.yml")
registry = provider.create_recognizer_registry()
analyzer = AnalyzerEngine(registry=registry)
 
results = analyzer.analyze(
    text="여권번호는 M123A4567입니다",
    language="ko",
)

사용자 입력                          LLM 프록시                         최종 응답
"주민번호 900101-1234567"
    → Presidio Analyzer (PII 탐지)
        → "주민번호 <KR_RRN>" (마스킹된 프롬프트)
            → GPT-4 (응답 생성)
                → Presidio Anonymizer (복원/마스킹 유지)
                    → 사용자에게 전달