# 로그와 LLM 프롬프트의 개인정보 마스킹: 주민번호·전화번호 패턴과 점검표

> Flask 앱의 로그와 LLM 호출 직전 프롬프트에 가짜 주민등록번호 형식, 휴대전화, 이메일, 카드번호가 그대로 남는 것을 OpenSearch Dashboards 로 확인하고, logging.Filter 와 프롬프트 전처리, Luhn 체크섬 검증으로 가린 뒤 다시 비교합니다.

- 주소: https://copyandrun.com/blog/pii-masking-logs-and-llm-prompts/
- 분야: AI 보안
- 발행일: 2026-10-27
- 태그: 개인정보, 로그, LLM, OpenSearch

Flask 앱의 로그와 LLM 호출 직전 프롬프트에 개인정보가 얼마나 그대로 남는지 확인하고, 기록하기 직전에 가리는 장치를 붙입니다. 주민등록번호 형식, 휴대전화, 이메일, 카드번호 네 가지를 다룹니다. 카드번호는 Luhn 체크섬으로 검증해서, 카드처럼 생겼지만 카드가 아닌 일련번호를 가리지 않도록 합니다.

순서는 이렇습니다. 먼저 마스킹이 없는 앱을 띄우고 로그와 프롬프트에 값이 그대로 남는 것을 OpenSearch Dashboards 와 모의 LLM 화면으로 봅니다. 그다음 `logging.Filter` 로 로그를 가리고, LLM 에 보내기 직전에 프롬프트를 전처리합니다. 같은 요청을 다시 보내 마스킹 전후를 비교하고, 마지막에 이 방식이 못 막는 것을 정리합니다. 모델은 쓰지 않습니다. 모의 LLM 서버가 받은 프롬프트를 화면에 보여 주므로 키나 Ollama 가 필요 없습니다.

이 글의 주민등록번호, 휴대전화, 이메일, 카드번호는 전부 실습용으로 만든 가짜(테스트용) 값입니다. 카드번호는 결제 업체 문서에 공개된 테스트 번호이고, 이메일은 예약된 `example.com` 도메인입니다. 실제 개인정보를 넣어 실행하지 않습니다. OpenSearch 와 Dashboards 는 보안 플러그인(TLS, 인증)을 끈 실습용 구성이므로 운영 환경에 쓰지 않고, 포트는 모두 `127.0.0.1` 에만 연결합니다.

## 준비물

| 항목 | 내용 |
|------|------|
| Docker | Docker Desktop 또는 Docker Engine, Compose v2 |
| OpenSearch, Dashboards | 3.2.0 (이미지 `opensearchproject/opensearch:3.2.0`, `opensearchproject/opensearch-dashboards:3.2.0`) |
| 앱, 모의 LLM | `python:3.12-slim` 컨테이너에 Flask 3.1.3 설치 |
| 호스트 Python | 3.12 (호스트에서 실행하는 스크립트는 표준 라이브러리만 사용, 3.12.10에서 확인) |
| 메모리 | OpenSearch 컨테이너는 1GB로 제한하고 힙은 512MB로 설정 |
| 호스트 포트 | 5790(OpenSearch), 5791(Dashboards), 5792(앱), 5793(모의 LLM) |

OpenSearch 설치는 이 글에서 다루지 않습니다. 같은 구성을 설명한 [Docker로 OpenSearch와 Ollama 띄워 비용 없는 AI-SIEM 만들기](/blog/opensearch-ollama-ai-siem/)를 참고합니다. 리눅스 호스트에서는 먼저 `sudo sysctl -w vm.max_map_count=262144` 를 실행합니다.

## 실습 파일 저장

작업 폴더 하나에 아래 파일 아홉 개를 같은 이름으로 저장하고, 같은 폴더에 빈 `logs` 폴더를 만듭니다(`mkdir logs`). 먼저 `docker-compose.yml` 입니다. 컨테이너 이름은 모두 `cr-pii-` 로 시작합니다. 앱은 `MASK` 값으로 마스킹을 켜고 끄며, 로그 파일은 `logs` 폴더에 `app-before.log` 또는 `app-after.log` 로 남습니다.

```yaml
name: cr-pii
services:
  opensearch:
    image: opensearchproject/opensearch:3.2.0
    container_name: cr-pii-opensearch
    mem_limit: 1g
    environment:
      - discovery.type=single-node
      - OPENSEARCH_JAVA_OPTS=-Xms512m -Xmx512m
      - DISABLE_INSTALL_DEMO_CONFIG=true
      - DISABLE_SECURITY_PLUGIN=true # 실습 전용: 인증과 TLS를 끕니다
      - http.compression=false
    ulimits:
      nofile: { soft: 65536, hard: 65536 }
    ports: ["127.0.0.1:5790:9200"]
    volumes: [opensearch-data:/usr/share/opensearch/data]
  dashboards:
    image: opensearchproject/opensearch-dashboards:3.2.0
    container_name: cr-pii-dashboards
    mem_limit: 1g
    environment:
      - OPENSEARCH_HOSTS=["http://opensearch:9200"]
      - DISABLE_SECURITY_DASHBOARDS_PLUGIN=true # 실습 전용: 로그인 화면을 끕니다
    ports: ["127.0.0.1:5791:5601"]
    depends_on: [opensearch]
  llm:
    image: python:3.12-slim
    container_name: cr-pii-llm
    command: sh -c "pip install -q flask==3.1.3 && python /app/mock_llm.py"
    volumes: ["./mock_llm.py:/app/mock_llm.py:ro"]
    ports: ["127.0.0.1:5793:8000"]
  app:
    image: python:3.12-slim
    container_name: cr-pii-app
    command: sh -c "pip install -q flask==3.1.3 && cd /app && python app.py"
    environment:
      - MASK=${MASK:-0} # 1 이면 로그와 프롬프트에서 개인정보를 가립니다
    volumes:
      - ./app.py:/app/app.py:ro
      - ./pii.py:/app/pii.py:ro
      - ./logs:/logs
    ports: ["127.0.0.1:5792:8000"]
    depends_on: [llm]
volumes:
  opensearch-data:
```

`pii.py` 가 마스킹 규칙입니다. 정규식으로 후보를 찾은 뒤 검증을 통과한 것만 가립니다. 카드번호는 Luhn 체크섬이 맞아야 하고, 주민등록번호 형식은 월과 일이 날짜로 가능해야 합니다. `mask_text` 의 `style="log"` 는 뒷부분만 남기는 마스킹이고, `style="prompt"` 는 `[주민번호]` 처럼 종류만 알려 주는 표시로 바꿉니다. `PiiFilter` 는 로그 한 건을 기록하기 직전에 메시지와 예외 문구를 가립니다.

```python
"""개인정보 마스킹: 정규식으로 후보를 찾고, 검증을 통과한 것만 가립니다."""
import logging
import re

# 주민등록번호 형식: 앞에 숫자, 영문, 하이픈이 붙은 긴 번호의 일부는 제외합니다
RRN = re.compile(r"(?<![\w-])(\d{2})(\d{2})(\d{2})-?([1-8])\d{6}(?!\d)")
# 카드번호 형식: 4자리 네 묶음, 구분자는 공백 또는 하이픈 중 하나로 통일되어 있어야 합니다
CARD = re.compile(r"(?<![\w-])(\d{4})([- ]?)(\d{4})\2(\d{4})\2(\d{4})(?!\d)")
# 휴대전화: 010, 011, 016, 017, 018, 019
PHONE = re.compile(r"(?<![\w-])(01[016789])([-. ]?)(\d{3,4})([-. ]?)(\d{4})(?!\d)")
EMAIL = re.compile(r"[\w.+-]+@[\w-]+(?:\.[\w-]+)+")

LABEL = {"rrn": "[주민번호]", "card": "[카드번호]", "phone": "[전화번호]", "email": "[이메일]"}


def luhn_ok(digits):
    """카드번호 체크섬(Luhn)입니다. 오른쪽에서 두 번째 자리부터 하나 걸러 두 배로 합니다."""
    total = 0
    for i, ch in enumerate(reversed(digits)):
        d = int(ch)
        if i % 2 == 1:
            d *= 2
            if d > 9:
                d -= 9
        total += d
    return total % 10 == 0


def mask_text(text, style="log"):
    """style="log" 는 일부를 남기는 마스킹, style="prompt" 는 종류만 알려 주는 표시로 바꿉니다."""
    prompt = style == "prompt"

    def card(m):
        digits = "".join(m.group(i) for i in (1, 3, 4, 5))
        if not luhn_ok(digits):
            return m.group(0)  # 체크섬이 틀리면 카드번호가 아니라 일련번호로 봅니다
        if prompt:
            return LABEL["card"]
        sep = m.group(2)
        return sep.join(["****", "****", "****", m.group(5)])

    def rrn(m):
        month, day = int(m.group(2)), int(m.group(3))
        if not (1 <= month <= 12 and 1 <= day <= 31):
            return m.group(0)  # 날짜가 될 수 없는 숫자는 건드리지 않습니다
        return LABEL["rrn"] if prompt else "******-*******"

    def phone(m):
        if prompt:
            return LABEL["phone"]
        return f"{m.group(1)}{m.group(2)}****{m.group(4)}{m.group(5)}"

    def email(m):
        if prompt:
            return LABEL["email"]
        local, domain = m.group(0).split("@", 1)
        return f"{local[0]}***@{domain}"

    text = CARD.sub(card, text)  # 카드를 먼저 처리해야 16자리 안의 13자리가 주민번호로 오인되지 않습니다
    text = RRN.sub(rrn, text)
    text = PHONE.sub(phone, text)
    return EMAIL.sub(email, text)


class PiiFilter(logging.Filter):
    """핸들러에 붙이는 필터입니다. 메시지와 예외 문구를 기록하기 직전에 마스킹합니다."""

    def filter(self, record):
        record.msg = mask_text(record.getMessage())
        record.args = ()
        if record.exc_info:
            text = logging.Formatter().formatException(record.exc_info)
            record.exc_text = mask_text(text)
        return True
```

`test_pii.py` 는 가려야 할 것과 가리면 안 되는 것을 함께 점검합니다.

```python
"""마스킹 규칙 점검: 가려야 할 것은 가리고, 가리면 안 되는 것은 그대로 두는지 확인합니다."""
from pii import luhn_ok, mask_text

DOMAIN = "example.com"

CASES = [
    # (입력, 로그 스타일 기대값)
    ("rrn=900101-1234567", "rrn=******-*******"),
    ("rrn=9001011234567", "rrn=******-*******"),
    ("rrn=901301-1234567", "rrn=901301-1234567"),  # 13월은 날짜가 아닙니다
    ("주문 ORD-2610271234567", "주문 ORD-2610271234567"),  # 앞에 붙은 접두어가 있으면 건드리지 않습니다
    ("tel=010-1234-5678", "tel=010-****-5678"),
    ("tel=01012345678", "tel=010****5678"),
    (f"mail=tester1@{DOMAIN}", f"mail=t***@{DOMAIN}"),
    ("card=4111 1111 1111 1111", "card=**** **** **** 1111"),
    ("card=5555-5555-5555-4444", "card=****-****-****-4444"),
    ("track=1234-5678-9012-3456", "track=1234-5678-9012-3456"),  # Luhn 불일치
]

for text, want in CASES:
    got = mask_text(text)
    assert got == want, f"{text!r}\n  기대 {want!r}\n  결과 {got!r}"

prompt = mask_text("연락처 010-1234-5678, 주민번호 900101-1234567", style="prompt")
assert prompt == "연락처 [전화번호], 주민번호 [주민번호]", prompt
assert luhn_ok("4111111111111111") and not luhn_ok("1234567890123456")
print(f"마스킹 규칙 점검 통과 ({len(CASES) + 2}건)")
```

`app.py` 가 점검 대상 앱입니다. 회원가입, 결제, 챗 문의, 고객 조회 요청을 받아 값을 `%s` 로 로그에 그대로 찍습니다. `MASK=1` 이면 로그 핸들러에 `PiiFilter` 를 붙이고, 챗 문의는 LLM 에 보내기 직전에 프롬프트를 전처리합니다.

```python
"""회원가입, 결제, 챗 문의를 받는 Flask 앱입니다. MASK=1 이면 로그와 프롬프트에서 개인정보를 가립니다."""
import json
import logging
import os
import re
import sys
import urllib.request
from datetime import datetime, timezone

from flask import Flask, jsonify, request

from pii import PiiFilter, mask_text

MASK = os.environ.get("MASK", "0") == "1"
MODE = "after" if MASK else "before"
LLM_URL = os.environ.get("LLM_URL", "http://llm:8000/v1/chat")
LOG_PATH = f"/logs/app-{MODE}.log"
ANSI = re.compile(r"\x1b\[[0-9;]*m")  # werkzeug 가 붙이는 색상 코드
CUSTOMERS = {"010-1234-5678": "테스트고객1"}  # 전부 실습용 가짜 값입니다


class JsonFormatter(logging.Formatter):
    def format(self, record):
        doc = {
            "@timestamp": datetime.fromtimestamp(record.created, timezone.utc).isoformat(),
            "mode": MODE,
            "level": record.levelname,
            "logger": record.name,
            "message": ANSI.sub("", record.getMessage()),
        }
        if record.exc_info:
            doc["exception"] = record.exc_text or self.formatException(record.exc_info)
        return json.dumps(doc, ensure_ascii=False)


def setup_logging():
    handlers = [logging.FileHandler(LOG_PATH, mode="w", encoding="utf-8"), logging.StreamHandler(sys.stdout)]
    root = logging.getLogger()
    root.setLevel(logging.INFO)
    for handler in handlers:
        handler.setFormatter(JsonFormatter())
        if MASK:
            handler.addFilter(PiiFilter())  # 로거가 아니라 핸들러에 붙여야 다른 로거(werkzeug 등)의 기록도 가려집니다
        root.addHandler(handler)


setup_logging()
log = logging.getLogger("shop")
app = Flask(__name__)


def ask_llm(prompt):
    body = json.dumps({"mode": MODE, "prompt": prompt}).encode()
    req = urllib.request.Request(LLM_URL, body, {"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=10) as res:
        return json.load(res)["answer"]


@app.get("/health")
def health():
    return jsonify(ok=True)


@app.post("/signup")
def signup():
    d = request.get_json()
    log.info("회원가입 요청: name=%s rrn=%s phone=%s email=%s", d["name"], d["rrn"], d["phone"], d["email"])
    return jsonify(ok=True)


@app.post("/payment")
def payment():
    d = request.get_json()
    log.info("결제 요청: card=%s amount=%s memo=%s", d["card"], d["amount"], d.get("memo", ""))
    return jsonify(ok=True)


@app.post("/chat")
def chat():
    message = request.get_json()["message"]
    prompt = "다음 고객 문의를 두 문장으로 요약하세요.\n" + message
    if MASK:
        prompt = mask_text(prompt, style="prompt")  # LLM 호출 직전 전처리
    log.info("LLM 호출: prompt=%s", prompt.replace("\n", " / "))
    return jsonify(answer=ask_llm(prompt))


@app.get("/lookup")
def lookup():
    phone = request.args["phone"]
    name = CUSTOMERS.get(phone)
    if name is None:
        try:
            raise LookupError(f"고객을 찾지 못했습니다: {phone}")
        except LookupError:
            log.exception("고객 조회 실패")
        return jsonify(found=False), 404
    return jsonify(found=True, name=name)


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)
```

`mock_llm.py` 는 모델 대신 받은 프롬프트를 기록하고 화면으로 보여 주는 모의 LLM 서버입니다.

```python
"""모의 LLM 서버입니다. 모델 없이 받은 프롬프트만 기록하고 화면으로 보여 줍니다."""
import html

from flask import Flask, jsonify, request

app = Flask(__name__)
RECEIVED = {"before": [], "after": []}

PAGE = """<!doctype html><meta charset="utf-8"><title>모의 LLM 수신 프롬프트</title>
<style>
body{{font-family:"Malgun Gothic",sans-serif;margin:0;background:#f4f5f7;color:#1c2330}}
header{{background:#1c2330;color:#fff;padding:14px 24px;font-size:18px}}
main{{padding:20px 24px}}
.tag{{display:inline-block;padding:2px 10px;border-radius:10px;color:#fff;background:{color};font-size:14px}}
.card{{background:#fff;border:1px solid #d6dae1;border-radius:6px;padding:12px 16px;margin:12px 0}}
.card h3{{margin:0 0 6px;font-size:14px;color:#566074}}
pre{{margin:0;white-space:pre-wrap;font:15px/1.6 Consolas,"Malgun Gothic",monospace}}
</style>
<header>모의 LLM 서버가 받은 프롬프트</header>
<main><p>수신 구분 <span class="tag">{mode}</span> 총 {count}건</p>{cards}</main>"""


@app.post("/v1/chat")
def chat():
    d = request.get_json()
    RECEIVED[d["mode"]].append(d["prompt"])
    return jsonify(answer="모의 응답: 문의를 접수했습니다.")


@app.post("/reset")
def reset():
    RECEIVED[request.args["mode"]].clear()
    return jsonify(ok=True)


@app.get("/prompts")
def prompts():
    return jsonify(RECEIVED[request.args.get("mode", "before")])


@app.get("/")
def index():
    mode = request.args.get("mode", "before")
    cards = "".join(
        f'<div class="card"><h3>요청 {i}</h3><pre>{html.escape(p)}</pre></div>'
        for i, p in enumerate(RECEIVED[mode], 1)
    )
    color = "#c0392b" if mode == "before" else "#1e8449"
    return PAGE.format(mode="마스킹 전" if mode == "before" else "마스킹 후", color=color, count=len(RECEIVED[mode]), cards=cards)


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)
```

`send_traffic.py` 는 가짜 개인정보가 담긴 요청 일곱 건을 앱에 보냅니다. 인자로 `before` 또는 `after` 를 받아 해당 구분의 수신 기록만 비우고 시작합니다.

```python
"""앱에 가짜 개인정보가 담긴 요청을 보냅니다. 값은 모두 실습용으로 만든 가짜입니다."""
import json
import sys
import urllib.error
import urllib.parse
import urllib.request

APP = "http://127.0.0.1:5792"
LLM = "http://127.0.0.1:5793"
DOMAIN = "example.com"  # 예약된 예시 도메인


def call(method, url, body=None):
    data = json.dumps(body).encode() if body is not None else None
    req = urllib.request.Request(url, data, {"Content-Type": "application/json"}, method=method)
    try:
        with urllib.request.urlopen(req) as res:
            return res.status
    except urllib.error.HTTPError as exc:
        return exc.code


MODE = sys.argv[1]  # before 또는 after: 해당 구분의 수신 기록만 비우고 시작합니다
call("POST", f"{LLM}/reset?mode={MODE}")
requests = [
    ("POST", "/signup", {"name": "테스트고객1", "rrn": "900101-1234567", "phone": "010-1234-5678", "email": f"tester1@{DOMAIN}"}),
    ("POST", "/signup", {"name": "테스트고객2", "rrn": "8503152345678", "phone": "01055550101", "email": f"tester2@{DOMAIN}"}),
    ("POST", "/payment", {"card": "4111 1111 1111 1111", "amount": 12000, "memo": "주문 ORD-2610271234567 건"}),
    ("POST", "/payment", {"card": "5555-5555-5555-4444", "amount": 8500, "memo": "송장 1234-5678-9012-3456 배송 문의"}),
    ("POST", "/chat", {"message": "제 주민번호는 900101-1234567 이고 연락처는 010-1234-5678 입니다. 환불 계좌 등록을 도와주세요."}),
    ("POST", "/chat", {"message": f"카드 4111 1111 1111 1111 결제가 두 번 됐습니다. 결과는 tester1@{DOMAIN} 으로 알려 주세요."}),
    ("GET", "/lookup?" + urllib.parse.urlencode({"phone": "010-9999-0000"}), None),
]
for method, path, body in requests:
    print(call(method, APP + path, body), method, path.split("?")[0])
```

`ship_logs.py` 는 앱이 남긴 로그 파일을 OpenSearch 에 색인합니다. 마스킹 전은 `pii-logs-before`, 후는 `pii-logs-after` 색인에 들어갑니다.

```python
"""앱이 남긴 JSON 로그 파일을 OpenSearch 에 색인합니다. 마스킹 전은 pii-logs-before, 후는 pii-logs-after 입니다."""
import json
import sys
import urllib.error
import urllib.request

OS = "http://127.0.0.1:5790"


def call(method, path, body=None, ctype="application/json"):
    data = body.encode() if isinstance(body, str) else None
    req = urllib.request.Request(OS + path, data, {"Content-Type": ctype}, method=method)
    with urllib.request.urlopen(req) as res:
        return json.load(res)


for mode in sys.argv[1:] or ("before", "after"):  # 인자로 before 또는 after 하나만 줄 수도 있습니다
    index = f"pii-logs-{mode}"
    try:
        call("DELETE", f"/{index}")
    except urllib.error.HTTPError:
        pass  # 처음 실행이면 지울 색인이 없습니다
    with open(f"logs/app-{mode}.log", encoding="utf-8") as f:
        docs = [line for line in f.read().splitlines() if line.strip()]
    bulk = "".join(f'{{"index":{{"_index":"{index}"}}}}\n{d}\n' for d in docs)
    res = call("POST", "/_bulk?refresh=true", bulk, "application/x-ndjson")
    print(index, len(docs), "건", "오류 있음" if res["errors"] else "오류 없음")
```

`setup.py` 는 Dashboards 에 인덱스 패턴과 저장된 검색 세 개를 만듭니다. 개발 서버가 시작할 때 남기는 안내 두 줄은 검색 조건에서 뺍니다.

```python
"""Dashboards 에 인덱스 패턴과 저장된 검색(마스킹 전, 마스킹 후, 원본 번호 검색)을 만듭니다."""
import json
import urllib.request

DASH = "http://127.0.0.1:5791"


def saved(kind, obj_id, attributes, references):
    url = f"{DASH}/api/saved_objects/{kind}/{obj_id}?overwrite=true"
    body = json.dumps({"attributes": attributes, "references": references}).encode()
    req = urllib.request.Request(url, body, {"Content-Type": "application/json", "osd-xsrf": "true"}, method="POST")
    print(kind, json.load(urllib.request.urlopen(req))["id"])


def index_ref(pattern_id):
    return [{"name": "kibanaSavedObjectMeta.searchSourceJSON.index", "type": "index-pattern", "id": pattern_id}]


def source(query):
    return json.dumps({
        "indexRefName": "kibanaSavedObjectMeta.searchSourceJSON.index",
        "query": {"language": "kuery", "query": query},
        "filter": [],
    })


for pattern in ("pii-logs-before", "pii-logs-after", "pii-logs-*"):
    saved("index-pattern", pattern, {"title": pattern, "timeFieldName": "@timestamp"}, [])

COLUMNS = ["logger", "message"]


def search(obj_id, title, pattern, query, columns):
    saved("search", obj_id, {
        "title": title, "description": "", "hits": 0, "columns": columns,
        "sort": [["@timestamp", "asc"]], "version": 1,
        "kibanaSavedObjectMeta": {"searchSourceJSON": source(query)},
    }, index_ref(pattern))


NOISE = "not message:(Press or WARNING)"  # 개발 서버 시작 안내 두 줄은 뺍니다
search("before", "마스킹 전 로그", "pii-logs-before", NOISE, COLUMNS)
search("after", "마스킹 후 로그", "pii-logs-after", NOISE, COLUMNS)
search("raw-search", "원본 번호로 검색", "pii-logs-*", "message:(900101 or 4111 or 8503)", ["mode", "message"])
```

`check_leaks.py` 는 로그 파일과 모의 LLM 이 받은 프롬프트에 개인정보 모양이 남았는지 셉니다. 일부러 `pii.py` 보다 느슨한 규칙을 써서, 마스킹 규칙이 놓친 것을 따로 확인합니다.

```python
"""마스킹 전후 로그와 LLM 수신 프롬프트에 개인정보 모양이 남았는지 느슨한 규칙으로 셉니다."""
import json
import re
import urllib.request

LLM = "http://127.0.0.1:5793"
LOOSE = {
    "주민번호": re.compile(r"\d{6}-?[1-4]\d{6}"),
    "휴대전화": re.compile(r"01[016789][-. ]?\d{3,4}[-. ]?\d{4}"),
    "이메일": re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+"),
    "카드번호": re.compile(r"\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}"),
}


def count(texts):
    return {name: sum(1 for t in texts if pat.search(t)) for name, pat in LOOSE.items()}


def show(label, hits):
    print(f"{label:<14}" + "  ".join(f"{k} {v}" for k, v in hits.items()))


for mode in ("before", "after"):
    logs = []
    with open(f"logs/app-{mode}.log", encoding="utf-8") as f:
        for row in f:
            if row.strip():
                doc = json.loads(row)
                logs.append(doc["message"] + doc.get("exception", ""))
    with urllib.request.urlopen(f"{LLM}/prompts?mode={mode}") as res:
        prompts = json.load(res)
    show(f"로그 {mode}", count(logs))
    show(f"프롬프트 {mode}", count(prompts))
```

## 1. 발견: 로그와 프롬프트에 값이 그대로 남는다

마스킹 없이(`MASK` 기본값 0) 앱과 나머지 컨테이너를 띄웁니다. 처음 실행하면 이미지를 내려받느라 시간이 걸립니다.

```bash
docker compose up -d
until curl -sf http://127.0.0.1:5792/health >/dev/null; do sleep 2; done
python send_traffic.py before
python ship_logs.py before
python setup.py
```

요청 일곱 건의 응답 코드와 색인 결과, Dashboards 설정 결과는 다음과 같습니다. 마지막 고객 조회는 없는 번호를 찾으므로 404 가 정상입니다. 색인 건수는 앱이 뜨기를 기다린 `/health` 요청 횟수에 따라 달라질 수 있습니다.

```text
200 POST /signup
200 POST /signup
200 POST /payment
200 POST /payment
200 POST /chat
200 POST /chat
404 GET /lookup
pii-logs-before 17 건 오류 없음
index-pattern pii-logs-before
index-pattern pii-logs-after
index-pattern pii-logs-*
search before
search after
search raw-search
```

브라우저에서 `http://127.0.0.1:5791/app/data-explorer/discover#/view/before?_g=(time:(from:now-1h,to:now))` 를 엽니다. 저장된 검색 "마스킹 전 로그" 가 열립니다.

![마스킹 전 로그에 주민등록번호, 휴대전화, 이메일, 카드번호가 그대로 있고, 접근 로그의 조회 주소에도 전화번호가 남아 있는지 확인합니다.](https://copyandrun.com/img/pii-masking-logs-and-llm-prompts/01-마스킹-전-로그-Discover.png)

앱이 직접 남긴 로그(`shop`)뿐 아니라 Flask 개발 서버의 접근 로그(`werkzeug`)에도 `GET /lookup?phone=010-9999-0000` 처럼 쿼리스트링의 전화번호가 남습니다. LLM 호출 로그에는 프롬프트 전체가 들어 있어 주민등록번호와 카드번호가 한 번 더 기록됩니다.

이제 LLM 쪽입니다. 모의 LLM 서버가 받은 내용을 `http://127.0.0.1:5793/?mode=before` 에서 엽니다.

![모의 LLM 서버가 받은 프롬프트 두 건에 주민등록번호, 전화번호, 카드번호, 이메일이 원본 그대로 들어 있는지 확인합니다.](https://copyandrun.com/img/pii-masking-logs-and-llm-prompts/02-LLM-수신-프롬프트-전.png)

외부 LLM API 를 쓰는 앱이었다면 이 값이 그대로 사업장 밖 서비스로 나갑니다. 같은 값이 로그 색인에도 남아 있으므로, 원본 번호 앞자리로 검색하면 바로 나옵니다. 저장된 검색 "원본 번호로 검색" 은 `http://127.0.0.1:5791/app/data-explorer/discover#/view/raw-search?_g=(time:(from:now-1h,to:now))` 에서 엽니다. 두 색인을 함께 조회하며 `message:(900101 or 4111 or 8503)` 로 찾습니다. 이 화면은 4절에서 마스킹 후 색인까지 만든 뒤에 열어야 두 색인이 모두 조회됩니다.

![원본 번호 앞자리로 검색하면 마스킹 전 색인(before)의 로그 네 건이 강조되어 나오고 마스킹 후 색인은 나오지 않는지 확인합니다.](https://copyandrun.com/img/pii-masking-logs-and-llm-prompts/05-원본-번호-검색.png)

## 2. 원인: 값을 문자열에 넣는 순간 모든 출력이 가져간다

`log.info("... rrn=%s", d["rrn"])` 처럼 값을 메시지에 넣으면, 그 문자열은 파일, 표준 출력, 수집기, 색인으로 복제됩니다. 이 앱에서 값이 새는 경로는 네 갈래입니다.

- **업무 로그**: 가입과 결제 요청을 기록하면서 입력값을 그대로 넣었습니다.
- **접근 로그**: 라이브러리가 만드는 요청 줄에 쿼리스트링이 들어갑니다. 앱 코드를 고쳐도 `werkzeug` 가 남기는 줄은 그대로입니다.
- **예외 문구**: `LookupError(f"...: {phone}")` 처럼 예외 메시지에 값을 넣으면 스택 트레이스에 실려 나갑니다.
- **프롬프트**: 사용자가 챗에 입력한 값이 그대로 프롬프트가 되고, 그 프롬프트를 로그에도 남깁니다.

로그를 한 번 색인하면 값이 검색 가능한 상태로 퍼지므로, 쓰는 쪽에서 가리는 것이 비용이 가장 적게 드는 방법입니다.

## 3. 수정: 기록 직전 필터와 프롬프트 전처리

수정은 `pii.py` 와 `app.py` 에 이미 들어 있습니다. 핵심은 세 가지입니다.

- **핸들러에 필터 붙이기**: Python `logging` 문서에 따르면 로거에 붙인 필터는 그 로거에서 직접 남긴 기록에만 적용되고, 자식 로거가 올려 보낸 기록에는 적용되지 않습니다. 핸들러에 붙이면 그 핸들러가 처리하는 모든 기록에 적용되므로 `werkzeug` 접근 로그도 가려집니다. `app.py` 의 `handler.addFilter(PiiFilter())` 가 이 부분입니다.
- **예외까지 가리기**: `PiiFilter` 는 `exc_info` 가 있으면 스택 트레이스 문자열을 만들어 마스킹한 뒤 `exc_text` 에 넣습니다. 포맷터가 이 값을 그대로 씁니다.
- **프롬프트는 종류 표시로**: LLM 에는 `[주민번호]` 처럼 무슨 종류의 값이 있었는지만 알려 줍니다. 요약 같은 작업에는 이 정도로 충분합니다. 로그의 마스킹과 달리 뒷자리도 남기지 않습니다.

체크섬 검증은 오탐을 줄이는 장치입니다. 16자리 숫자를 모두 카드번호로 보고 가리면, 송장번호나 주문번호까지 지워져 로그를 읽을 수 없게 됩니다. 카드번호 형식이면서 Luhn 검사를 통과한 것만 가리고, 주민등록번호 형식은 월과 일이 날짜로 가능한 것만 가립니다. `ORD-` 처럼 앞에 접두어가 붙은 번호는 후보에서 뺍니다. 규칙 점검부터 실행합니다.

```bash
python test_pii.py
```

```text
마스킹 규칙 점검 통과 (12건)
```

## 4. 재확인: 같은 요청을 마스킹을 켜고 다시 보내기

`MASK=1` 로 앱 컨테이너만 다시 만들고 같은 요청을 보냅니다. PowerShell 에서는 첫 줄 대신 `$env:MASK = "1"` 을 먼저 실행합니다.

```bash
MASK=1 docker compose up -d --force-recreate app
until curl -sf http://127.0.0.1:5792/health >/dev/null; do sleep 2; done
python send_traffic.py after
python ship_logs.py after
```

```text
pii-logs-after 17 건 오류 없음
```

`http://127.0.0.1:5791/app/data-explorer/discover#/view/after?_g=(time:(from:now-1h,to:now))` 를 엽니다.

![마스킹 후 로그에서 주민등록번호는 별표로, 전화번호와 카드번호는 뒤 네 자리만, 이메일은 첫 글자만 남고 접근 로그의 조회 주소도 가려졌는지 확인합니다.](https://copyandrun.com/img/pii-masking-logs-and-llm-prompts/03-마스킹-후-로그-Discover.png)

가입 로그의 값은 `rrn=******-*******`, `phone=010-****-5678`, `email=t***@example.com` 으로 바뀌었습니다. 하이픈이 없는 `8503152345678` 과 `01055550101` 도 가려졌습니다. 접근 로그의 조회 주소는 `phone=010-****-0000` 입니다. 결제 로그에서 `ORD-2610271234567` 과 `1234-5678-9012-3456` 은 그대로입니다. 앞의 것은 접두어가 붙은 주문번호이고, 뒤의 것은 Luhn 검사를 통과하지 못하는 송장번호이기 때문입니다.

모의 LLM 이 받은 프롬프트는 `http://127.0.0.1:5793/?mode=after` 에서 봅니다.

![모의 LLM 서버가 받은 프롬프트에서 개인정보가 주민번호, 전화번호, 카드번호, 이메일 표시로 바뀌었는지 확인합니다.](https://copyandrun.com/img/pii-masking-logs-and-llm-prompts/04-LLM-수신-프롬프트-후.png)

마지막으로 느슨한 규칙으로 남은 것을 세고, 예외 문구도 비교합니다.

```bash
python check_leaks.py
grep -ho 'LookupError: [^\\"]*' logs/app-before.log logs/app-after.log
```

```text
로그 before     주민번호 4  휴대전화 5  이메일 3  카드번호 3
프롬프트 before   주민번호 1  휴대전화 1  이메일 1  카드번호 1
로그 after      주민번호 1  휴대전화 0  이메일 0  카드번호 1
프롬프트 after    주민번호 0  휴대전화 0  이메일 0  카드번호 0
LookupError: 고객을 찾지 못했습니다: 010-9999-0000
LookupError: 고객을 찾지 못했습니다: 010-****-0000
```

![마스킹 전에는 네 종류가 여러 건 남아 있고, 마스킹 후에는 주민번호와 카드번호 각 한 건만 남으며 예외 문구의 전화번호도 가려졌는지 확인합니다.](https://copyandrun.com/img/pii-masking-logs-and-llm-prompts/06-마스킹-점검-결과.png)

마스킹 후 로그에 남은 두 건은 위에서 설명한 주문번호 `ORD-2610271234567` 과 송장번호 `1234-5678-9012-3456` 입니다. 느슨한 규칙이 숫자 모양만 보고 센 것이므로 개인정보가 새는 것이 아니라 의도한 예외입니다. 실제 운영에서는 이런 예외 목록을 사람이 한 번씩 확인해야 합니다.

## 5. 점검표

로그와 프롬프트를 점검할 때 아래 항목을 순서대로 봅니다.

- **로그 출력 지점**: 파일, 표준 출력, 수집기가 읽는 경로 모두에 같은 필터가 붙었는지 확인합니다.
- **라이브러리 로그**: 접근 로그와 SQL 로그, 클라이언트 라이브러리의 디버그 로그에 쿼리스트링과 본문이 남는지 확인합니다.
- **예외와 스택 트레이스**: 예외 메시지에 입력값을 넣지 않거나, 필터가 `exc_info` 까지 가리는지 확인합니다.
- **프롬프트 기록**: LLM 에 보내는 프롬프트와 응답을 로그나 트레이싱 도구에 남기는지 확인하고, 남긴다면 가린 뒤의 값인지 봅니다.
- **검증 규칙**: 카드번호는 체크섬, 주민등록번호 형식은 날짜로 오탐을 줄이고, 예외 목록을 정기적으로 봅니다.
- **남은 것 세기**: 마스킹 규칙과 다른 느슨한 규칙으로 로그와 색인을 주기적으로 세어 봅니다.

## 6. 한계

- **정규식은 모양만 봅니다**: 하이픈과 공백이 섞인 변형, 전각 숫자, 숫자 사이에 낀 줄바꿈은 놓칠 수 있습니다. 유선전화와 해외 번호는 이 글의 규칙에 없습니다. 주민등록번호 형식은 체크섬을 쓰지 않고 날짜만 검사하므로, 접두어 없는 13자리 숫자가 날짜처럼 보이면 가려지는 오탐이 있습니다.
- **정형 값만 다룹니다**: 이름, 주소, 계좌 별칭, 병명처럼 정해진 모양이 없는 값은 정규식으로 찾지 못합니다. 이 글의 가입 로그에서도 `name=테스트고객1` 은 그대로 남았습니다. 이런 값은 NER 같은 별도 탐지나 "이 필드는 로그에 남기지 않는다" 는 규칙으로 다룹니다.
- **프롬프트에서는 문맥이 남습니다**: 값을 지워도 "서울 강남구 ○○동 3층 치과의사" 같은 서술은 그대로 전달됩니다.
- **마스킹과 가명처리는 다릅니다**: 이 글의 마스킹은 값의 일부를 지워 되돌릴 수 없게 하는 방식입니다. 가명처리는 일반적으로, 따로 보관하는 추가 정보(대응표)가 있으면 원래 값으로 되돌릴 수 있게 다른 값으로 바꾸는 처리를 가리킵니다. 뒤 네 자리를 남긴 마스킹은 다른 정보와 결합하면 사람을 알아볼 수 있으므로, 이 결과를 곧바로 익명이라고 부를 수는 없습니다.
- **법적 판단은 별개입니다**: 어떤 처리가 법에서 말하는 가명처리나 익명처리에 해당하는지, 과징금, 유출 통지, 안전성 확보조치 같은 의무가 지금 어떻게 정해져 있는지는 이 글에서 다루지 않습니다. 조항과 시행일은 개인정보보호위원회와 국가법령정보센터의 공식 자료로 확인합니다.

## 자주 막히는 곳

- **`docker compose up` 후 `/health` 가 오래 안 열림**: 앱 컨테이너가 시작할 때 Flask 를 설치하므로 처음에는 1분 안팎 걸립니다. `docker logs cr-pii-app` 으로 확인합니다.
- **Discover 에 아무것도 안 나옴**: 오른쪽 위 시간 범위가 "Last 1 hour" 인지 확인합니다. 로그를 색인한 지 한 시간이 넘었다면 범위를 넓힙니다.
- **`ship_logs.py` 에서 `FileNotFoundError`**: 해당 모드로 `send_traffic.py` 를 먼저 실행하지 않았거나 `logs` 폴더가 없는 경우입니다. 인자 없이 실행하면 before 와 after 파일이 모두 있어야 합니다.
- **PowerShell 에서 `MASK=1` 오류**: `$env:MASK = "1"` 을 먼저 실행한 뒤 `docker compose up -d --force-recreate app` 만 실행합니다.

## 정리

실습이 끝나면 `cr-pii-` 로 시작하는 컨테이너와 볼륨만 지웁니다.

```bash
docker compose down -v
```

작업 폴더의 `logs` 폴더에는 가짜 값이 담긴 로그 파일이 남아 있으니 함께 지웁니다.

## 확인 범위

- **해 본 것:** Windows Docker Desktop에서 OpenSearch 3.2.0, OpenSearch Dashboards 3.2.0, `python:3.12-slim`(Flask 3.1.3)을 띄웠습니다. 호스트 Python 3.12.10으로 위 파일을 실행하여 인용한 출력과 화면을 확인했습니다. 호스트 포트(5790~5793)는 실행한 값 그대로입니다.
- **해 보지 않은 것:** Linux와 Mac, 3.2.0 이외 버전, 실제 LLM API와 연결한 구성, 운영 로그 수집기(Fluent Bit 등)와 함께 쓰는 구성, 이름과 주소 같은 비정형 값의 탐지.
- **읽을 때 주의:** 이 글은 법률 자문이 아닙니다.
