feat(analyzer): add Korean bank account number recognizer (KR_BANK_ACCOUNT)

Author: juno-junho

docs/supported_entities.md

@@ -113,6 +113,7 @@ For more information, refer to the [adding new recognizers documentation](analyz
 | KR_PASSPORT| The Korean Passport Number  | Pattern match, context. |
 | KR_BRN     | The Korean Business Registration Number (BRN) is a 10-digit number assigned to business entities for taxation purposes. | Pattern match, context and custom logic. |
 | KR_RRN     | The Korean Resident Registration Number (RRN) is a 13-digit number issued to all Korean residents. | Pattern match, context and custom logic. |
+| KR_BANK_ACCOUNT | The Korean bank account number: 10-14 digit bank-specific formats with no unified checksum. | Pattern match, context. |
 
 
 ### Nigeria

presidio-analyzer/presidio_analyzer/conf/default_recognizers.yaml

@@ -279,6 +279,14 @@ recognizers:
     type: predefined
     country_code: pl
 
+  - name: KrBankAccountRecognizer
+    supported_languages:
+    - ko
+    - kr
+    type: predefined
+    enabled: false
+    country_code: kr
+
   - name: KrBrnRecognizer
     supported_languages: 
     - ko

presidio-analyzer/presidio_analyzer/predefined_recognizers/__init__.py

@@ -62,6 +62,9 @@
 from .country_specific.italy.it_vat_code import ItVatCodeRecognizer
 
 # Korea recognizers
+from .country_specific.korea.kr_bank_account_recognizer import (
+    KrBankAccountRecognizer,
+)
 from .country_specific.korea.kr_brn_recognizer import KrBrnRecognizer
 from .country_specific.korea.kr_driver_license_recognizer import (
     KrDriverLicenseRecognizer,
@@ -271,6 +274,7 @@
     "UkPostcodeRecognizer",
     "UkVehicleRegistrationRecognizer",
     "AzureHealthDeidRecognizer",
+    "KrBankAccountRecognizer",
     "KrBrnRecognizer",
     "KrRrnRecognizer",
     "KrDriverLicenseRecognizer",

presidio-analyzer/presidio_analyzer/predefined_recognizers/country_specific/korea/__init__.py

@@ -1,17 +1,17 @@
 """Korea-specific recognizers."""
 
+from .kr_bank_account_recognizer import KrBankAccountRecognizer
 from .kr_brn_recognizer import KrBrnRecognizer
 from .kr_driver_license_recognizer import KrDriverLicenseRecognizer
 from .kr_frn_recognizer import KrFrnRecognizer
 from .kr_passport_recognizer import KrPassportRecognizer
 from .kr_rrn_recognizer import KrRrnRecognizer
 
 __all__ = [
-    "KrDriverLicenseRecognizer",
-    "KrPassportRecognizer",
-    "KrFrnRecognizer",
+    "KrBankAccountRecognizer",
     "KrBrnRecognizer",
     "KrDriverLicenseRecognizer",
+    "KrFrnRecognizer",
     "KrPassportRecognizer",
     "KrRrnRecognizer",
 ]

presidio-analyzer/presidio_analyzer/predefined_recognizers/country_specific/korea/kr_bank_account_recognizer.py

@@ -0,0 +1,86 @@
+from typing import List, Optional
+
+from presidio_analyzer import Pattern, PatternRecognizer
+
+
+class KrBankAccountRecognizer(PatternRecognizer):
+    """
+    Recognize Korean bank account numbers.
+
+    Korean bank account numbers are 10-14 digit identifiers issued in
+    bank-specific segment layouts, commonly written with hyphens
+    (e.g. NongHyup's 302-XXXX-XXXX-XX personal accounts, or common
+    three-segment forms such as 110-234-567890). No unified national
+    format or check digit exists, so precision comes from structural
+    patterns plus negative lookaheads that exclude look-alike shapes:
+    Korean mobile/VoIP phone numbers (010/011/016/017/019/070),
+    resident registration numbers and calendar dates.
+
+    Reference: per-bank layouts (e.g. NongHyup's 3YY-XXXX-XXXX-CC
+    personal accounts) are documented at
+    https://namu.wiki/w/%EA%B3%84%EC%A2%8C%EB%B2%88%ED%98%B8
+    Patterns were validated in a production Korean PII-masking deployment.
+
+    :param patterns: List of patterns to be used by this recognizer
+    :param context: List of context words to increase confidence in detection
+    :param supported_language: Language this recognizer supports
+    :param supported_entity: The entity this recognizer can detect
+    """
+
+    COUNTRY_CODE = "kr"
+
+    PATTERNS = [
+        Pattern(
+            "NH 4-segment account (Medium)",
+            r"(?<!\d)302-\d{3,4}-\d{3,4}-\d{2}(?!\d)",
+            0.6,
+        ),
+        Pattern(
+            "Hyphenated 3-segment account (Weak)",
+            r"(?<!\d)(?!(?:01[01679]|070)-\d{3,4}-\d{4}(?!\d))"
+            r"(?!\d{4}[-./]\d{1,2}[-./]\d{1,2}(?!\d))(?=(?:\d-?){9,16}(?!\d))"
+            r"\d{2,3}-\d{2,6}-\d{1,7}(?!\d)",
+            0.3,
+        ),
+        Pattern(
+            "Mixed-separator account (Very weak)",
+            r"(?<!\d)(?!\d{6}-?\d{7}(?!\d))"
+            r"(?!(?:01[01679]|070)[- ]?\d{3,4}[- ]?\d{4}(?!\d))"
+            r"(?!\d{4}[-./]\d{1,2}[-./]\d{1,2}(?!\d))(?=(?:\d[- ]?){9,16}(?!\d))"
+            r"\d{2,4}(?:[- ]?\d{2,6})(?:[- ]?\d{1,7})(?:[- ]?\d{1,3})?(?!\d)",
+            0.15,
+        ),
+    ]
+
+    CONTEXT = [
+        "계좌",
+        "계좌번호",
+        "예금주",
+        "송금",
+        "입금",
+        "입금계좌",
+        "출금",
+        "이체",
+        "타행",
+        "은행",
+        "bank account",
+        "account number",
+    ]
+
+    def __init__(
+        self,
+        patterns: Optional[List[Pattern]] = None,
+        context: Optional[List[str]] = None,
+        supported_language: str = "ko",
+        supported_entity: str = "KR_BANK_ACCOUNT",
+        name: Optional[str] = None,
+    ):
+        patterns = patterns if patterns else self.PATTERNS
+        context = context if context else self.CONTEXT
+        super().__init__(
+            supported_entity=supported_entity,
+            patterns=patterns,
+            context=context,
+            supported_language=supported_language,
+            name=name,
+        )

presidio-analyzer/tests/test_kr_bank_account_recognizer.py

@@ -0,0 +1,65 @@
+import pytest
+
+from tests import assert_result_within_score_range
+from presidio_analyzer.predefined_recognizers.country_specific.korea import (
+    KrBankAccountRecognizer,
+)
+
+
+@pytest.fixture(scope="module")
+def recognizer():
+    return KrBankAccountRecognizer()
+
+
+@pytest.fixture(scope="module")
+def entities():
+    return ["KR_BANK_ACCOUNT"]
+
+
+# Patterns overlap by design (an NH account also matches the generic layouts),
+# so positive cases assert on the best-scoring match instead of result counts.
+@pytest.mark.parametrize(
+    "text, start, end, score",
+    [
+        # NH (NongHyup) 302-prefixed 4-segment personal account
+        ("302-1234-5678-91", 0, 16, 0.6),
+        ("이체 계좌: 302-0123-4567-89", 7, 23, 0.6),
+        # Common hyphenated 3-segment layouts
+        ("110-234-567890", 0, 14, 0.3),
+        ("457-910-012345", 0, 14, 0.3),
+        # Mixed/plain digit runs (9-16 digits, excluding the 13-digit RRN shape)
+        ("987654321012", 0, 12, 0.15),
+        ("1002-123-456789", 0, 15, 0.15),
+    ],
+)
+def test_when_account_like_then_best_match_found(
+    text, start, end, score, recognizer, entities
+):
+    results = recognizer.analyze(text, entities)
+    assert results
+    best = max(results, key=lambda r: r.score)
+    assert_result_within_score_range(best, entities[0], start, end, score, score)
+
+
+@pytest.mark.parametrize(
+    "text",
+    [
+        # Korean mobile / VoIP phone numbers must not match
+        "010-1234-5678",
+        "070-1234-5678",
+        "01012345678",
+        "07012345678",
+        # Resident registration number shapes must not match
+        "960121-1234567",
+        "9601211234567",
+        # Any 13-digit pure run is left to KR_RRN's domain
+        "9876543210123",
+        # Dates must not match
+        "2024-03-10",
+        # Too short
+        "45000",
+        "12345678",
+    ],
+)
+def test_when_look_alike_then_no_match(text, recognizer, entities):
+    assert recognizer.analyze(text, entities) == []