# 한국어 개인정보 찾기: 정규식과 Presidio 비교, 스캔 결과와 마스킹

> 주민등록번호 형식, 휴대전화 번호, 이메일, 사업자등록번호, 카드 번호를 직접 만든 가짜 파일 3개에서 찾습니다. 형식만 보는 정규식, 검증 로직을 붙인 정규식, Presidio 기본, Presidio에 한국어 recognizer를 더한 방식을 같은 정답표로 채점해 탐지, 오탐, 미탐을 표로 비교하고 앞 6자리만 남기는 마스킹까지 해 봅니다.

- 주소: https://copyandrun.com/blog/korean-pii-regex-presidio-scan/
- 분야: 개인정보·컴플라이언스
- 발행일: 2026-11-02
- 태그: 개인정보, 정규식, Presidio, 마스킹, 주민등록번호

로그나 문서 묶음에 개인정보가 섞여 있는지 확인할 때 가장 먼저 떠올리는 방법이 정규식이고, 다음으로 많이 거론되는 도구가 Microsoft Presidio입니다. 이 글은 두 방법에 같은 가짜 파일을 넣고 무엇을 찾고, 무엇을 잘못 찾고, 무엇을 놓치는지 숫자로 비교합니다.

Windows Git Bash에서 Docker Desktop으로 실행했습니다. 시험 데이터는 전부 스크립트가 만든 가짜 값이며 실제 사람의 정보는 없습니다. 주민등록번호 형식의 값은 생년월일과 검증 숫자 규칙만 맞춘 임의 번호이고, 글과 화면에는 앞 6자리만 보이게 했고, 뒤 7자리는 탐지 여부와 상관없이 출력 단계에서 가립니다. 생년월일과 검증 숫자 규칙을 따르는 임의 번호라 우연히 실제 번호와 같을 수 있으므로 전체 자리를 화면에 싣지 않습니다. 이 글의 결과는 법적 판단이 아니라 탐지 도구의 동작 비교이며, 개인정보를 실제로 다룰 때는 소속 조직의 기준과 관련 법령을 따로 확인해야 합니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| 실행 환경 | Docker 컨테이너 1개(`cr-p20-scan`), `python:3.12-slim` 기반 |
| Python | 3.12.16 |
| presidio-analyzer | 2.2.366 |
| spaCy / 모델 | 3.8.18 / `en_core_web_sm` 3.8.0 (영어 작은 모델) |
| phonenumbers | 9.0.42 (Presidio 의존 패키지) |

작업 폴더는 아래 다섯 파일입니다. 전체 내용은 글 끝의 `## 전체 코드`에 있습니다. 서버 포트는 열지 않고 컨테이너 안에서만 실행합니다.

```
Dockerfile
make_data.py
scan_regex.py
scan_presidio.py
compare.py
```

## 1. 컨테이너 만들기

<!-- files: Dockerfile -->

`Dockerfile`은 Presidio와 spaCy를 설치하고 영어 작은 모델만 내려받습니다. Presidio 기본 설정이 쓰는 큰 모델(`en_core_web_lg`)은 받지 않아서 이미지가 가볍습니다. 작은 모델로 바꾸는 설정은 4단계의 `scan_presidio.py`에 있습니다.

```bash
docker build -q -t cr-p20-scan:latest .
docker run -d --name cr-p20-scan cr-p20-scan:latest
docker ps --filter name=cr-p20 --format "table {{.Names}}\t{{.Image}}\t{{.Status}}"
docker exec cr-p20-scan sh -c 'python --version; pip list 2>/dev/null | grep -iE "^(presidio|spacy |phonenumbers|en.core)"'
```

![컨테이너 cr-p20-scan이 올라와 있고 Python 3.12.16, presidio_analyzer 2.2.366, spacy 3.8.18, en_core_web_sm 3.8.0이 설치된 것을 확인합니다.](https://copyandrun.com/img/korean-pii-regex-presidio-scan/01-container-versions.png)

## 2. 가짜 시험 데이터 만들기

<!-- files: make_data.py -->

`make_data.py`는 세 파일과 정답표를 만듭니다. 고정된 난수 씨앗을 써서 매번 같은 값이 나옵니다.

- `customers.csv`: 정상 서식으로 쓴 고객 6행(휴대전화, 이메일, 주민등록번호 형식)
- `memo.txt`: 상담 메모 문장. 하이픈 없는 번호, 공백으로 쓴 번호, `+82` 표기, 한글로 풀어 쓴 번호, 검증 숫자가 맞지 않는 번호, 사업자등록번호, 카드 번호가 섞여 있습니다.
- `orders.txt`: 개인정보가 아닌데 모양이 비슷한 값. 날짜처럼 보이는 앞 6자리와 검증 숫자가 틀린 뒤 7자리로 만든 주문번호와 송장번호, 16자리 주문 묶음 번호, 검증이 안 되는 상품 코드입니다.
- `labels.json`: 진짜 개인정보 33건의 종류와 위치. 탐지 결과를 채점하는 정답표입니다.

```bash
docker exec cr-p20-scan python make_data.py
docker exec cr-p20-scan sh -c "head -4 data/customers.csv | sed -E 's/([0-9]{6}-?)[1-4][0-9]{6}/\1*******/'; echo; sed -E 's/([0-9]{6}-?)[1-4][0-9]{6}/\1*******/' data/orders.txt"
```

성별 자리를 포함한 뒤 7자리는 `sed`로 가려서 화면에 찍었습니다.

![customers.csv 앞 4줄과 orders.txt가 보이고, 주문번호와 송장번호가 주민등록번호처럼 6자리 뒤에 7자리 형태인 것을 확인합니다.](https://copyandrun.com/img/korean-pii-regex-presidio-scan/02-fake-data-masked.png)

주문번호 `260703-*******`은 생년월일처럼 읽히는 값입니다. 형식만 보는 방법은 이 값을 주민등록번호로 착각합니다.

## 3. 정규식과 검증 로직

<!-- files: scan_regex.py -->

`scan_regex.py`는 다섯 종류의 정규식을 두고, `validate=True`일 때 아래 검증으로 후보를 걸러 냅니다.

| 종류 | 정규식이 보는 것 | 검증 로직 |
|---|---|---|
| 주민등록번호 형식 | 숫자 6자리, 하이픈은 선택, 1~4 한 자리, 숫자 6자리 | 앞 6자리가 실제 달력에 있는 생년월일인지, 마지막 숫자가 검증 숫자 계산과 같은지 |
| 휴대전화 | `010` 또는 `+82 10` 뒤 4자리와 4자리, 구분은 하이픈이나 공백 | 없음 |
| 이메일 | 일반적인 이메일 모양(이름, 골뱅이표, 도메인, 최상위 도메인) | 없음 |
| 사업자등록번호 | `3자리-2자리-5자리` | 가중치 합으로 마지막 숫자 확인 |
| 카드 번호 | 16자리, 4자리마다 하이픈이나 공백 허용 | Luhn 검사 |

검증 함수가 맞게 동작하는지는 잘 알려진 시험용 카드 번호로 확인했습니다. 마지막 숫자를 바꾸면 거부됩니다.

```bash
docker exec cr-p20-scan python -c "import scan_regex as s; print(s.luhn_ok('4111111111111111'), s.luhn_ok('4111111111111112'))"
```

```
True False
```

## 4. Presidio 설정과 한국어 recognizer

<!-- files: scan_presidio.py -->

공식 문서(`presidio.dataprivacystack.org`)에서 확인한 내용은 이렇습니다. 지원 개체 목록에 한국용 `KR_RRN`(주민등록번호), `KR_BRN`(사업자등록번호), `KR_FRN`, `KR_PASSPORT`, `KR_DRIVER_LICENSE`가 있고, 언어 문서는 기본 제공이 영어용 recognizer와 모델이라고 설명하며 다른 언어를 쓰려면 NLP 엔진과 recognizer를 함께 바꿔야 한다고 안내합니다. 또 recognizer 하나는 언어 하나만 지원합니다.

설치한 2.2.366에서 직접 확인한 것도 같습니다. 기본 상태에서는 한국어 recognizer가 하나도 등록되지 않고, 한국어 NLP 모델도 없습니다. 그래서 `scan_presidio.py`는 두 방식을 만듭니다.

- **Presidio 기본**: 기본 recognizer만 사용합니다.
- **Presidio+한국어**: 내장 `KrRrnRecognizer`, `KrBrnRecognizer`를 더하고, 직접 만든 `PatternRecognizer`(`KR_MOBILE`)로 `010` 휴대전화 정규식을 등록합니다.

내장 한국어 recognizer의 기본 언어는 `ko`입니다. 이 실습은 영어 모델 하나만 설치해 모든 분석을 `en`으로 돌리므로, `supported_language="en"`으로 다시 만들어 등록했습니다.

```bash
docker exec cr-p20-scan python -c "import scan_presidio as p; e = p.build(True); print([(r.name, r.supported_language) for r in e.registry.recognizers if r.name.startswith(('Kr', 'Pattern'))]); print([r.supported_regions for r in e.registry.recognizers if r.name == 'PhoneRecognizer']); print(e.nlp_engine.get_supported_languages())"
```

```
[('KrRrnRecognizer', 'en'), ('KrBrnRecognizer', 'en'), ('PatternRecognizer', 'en')]
[('US', 'GB', 'DE', 'FR', 'IL', 'IN', 'CA', 'BR')]
['en']
```

두 번째 줄이 중요합니다. 기본 `PhoneRecognizer`가 보는 지역에 한국이 없어서, 한국 휴대전화 번호는 그대로 두면 거의 찾지 못합니다. 그래서 `KR_MOBILE`을 직접 추가했습니다.

## 5. 네 가지 방식 비교

<!-- files: compare.py -->

`compare.py`는 네 방식으로 `data/`의 세 파일을 스캔하고, `labels.json`의 위치와 겹치면 정탐, 겹치지 않는 탐지는 오탐, 겹치는 탐지가 없는 정답은 미탐으로 셉니다. Presidio는 점수 0.5 이상만 결과로 받았습니다. 출력에는 원래 값을 찍지 않습니다.

```bash
docker exec cr-p20-scan python compare.py
```

```
정답 33건 (RRN 9, PHONE 10, EMAIL 8, BRN 3, CARD 3)

방식                 탐지   정탐   오탐   미탐
형식만 정규식        37   30    7    3
검증 정규식          29   29    0    4
Presidio 기본        10   10    0   23
Presidio+한국어      34   30    4    3

종류별 정탐 수 (정답 수 대비)
방식                   RRN   PHONE   EMAIL     BRN    CARD
형식만 정규식        8/9     9/10    7/8     3/3     3/3  
검증 정규식          7/9     9/10    7/8     3/3     3/3  
Presidio 기본        0/9     0/10    7/8     0/3     3/3  
Presidio+한국어      8/9     9/10    7/8     3/3     3/3  

Presidio 가 개인정보 5종 밖에서 낸 엔티티(임계값 0.5 이상): {'PERSON': 2, 'DATE_TIME': 14, 'ORGANIZATION': 2, 'URL': 7}
Presidio+한국어의 RRN 점수 분포: {1.0: 7, 0.5: 5}
```

![네 방식의 탐지, 정탐, 오탐, 미탐 수와 종류별 정탐 수가 표로 나오고, 검증 정규식은 오탐 0건, Presidio 기본은 미탐 23건인 것을 확인합니다.](https://copyandrun.com/img/korean-pii-regex-presidio-scan/03-compare-summary.png)

읽는 법입니다.

- 형식만 보는 정규식은 오탐이 7건입니다. 주문번호, 송장번호, 16자리 주문 묶음 번호 2건, 상품 코드가 모두 개인정보로 잡혔습니다.
- 검증을 붙이면 오탐이 0건이 되지만, 검증 숫자가 맞지 않는 주민등록번호 형식 값이 미탐으로 바뀝니다. 일부 신규 번호는 이 검증 규칙을 따르지 않는 것으로 알려져 있으나 공식 자료는 확인하지 못했습니다. 행정안전부 보도자료(`https://www.korea.kr/news/policyNewsView.do?newsId=148872723`)는 2020년 10월부터 신규 번호의 뒷자리가 성별 표시 첫 자리를 제외하고 6자리 임의번호가 된다고만 밝히고, 그 안에 검증 숫자가 있는지는 적지 않았습니다. 그래서 이 글의 검증 정규식이 놓치는 번호가 실제로 있는지는 단정하지 않습니다.
- Presidio 기본은 카드 번호와 이메일만 찾습니다. 카드는 Luhn 검사를 거쳐 16자리 주문 묶음 번호는 걸러졌습니다. 휴대전화, 주민등록번호, 사업자등록번호는 0건이었습니다.
- Presidio+한국어는 정탐 30건이지만 오탐이 4건입니다. 내장 `KR_RRN`은 검증 숫자가 맞으면 점수 1.0, 맞지 않으면 0.5로 두기 때문에 주문번호 같은 값이 0.5로 남습니다. 점수 분포가 `{1.0: 7, 0.5: 5}`인 이유입니다. 0.5는 오탐 4건과 검증 숫자가 맞지 않는 진짜 번호 1건입니다.

임계값을 0.6으로 올려 주문 파일을 다시 스캔하면 오탐이 사라집니다.

```bash
docker exec cr-p20-scan python -c "import scan_presidio as p; e = p.build(True); t = open('data/orders.txt', encoding='utf-8').read(); print(len(p.scan_text(e, t, 0.5)[0]), len(p.scan_text(e, t, 0.6)[0]))"
```

```
4 0
```

다만 같은 임계값이면 `memo.txt`의 검증 숫자가 맞지 않는 진짜 번호도 사라집니다. 점수 기준은 오탐과 미탐을 맞바꾸는 조절 장치입니다.

## 6. 어떤 값을 틀렸는지 보기

```bash
docker exec cr-p20-scan python compare.py --detail
```

![형식만 정규식의 오탐 7건(주문번호, 송장번호, 카드형 번호, 상품 코드)과 세 방식이 공통으로 놓친 memo.txt의 세 값이 가려진 상태로 나열된 것을 확인합니다.](https://copyandrun.com/img/korean-pii-regex-presidio-scan/04-false-positive-miss.png)

세 방식이 모두 놓친 것은 `memo.txt`의 세 값입니다.

- 공백으로 쓴 주민등록번호 형식 값(`991231 *******`)
- 한글로 쓴 전화번호(공일공-오오오공-사오육칠)
- 문자로 풀어 쓴 이메일(`memo02 at example dot com`)

정규식 모양을 늘려 잡으면 일부는 찾을 수 있지만 그만큼 오탐도 늘어납니다. 사람이 알아볼 수 있게 변형한 표기는 도구로 끝까지 막기 어렵다는 점을 기억해 둡니다.

Presidio가 개인정보 5종 밖에서 낸 결과도 봐 둘 만합니다. 영어 모델로 한국어 문장을 분석했기 때문에 `DATE_TIME` 14건, `PERSON` 2건, `ORGANIZATION` 2건이 나왔는데, 다수는 숫자 열이나 한국어 문장 조각을 잘못 읽은 것이었습니다. 이름과 주소를 찾는 NER 기능은 한국어에서는 이 설정으로 쓰기 어렵고, 한국어 개인정보 탐지는 사실상 정규식 기반 recognizer가 맡습니다.

## 7. 마스킹하고 남은 것 확인

`compare.py --mask`는 검증 정규식이 찾은 값을 가립니다. 정규식이 놓친 값이 그대로 남지 않도록, 주민등록번호 모양(6자리와 7자리)은 탐지 여부와 상관없이 마지막에 한 번 더 앞 6자리만 남기고 가립니다. 주민등록번호, 카드 번호, 사업자등록번호는 앞에서 남길 숫자 수를 정해 두었고(주민등록번호 앞 6자리, 카드 앞 6자리, 사업자등록번호 앞 3자리), 전화번호는 뒤 8자리를, 이메일은 `@` 앞부분을 가립니다.

```bash
docker exec cr-p20-scan python compare.py --mask memo.txt
```

```
--- out/memo.txt (검증 정규식 결과로 가림)
상담 메모 (시험용 가짜 데이터)
고객이 구두로 알려 준 번호는 880808******* 이고 하이픈 없이 적었음.
다른 고객은 991231 ******* 처럼 공백으로 적음.
신규 발급 형식이라는 050505-******* 도 접수됨.
휴대전화는 010******** 또는 +82 10-****-****.
다른 표기: 010 **** **** 와 공일공-오오오공-사오육칠.
이메일 ***@example.com 로 회신, 또는 memo02 at example dot com 으로 보내 달라고 함.
사업자등록번호 356-**-*****, 697-**-*****, 551-**-*****.
결제 카드 4477-87**-****-****, 5122 76** **** ****, 357965**********.
```

![주민등록번호 모양은 모두 앞 6자리만 남고 가려졌고, 한글 전화번호와 문자 이메일은 가려지지 않고 그대로 남은 것을 확인합니다.](https://copyandrun.com/img/korean-pii-regex-presidio-scan/05-masked-memo.png)

가려진 결과보다 가려지지 않은 줄이 더 중요합니다. 공백으로 쓴 번호와 검증 숫자가 맞지 않는 번호는 탐지에서 빠졌지만 주민등록번호 모양 규칙 덕분에 가려졌습니다. 반면 한글 전화번호와 문자 이메일처럼 모양 규칙에도 걸리지 않는 값은 원본이 그대로 결과 파일에 남습니다. 마스킹이 끝났다는 것은 탐지 도구가 찾은 범위에 한정된 이야기이고, 파일에 개인정보가 더 없다는 뜻이 아닙니다.

## 개인정보를 다룰 때 일반 주의

- 스캔 결과 파일 자체가 개인정보가 됩니다. `compare.py`는 값을 찍지 않고 가린 값과 위치만 출력하게 만들었습니다. 원본 값이 든 결과를 남기지 않습니다.
- 스캔에 쓴 원본과 결과는 필요한 기간만 보관하고 끝나면 지웁니다. 이 글은 컨테이너를 지우는 것으로 마무리합니다.
- 사람이 읽는 화면과 로그에는 가린 값만 보이게 합니다. 원본이 필요한 단계와 가려진 값만 필요한 단계를 나눕니다.
- 자동 탐지는 후보를 줄이는 용도입니다. 미탐이 있으므로 사람이 표본으로 다시 봅니다.

## 결과 정리

- 주민등록번호 형식은 생년월일과 검증 숫자 확인을 붙이면 날짜처럼 보이는 번호를 걸러 내지만, 검증 숫자 규칙을 따르지 않는 번호는 놓칩니다. 그런 번호가 실제로 있는지는 확인하지 못했으나, 미탐을 줄이려면 형식만 일치한 후보를 따로 모아 사람이 봅니다.
- 카드 번호는 Luhn, 사업자등록번호는 가중치 합 검증을 붙이면 오탐이 사라졌습니다.
- Presidio 기본은 한국 번호 형식을 거의 못 찾습니다. 내장 `KR_RRN`, `KR_BRN`을 등록하고 휴대전화는 직접 만든 recognizer로 채우면 정규식과 비슷한 수준이 됩니다.
- Presidio의 이점은 recognizer 등록, 점수, 마스킹 연계 구조이고, 한국어 문장 이해는 이 설정에서 기대하기 어렵습니다.

## 전체 코드

작업 폴더 구조는 아래와 같습니다.

```
Dockerfile
make_data.py
scan_regex.py
scan_presidio.py
compare.py
```

### Dockerfile

```dockerfile
FROM python:3.12-slim
WORKDIR /work
RUN pip install --no-cache-dir presidio-analyzer==2.2.366 spacy==3.8.18 \
 && python -m spacy download en_core_web_sm
COPY make_data.py scan_regex.py scan_presidio.py compare.py /work/
CMD ["sleep", "3600"]
```

### make_data.py

```python
"""시험용 가짜 개인정보 파일과 정답표(labels.json)를 만듭니다. 실제 사람의 정보는 없습니다.

주민등록번호 형식 값은 생년월일과 검증 숫자 규칙만 맞춘 임의 번호입니다.
앞 6자리와 뒤 7자리를 따로 조합해 만들며, 이 스크립트의 출력에는 그대로 찍지 않습니다.
"""
import json
import random
from pathlib import Path

rnd = random.Random(20261102)
AT = "@"                       # 이메일 주소를 소스에 그대로 쓰지 않으려고 따로 둡니다
OUT = Path("data")


def rrn_check(first12):
    w = [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5]
    s = sum(int(c) * k for c, k in zip(first12, w))
    return str((11 - s % 11) % 10)


def make_rrn(birth6, gender, valid=True):
    tail6 = "".join(str(rnd.randint(0, 9)) for _ in range(5))
    first12 = (birth6 + str(gender) + tail6)[:12]
    check = rrn_check(first12)
    if not valid:                                       # 검증 숫자를 일부러 틀리게 만든 값
        check = str((int(check) + 3) % 10)
    return birth6, first12[6:] + check


def luhn_ok(num):
    total = 0
    for i, c in enumerate(reversed(num)):
        d = int(c)
        if i % 2 == 1:
            d = d * 2 - 9 if d * 2 > 9 else d * 2
        total += d
    return total % 10 == 0


def make_card(prefix):
    while True:
        body = prefix + "".join(str(rnd.randint(0, 9)) for _ in range(15 - len(prefix)))
        for chk in range(10):
            if luhn_ok(body + str(chk)):
                return body + str(chk)


def not_luhn_16():
    while True:
        n = "".join(str(rnd.randint(0, 9)) for _ in range(16))
        if not luhn_ok(n):
            return n


def make_brn(valid=True):
    d = [rnd.randint(1, 9) for _ in range(3)] + [rnd.randint(1, 9) for _ in range(2)] + [rnd.randint(0, 9) for _ in range(4)]
    w = [1, 3, 7, 1, 3, 7, 1, 3, 5]
    s = sum(a * b for a, b in zip(d, w)) + (d[8] * 5) // 10
    chk = (10 - s % 10) % 10
    if not valid:
        chk = (chk + 4) % 10
    t = "".join(map(str, d)) + str(chk)
    return f"{t[:3]}-{t[3:5]}-{t[5:]}"


truth = []     # {file, type, text}
files = {}


def put(name, text, kind=None, value=None):
    files.setdefault(name, []).append(text)
    if kind:
        truth.append({"file": name, "type": kind, "text": value})


def phone(mid="5550"):
    return f"{mid}-{rnd.randint(0, 9999):04d}"


# ---- customers.csv: 정상 서식 위주 ----
csv_rows = ["이름,연락처,이메일,주민등록번호,사업자등록번호,메모"]
births = ["900101", "851130", "010315", "770622", "030228", "950909"]
for i, b in enumerate(births, 1):
    g = 1 if int(b[:2]) > 25 else 3
    g = g + (i % 2)                                     # 1/2 또는 3/4
    front, back = make_rrn(b, g)
    rrn = f"{front}-{back}"
    ph = "010-" + phone()
    em = f"test{i:02d}" + AT + "example.com"
    csv_rows.append(f"시험고객{i:02d},{ph},{em},{rrn},,")
    truth += [{"file": "customers.csv", "type": t, "text": v} for t, v in
              (("PHONE", ph), ("EMAIL", em), ("RRN", rrn))]
files["customers.csv"] = csv_rows

# ---- memo.txt: 자유 문장 속 여러 서식, 놓치기 쉬운 표기 포함 ----
def t(kind, v):
    truth.append({"file": "memo.txt", "type": kind, "text": v})
    return v

f, b = make_rrn("880808", 1)
no_hyphen = f + b
f2, b2 = make_rrn("991231", 2)
spaced = f"{f2} {b2}"
f3, b3 = make_rrn("050505", 3, valid=True)
new_style = f"{f3}-{b3[:-1]}{(int(b3[-1]) + 3) % 10}"  # 2020년 10월 이후 발급처럼 검증 숫자가 맞지 않는 값
brn = [make_brn() for _ in range(3)]
cards = [make_card("4"), make_card("51"), make_card("35")]
lines = [
    "상담 메모 (시험용 가짜 데이터)",
    f"고객이 구두로 알려 준 번호는 {t('RRN', no_hyphen)} 이고 하이픈 없이 적었음.",
    f"다른 고객은 {spaced} 처럼 공백으로 적음.",
    f"신규 발급 형식이라는 {t('RRN', new_style)} 도 접수됨.",
    f"휴대전화는 {t('PHONE', '01055501234')} 또는 {t('PHONE', '+82 10-5550-2345')}.",
    f"다른 표기: {t('PHONE', '010 5550 3456')} 와 공일공-오오오공-사오육칠.",
    f"이메일 {t('EMAIL', 'memo01' + AT + 'example.com')} 로 회신, 또는 memo02 at example dot com 으로 보내 달라고 함.",
    f"사업자등록번호 {t('BRN', brn[0])}, {t('BRN', brn[1])}, {t('BRN', brn[2])}.",
    f"결제 카드 {t('CARD', cards[0][:4] + '-' + cards[0][4:8] + '-' + cards[0][8:12] + '-' + cards[0][12:])}, "
    f"{t('CARD', cards[1][:4] + ' ' + cards[1][4:8] + ' ' + cards[1][8:12] + ' ' + cards[1][12:])}, {t('CARD', cards[2])}.",
]
files["memo.txt"] = lines
truth += [{"file": "memo.txt", "type": "RRN", "text": spaced},
          {"file": "memo.txt", "type": "PHONE", "text": "공일공-오오오공-사오육칠"},
          {"file": "memo.txt", "type": "EMAIL", "text": "memo02 at example dot com"}]

# ---- orders.txt: 개인정보가 아닌데 모양이 비슷한 값(오탐 유도) ----
orders = ["주문 내역 (개인정보 없음, 시험용)"]
for i in range(3):
    # 생년월일처럼 보이는 앞 6자리 + 성별 자리 1~4 + 검증 숫자가 틀린 뒤 7자리
    front = f"26{rnd.randint(1, 12):02d}{rnd.randint(1, 28):02d}"
    _, back = make_rrn(front, rnd.randint(1, 4), valid=False)
    orders.append(f"주문번호 {front}-{back} 배송 완료")
orders.append(f"송장번호 {make_rrn('261102', 2, valid=False)[0]}{make_rrn('261102', 2, valid=False)[1]} 출고")
for i in range(2):
    n = not_luhn_16()
    orders.append(f"주문 묶음 번호 {n[:4]}-{n[4:8]}-{n[8:12]}-{n[12:]} 접수")
orders.append(f"상품 코드 {make_brn(valid=False)} 재고 확인")
orders.append("일시 2026-11-02 14:30, 문의 대표번호 02-555-0100, 버전 3.12 는 개인정보가 아님")
files["orders.txt"] = orders

OUT.mkdir(exist_ok=True)
for name, rows in files.items():
    (OUT / name).write_text("\n".join(rows) + "\n", encoding="utf-8", newline="\n")


for item in truth:
    text = (OUT / item["file"]).read_text(encoding="utf-8")
    s = text.find(item["text"])
    assert s >= 0, item
    item["start"], item["end"] = s, s + len(item["text"])
(OUT / "labels.json").write_text(json.dumps(truth, ensure_ascii=False, indent=1), encoding="utf-8")
print("만든 파일:", ", ".join(sorted(files)), "/ 정답표", len(truth), "건")
```

### scan_regex.py

```python
"""정규식으로 한국어 개인정보를 찾습니다. validate=True 이면 검증 로직으로 오탐을 거릅니다."""
import re
from datetime import date

PATTERNS = {
    "RRN": re.compile(r"(?<!\d)\d{6}-?[1-4]\d{6}(?!\d)"),
    "PHONE": re.compile(r"(?<!\d)(?:\+82[-\s]?10|010)[-\s]?\d{4}[-\s]?\d{4}(?!\d)"),
    "EMAIL": re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"),
    "BRN": re.compile(r"(?<!\d)\d{3}-\d{2}-\d{5}(?!\d)"),
    "CARD": re.compile(r"(?<!\d)(?:\d{4}[- ]?){3}\d{4}(?!\d)"),
}


def digits(s):
    return re.sub(r"\D", "", s)


def rrn_ok(s):
    d = digits(s)
    year = int(d[:2]) + (1900 if d[6] in "12" else 2000)
    try:
        date(year, int(d[2:4]), int(d[4:6]))           # 실제 달력에 있는 생년월일인지
    except ValueError:
        return False
    w = [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5]
    total = sum(int(c) * k for c, k in zip(d[:12], w))
    return (11 - total % 11) % 10 == int(d[12])        # 검증 숫자


def brn_ok(s):
    d = [int(c) for c in digits(s)]
    w = [1, 3, 7, 1, 3, 7, 1, 3, 5]
    total = sum(a * b for a, b in zip(d[:9], w)) + (d[8] * 5) // 10
    return (10 - total % 10) % 10 == d[9]


def luhn_ok(s):
    total = 0
    for i, c in enumerate(reversed(digits(s))):
        n = int(c) * (2 if i % 2 else 1)
        total += n - 9 if n > 9 else n
    return total % 10 == 0


CHECKS = {"RRN": rrn_ok, "BRN": brn_ok, "CARD": luhn_ok}


def scan_text(text, validate):
    found = []
    for kind, rx in PATTERNS.items():
        for m in rx.finditer(text):
            if validate and kind in CHECKS and not CHECKS[kind](m.group()):
                continue
            found.append({"type": kind, "start": m.start(), "end": m.end(), "score": 1.0})
    return found
```

### scan_presidio.py

```python
"""Presidio 로 같은 파일을 스캔합니다. extra=True 이면 한국어 recognizer 를 더합니다."""
from presidio_analyzer import AnalyzerEngine, Pattern, PatternRecognizer, RecognizerRegistry
from presidio_analyzer.nlp_engine import NlpEngineProvider
from presidio_analyzer.predefined_recognizers import KrBrnRecognizer, KrRrnRecognizer

LANG = "en"   # 설치한 NLP 모델은 영어 작은 모델 하나뿐이라 모든 분석을 en 으로 돌립니다.
TYPE_MAP = {"EMAIL_ADDRESS": "EMAIL", "PHONE_NUMBER": "PHONE", "KR_MOBILE": "PHONE",
            "CREDIT_CARD": "CARD", "KR_RRN": "RRN", "KR_BRN": "BRN"}


def build(extra):
    nlp = NlpEngineProvider(nlp_configuration={
        "nlp_engine_name": "spacy",
        "models": [{"lang_code": LANG, "model_name": "en_core_web_sm"}],
    }).create_engine()
    registry = RecognizerRegistry()
    registry.load_predefined_recognizers(nlp_engine=nlp, languages=[LANG])
    if extra:
        # 내장 한국어 recognizer 는 기본 언어가 ko 라서 en 으로 다시 만들어 등록합니다.
        registry.add_recognizer(KrRrnRecognizer(supported_language=LANG))
        registry.add_recognizer(KrBrnRecognizer(supported_language=LANG))
        # 직접 만든 recognizer: 010 휴대전화 번호(하이픈, 공백, +82 표기)
        registry.add_recognizer(PatternRecognizer(
            supported_entity="KR_MOBILE",
            supported_language=LANG,
            patterns=[Pattern("KR mobile", r"(?<!\d)(?:\+82[-\s]?10|010)[-\s]?\d{4}[-\s]?\d{4}(?!\d)", 0.6)],
        ))
    return AnalyzerEngine(registry=registry, nlp_engine=nlp, supported_languages=[LANG])


def scan_text(engine, text, threshold=0.5):
    out, other = [], {}
    for r in engine.analyze(text=text, language=LANG, score_threshold=threshold):
        kind = TYPE_MAP.get(r.entity_type)
        if kind:
            out.append({"type": kind, "start": r.start, "end": r.end, "score": round(r.score, 2)})
        else:
            other[r.entity_type] = other.get(r.entity_type, 0) + 1
    return out, other
```

### compare.py

```python
"""네 가지 스캔 방식을 같은 정답표로 채점하고, 마스킹한 결과를 보여 줍니다.

사용법: python compare.py [--detail] [--mask 파일이름]
출력에는 원래 값을 찍지 않습니다. 스캔 결과 파일도 개인정보가 되기 때문입니다.
"""
import json
import re
import sys
from collections import Counter
from pathlib import Path

import scan_presidio
import scan_regex

DATA = Path("data")
KINDS = ["RRN", "PHONE", "EMAIL", "BRN", "CARD"]
KEEP = {"RRN": 6, "CARD": 6, "BRN": 3}   # 앞에서 남길 숫자 개수(전화번호는 뒤 8자리를 가림)


def mask_value(kind, text):
    if kind == "EMAIL":
        return "***@" + text.split("@", 1)[1] if "@" in text else "(문자로 풀어 쓴 표기)"
    left, out = KEEP.get(kind, 0), []
    if kind == "PHONE":
        left = len(scan_regex.digits(text)) - 8          # 뒤 8자리만 가립니다
    for ch in text:
        if ch.isdigit():
            out.append(ch if left > 0 else "*")
            left -= 1
        else:
            out.append(ch)
    return "".join(out)


RRN_SHAPE = re.compile(r"(?<!\d)(\d{6}[- ]?)[1-4]\d{6}(?!\d)")


def hide_rrn_shape(text):
    """탐지 여부와 상관없이 주민등록번호 모양(6자리 + 7자리)은 앞 6자리만 남기고 가립니다."""
    return RRN_SHAPE.sub(lambda m: m.group(1) + "*" * 7, text)


def pad(text, width):
    """한글은 두 칸으로 세어 표 칸을 맞춥니다."""
    return text + " " * (width - sum(2 if ord(c) > 0x2E7F else 1 for c in text))


def merge(found):
    """같은 종류끼리 겹치는 결과는 하나로 합칩니다."""
    out = []
    for f in sorted(found, key=lambda x: (x["type"], x["start"])):
        if out and out[-1]["type"] == f["type"] and f["start"] < out[-1]["end"]:
            out[-1]["end"] = max(out[-1]["end"], f["end"])
        else:
            out.append(dict(f))
    return out


def overlap(a, b):
    return a["type"] == b["type"] and a["start"] < b["end"] and b["start"] < a["end"]


def load_texts():
    return {p.name: p.read_text(encoding="utf-8") for p in sorted(DATA.iterdir()) if p.suffix in (".csv", ".txt")}


def run_all(texts):
    plain, strict = {}, {}
    pres_base, pres_kr, other = {}, {}, Counter()
    eng_base, eng_kr = scan_presidio.build(False), scan_presidio.build(True)
    for name, text in texts.items():
        plain[name] = scan_regex.scan_text(text, False)
        strict[name] = scan_regex.scan_text(text, True)
        pres_base[name], _ = scan_presidio.scan_text(eng_base, text)
        pres_kr[name], o = scan_presidio.scan_text(eng_kr, text)
        other.update(o)
    return [("형식만 정규식", plain), ("검증 정규식", strict),
            ("Presidio 기본", pres_base), ("Presidio+한국어", pres_kr)], other


def main():
    sys.stdout.reconfigure(encoding="utf-8")
    detail = "--detail" in sys.argv
    texts = load_texts()
    truth = json.loads((DATA / "labels.json").read_text(encoding="utf-8"))
    scanners, other = run_all(texts)
    if "--mask" in sys.argv:
        name = sys.argv[sys.argv.index("--mask") + 1]
        text = texts[name]
        found = sorted(merge(dict(scanners)["검증 정규식"][name]), key=lambda x: -x["start"])
        for f in found:
            text = text[:f["start"]] + mask_value(f["type"], text[f["start"]:f["end"]]) + text[f["end"]:]
        text = hide_rrn_shape(text)                      # 정규식이 놓친 값도 출력 전에 한 번 더 가립니다
        out = Path("out")
        out.mkdir(exist_ok=True)
        (out / name).write_text(text, encoding="utf-8", newline="\n")
        print(f"--- out/{name} (검증 정규식 결과로 가림)")
        print(text, end="")
        return

    print(f"정답 {len(truth)}건 (RRN {sum(t['type']=='RRN' for t in truth)}, "
          f"PHONE {sum(t['type']=='PHONE' for t in truth)}, EMAIL {sum(t['type']=='EMAIL' for t in truth)}, "
          f"BRN {sum(t['type']=='BRN' for t in truth)}, CARD {sum(t['type']=='CARD' for t in truth)})\n")
    print(pad("방식", 18) + f"{'탐지':>5}{'정탐':>5}{'오탐':>5}{'미탐':>5}")
    results = {}
    for label, per_file in scanners:
        tp = fp = fn = det = 0
        miss, wrong, hit_kind = [], [], Counter()
        for name in texts:
            found = merge(per_file[name])
            det += len(found)
            tr = [t for t in truth if t["file"] == name]
            for t in tr:
                if any(overlap(t, f) for f in found):
                    tp += 1
                    hit_kind[t["type"]] += 1
                else:
                    miss.append((name, t))
            for f in found:
                if not any(overlap(t, f) for t in tr):
                    wrong.append((name, f))
        fp, fn = len(wrong), len(miss)
        results[label] = (hit_kind, miss, wrong)
        print(pad(label, 18) + f"{det:>5}{tp:>5}{fp:>5}{fn:>5}")
    print("\n종류별 정탐 수 (정답 수 대비)")
    totals = Counter(t["type"] for t in truth)
    print(pad("방식", 18) + "".join(f"{k:>8}" for k in KINDS))
    for label, _ in scanners:
        hk = results[label][0]
        print(pad(label, 18) + "".join(f"{hk[k]:>4}/{totals[k]:<3}" for k in KINDS))
    print("\nPresidio 가 개인정보 5종 밖에서 낸 엔티티(임계값 0.5 이상):", dict(other))
    scores = Counter(f["score"] for fs in scanners[3][1].values() for f in merge(fs) if f["type"] == "RRN")
    print("Presidio+한국어의 RRN 점수 분포:", dict(sorted(scores.items(), reverse=True)))
    if detail:
        for label, _ in scanners:
            if label == "Presidio 기본":
                continue                                  # 미탐이 너무 많아 목록은 생략합니다
            _, miss, wrong = results[label]
            print(f"\n[{label}] 오탐 {len(wrong)}건")
            for name, f in wrong:
                v = texts[name][f["start"]:f["end"]]
                print(f"  {name} {f['type']} {mask_value(f['type'], v)}")
            print(f"[{label}] 미탐 {len(miss)}건")
            for name, t in miss:
                v = t["text"]
                shown = mask_value(t["type"], v) if t["type"] == "EMAIL" or any(c.isdigit() for c in v) else "(한글로 쓴 숫자)"
                print(f"  {name} {t['type']} {shown}")


if __name__ == "__main__":
    main()
```

## 자주 막히는 곳

- **내장 한국어 recognizer가 결과에 나오지 않습니다.** 기본 설정으로 만든 엔진에는 `KrRrnRecognizer`가 등록되어 있지 않았습니다. `RecognizerRegistry`에 직접 `add_recognizer`로 넣어야 했습니다.
- **한국어 recognizer를 넣었는데도 0건입니다.** 내장 recognizer는 기본 언어가 `ko`로 만들어지는데 이 실습의 분석 언어는 `en`이라, 그대로 등록하면 `KR_RRN`이 0건이었습니다. `supported_language="en"`으로 다시 만들어 등록해 해결했고, 한국어 모델을 따로 두는 방법은 시험하지 않았습니다.
- **`AnalyzerEngine()`을 그대로 만들면 모델을 새로 받습니다.** 인자 없이 만들었더니 `en_core_web_lg`를 내려받는 메시지가 나왔습니다. 작은 모델을 쓰려면 `scan_presidio.py`처럼 NLP 엔진 설정을 직접 넘깁니다.
- **한국 휴대전화 번호가 Presidio 기본에서 안 나옵니다.** 기본 `PhoneRecognizer`의 지역 목록에 한국이 없습니다. 위 4단계처럼 패턴 recognizer를 추가했습니다.
- **Git Bash에서 `docker exec`의 경로가 이상하게 바뀝니다.** `export MSYS_NO_PATHCONV=1`을 먼저 실행합니다.
- **한글 출력에서 파이썬이 인코딩 오류를 냅니다.** Windows에서 출력을 받는 도구가 cp1252로 쓰다가 난 오류였고, `PYTHONUTF8=1`을 주면 해결됩니다. 컨테이너 안에서 직접 실행할 때는 필요 없었습니다.

## 확인 범위

- **확인한 것:** 위의 명령과 출력은 Docker 컨테이너에서 실제로 실행한 결과입니다. 숫자는 이 글의 가짜 데이터 33건에서 나온 값이라 실제 문서의 탐지율을 대신하지 않습니다. Presidio 공식 문서는 `https://presidio.dataprivacystack.org/supported_entities/`(지원 개체 목록, 한국용 개체), `https://presidio.dataprivacystack.org/analyzer/languages/`(언어 지원, recognizer당 한 언어), `https://presidio.dataprivacystack.org/analyzer/adding_recognizers/`(recognizer 등록)에서 확인했습니다. 예전 주소 `microsoft.github.io/presidio`는 위 주소로 옮겨졌습니다.
- **공식 문서와 달랐던 점:** 공식 문서의 지원 개체 표에서 `CREDIT_CARD`의 검사 방식은 체크섬으로만 적혀 있고 Luhn이라고는 적혀 있지 않습니다. 이 글에서 16자리 가짜 주문 번호가 걸러진 것은 직접 실행한 결과로 확인했습니다. 추가 recognizer 문서 페이지에는 `Pattern`과 `validate_result`의 상세 규격이 없어서 설치된 패키지의 내장 한국어 recognizer 소스를 읽고 따라 만들었습니다.
- **하지 못한 것:** 한국어 NLP 모델 연결, 문맥 단어(context)로 점수를 올리는 기능, 외국인등록번호, 여권, 운전면허, 계좌번호, 이름과 주소 탐지는 다루지 않았습니다. 2020년 10월 이후 신규 주민등록번호에 검증 숫자 규칙이 적용되는지는 공식 자료로 확인하지 못했습니다(앞의 보도자료에는 이 내용이 없습니다). Linux와 macOS에서는 실행하지 않았습니다(Docker 컨테이너 안이라 명령은 같습니다).
- **범위의 한계:** 점수 0.5 임계값과 가림 규칙은 이 글에서 정한 값입니다. 정규식과 검증 로직은 설명용이며, 실제 서비스에 적용할 때는 대상 문서에 맞게 다시 시험합니다.
