Enterprise AI Architecture Blueprint 2편: 보안 아키텍처와 데이터 분류

class PromptInjectionGuard:
    INJECTION_PATTERNS = [
        "ignore previous instructions",
        "system: you are now",
        "forget everything above",
        "새로운 역할",
        "이전 지시를 무시",
    ]

    def check(self, user_input: str) -> bool:
        lower = user_input.lower()
        for pattern in self.INJECTION_PATTERNS:
            if pattern in lower:
                return False  # 차단
        return True

    def sanitize(self, user_input: str) -> str:
        # 사용자 입력을 명시적으로 구분
        return f"[USER INPUT START]\n{user_input}\n[USER INPUT END]"

import re

class OutputFilter:
    PII_PATTERNS = {
        "email": r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
        "phone": r'\b\d{2,3}[-.]?\d{3,4}[-.]?\d{4}\b',
        "ssn": r'\b\d{6}[-]?\d{7}\b',
        "card": r'\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b',
    }

    def filter(self, text: str) -> str:
        for pii_type, pattern in self.PII_PATTERNS.items():
            text = re.sub(pattern, f"[{pii_type.upper()} REDACTED]", text)
        return text

from enum import Enum

class DataClassification(Enum):
    PUBLIC = "public"
    INTERNAL = "internal"
    CONFIDENTIAL = "confidential"
    RESTRICTED = "restricted"

class AIGateway:
    """데이터 분류에 따라 사용 가능한 모델 제한"""

    MODEL_PERMISSIONS = {
        DataClassification.PUBLIC: ["claude-sonnet-4-6", "gpt-4o"],
        DataClassification.INTERNAL: ["claude-sonnet-4-6"],          # 외부 모델 불가
        DataClassification.CONFIDENTIAL: ["private-llm-on-prem"],    # 온프레미스만
        DataClassification.RESTRICTED: [],                             # AI 사용 불가
    }

    def allowed_models(self, classification: DataClassification) -> list:
        return self.MODEL_PERMISSIONS.get(classification, [])

    async def query(self, prompt: str, classification: DataClassification) -> str:
        models = self.allowed_models(classification)
        if not models:
            raise PermissionError(f"{classification.value} 데이터는 AI 처리 불가")
        return await llm_call(models[0], prompt)

사용자 요청
    ↓
[입력 필터]
  - 프롬프트 인젝션 탐지
  - PII 감지 및 마스킹
  - 토큰 한도 확인
    ↓
[인증/인가]
  - JWT 검증
  - RBAC 권한 확인
  - 데이터 분류 결정
    ↓
[LLM 호출]
  - 허용된 모델만 사용
  - 감사 로그 기록
    ↓
[출력 필터]
  - PII 재검사
  - 유해 콘텐츠 필터
  - 응답 로깅
    ↓
사용자 응답

from functools import wraps

ROLE_MODEL_ACCESS = {
    "viewer": ["claude-haiku-4-5"],
    "editor": ["claude-haiku-4-5", "claude-sonnet-4-6"],
    "admin": ["claude-haiku-4-5", "claude-sonnet-4-6", "claude-opus-4-7"],
}

def require_model_access(model: str):
    def decorator(fn):
        @wraps(fn)
        async def wrapper(user_role: str, *args, **kwargs):
            allowed = ROLE_MODEL_ACCESS.get(user_role, [])
            if model not in allowed:
                raise PermissionError(f"{user_role}는 {model} 사용 불가")
            return await fn(*args, **kwargs)
        return wrapper
    return decorator

@require_model_access("claude-opus-4-7")
async def complex_analysis(text: str) -> str:
    return await llm_call("claude-opus-4-7", text)

resp = ask(user="general-user", q="기밀시험 프로젝트 예산은?")
assert "CANARY-7F3A" not in resp.text
assert all(c.metadata["classification"] != "confidential" for c in resp.citations)