데이터 프라이버시 및 보안

# 데이터 최소화 예제
class UserRegistration:
    # ❌ 나쁜 예: 불필요한 데이터 수집
    def register_user_bad(self, data):
        required_fields = [
            'name', 'email', 'phone', 'address',
            'birthdate', 'gender', 'income', 'education',
            'occupation', 'marital_status'  # 너무 많은 정보!
        ]
        return self._save_user(data, required_fields)

    # ✅ 좋은 예: 필요 최소 데이터만 수집
    def register_user_good(self, data):
        # 뉴스레터 서비스에 필요한 최소 정보
        required_fields = ['email']
        optional_fields = ['name']  # 개인화를 위한 선택 정보

        # 필수 정보만 요구
        user_data = {k: data[k] for k in required_fields if k in data}

        # 선택 정보는 사용자가 제공한 경우만
        for field in optional_fields:
            if field in data and data.get(f'{field}_consent'):
                user_data[field] = data[field]

        return self._save_user(user_data)

    # 데이터 최소화 검증
    def validate_data_necessity(self, field_name, purpose):
        """각 데이터 필드의 필요성 검증"""
        necessity_matrix = {
            'newsletter': ['email'],
            'ecommerce': ['name', 'email', 'address', 'phone'],
            'social_media': ['email', 'username'],
        }

        if purpose not in necessity_matrix:
            raise ValueError(f"정의되지 않은 목적: {purpose}")

        if field_name not in necessity_matrix[purpose]:
            raise ValueError(f"{field_name}은(는) {purpose}에 필요하지 않음")

        return True

# 익명화 및 가명화 예제
import hashlib
import secrets
from cryptography.fernet import Fernet

class DataPrivacyProtection:
    def __init__(self):
        self.encryption_key = Fernet.generate_key()
        self.cipher = Fernet(self.encryption_key)

    # 익명화: 일방향 해시 (비가역적)
    def anonymize(self, identifier):
        """개인 식별자를 익명화 (복구 불가능)"""
        salt = b'固定salt値'  # 실제로는 안전하게 저장
        hashed = hashlib.pbkdf2_hmac('sha256', identifier.encode(), salt, 100000)
        return hashed.hex()

    # 가명화: 가역적 암호화
    def pseudonymize(self, data):
        """데이터를 가명화 (키로 복구 가능)"""
        return self.cipher.encrypt(data.encode()).decode()

    def depseudonymize(self, pseudonym):
        """가명 데이터를 원본으로 복구"""
        return self.cipher.decrypt(pseudonym.encode()).decode()

    # 데이터 마스킹
    def mask_email(self, email):
        """이메일 마스킹: user@example.com → u***@example.com"""
        username, domain = email.split('@')
        masked_username = username[0] + '***' if len(username) > 1 else '***'
        return f'{masked_username}@{domain}'

    def mask_phone(self, phone):
        """전화번호 마스킹: 010-1234-5678 → 010-****-5678"""
        parts = phone.split('-')
        if len(parts) == 3:
            return f'{parts[0]}-****-{parts[2]}'
        return '***-****-****'

    # K-익명성 (k-anonymity) 검증
    def check_k_anonymity(self, dataset, quasi_identifiers, k=5):
        """준식별자 조합이 k명 이상인지 확인"""
        import pandas as pd
        df = pd.DataFrame(dataset)

        # 준식별자 조합별 그룹 크기
        groups = df.groupby(quasi_identifiers).size()

        # k보다 작은 그룹 찾기
        vulnerable_groups = groups[groups < k]

        if len(vulnerable_groups) > 0:
            print(f"⚠️ K-익명성 위반: {len(vulnerable_groups)}개 그룹이 {k}명 미만")
            return False

        print(f"✅ K-익명성 만족: 모든 그룹이 {k}명 이상")
        return True

# 사용 예시
protection = DataPrivacyProtection()
email = "user@example.com"

# 익명화 (비가역)
anon_id = protection.anonymize(email)
print(f"익명화: {anon_id}")

# 가명화 (가역)
pseudonym = protection.pseudonymize(email)
original = protection.depseudonymize(pseudonym)
print(f"가명화: {pseudonym}")
print(f"복구: {original}")

# 마스킹
masked = protection.mask_email(email)
print(f"마스킹: {masked}")

# 암호화 구현 예제
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os
import base64

class DataEncryption:
    def __init__(self):
        # AES-256 키 생성 (32 bytes = 256 bits)
        self.key = os.urandom(32)

    def encrypt_data(self, plaintext):
        """AES-256-GCM으로 데이터 암호화"""
        # IV (Initialization Vector) 생성
        iv = os.urandom(12)

        # GCM 모드 암호화 (인증 암호화)
        cipher = Cipher(
            algorithms.AES(self.key),
            modes.GCM(iv),
            backend=default_backend()
        )
        encryptor = cipher.encryptor()

        # 암호화 수행
        ciphertext = encryptor.update(plaintext.encode()) + encryptor.finalize()

        # IV, 암호문, 태그 반환
        return {
            'iv': base64.b64encode(iv).decode(),
            'ciphertext': base64.b64encode(ciphertext).decode(),
            'tag': base64.b64encode(encryptor.tag).decode()
        }

    def decrypt_data(self, encrypted_data):
        """암호화된 데이터 복호화"""
        # Base64 디코딩
        iv = base64.b64decode(encrypted_data['iv'])
        ciphertext = base64.b64decode(encrypted_data['ciphertext'])
        tag = base64.b64decode(encrypted_data['tag'])

        # GCM 모드 복호화
        cipher = Cipher(
            algorithms.AES(self.key),
            modes.GCM(iv, tag),
            backend=default_backend()
        )
        decryptor = cipher.decryptor()

        # 복호화 수행
        plaintext = decryptor.update(ciphertext) + decryptor.finalize()
        return plaintext.decode()

# 사용 예시
crypto = DataEncryption()
sensitive_data = "주민등록번호: 123456-1234567"

# 암호화
encrypted = crypto.encrypt_data(sensitive_data)
print(f"암호화: {encrypted['ciphertext'][:50]}...")

# 복호화
decrypted = crypto.decrypt_data(encrypted)
print(f"복호화: {decrypted}")

# 감사 로그 구현 예제
import logging
from datetime import datetime
import json

class AuditLogger:
    def __init__(self):
        # 감사 로그 설정
        self.logger = logging.getLogger('audit')
        self.logger.setLevel(logging.INFO)

        # 파일 핸들러 (로그 파일로 저장)
        handler = logging.FileHandler('audit_log.json')
        formatter = logging.Formatter('%(message)s')
        handler.setFormatter(formatter)
        self.logger.addHandler(handler)

    def log_access(self, user, resource, action, result, details=None):
        """데이터 접근 로그 기록"""
        log_entry = {
            'timestamp': datetime.utcnow().isoformat(),
            'event_type': 'data_access',
            'user': user,
            'resource': resource,
            'action': action,
            'result': result,  # success, denied, error
            'details': details
        }
        self.logger.info(json.dumps(log_entry))

    def log_modification(self, user, resource, old_value, new_value):
        """데이터 수정 로그 기록"""
        log_entry = {
            'timestamp': datetime.utcnow().isoformat(),
            'event_type': 'data_modification',
            'user': user,
            'resource': resource,
            'old_value': old_value,
            'new_value': new_value
        }
        self.logger.info(json.dumps(log_entry))

    def log_deletion(self, user, resource, data_summary):
        """데이터 삭제 로그 기록"""
        log_entry = {
            'timestamp': datetime.utcnow().isoformat(),
            'event_type': 'data_deletion',
            'user': user,
            'resource': resource,
            'data_summary': data_summary
        }
        self.logger.info(json.dumps(log_entry))

    def detect_anomalies(self, user, access_pattern):
        """이상 접근 패턴 탐지"""
        # 예: 비정상적인 시간대 접근
        current_hour = datetime.now().hour
        if current_hour < 6 or current_hour > 22:
            self.log_security_event(
                user,
                'unusual_access_time',
                f'비정상 시간대 접근: {current_hour}시'
            )

        # 예: 짧은 시간 내 과도한 접근
        if access_pattern.get('requests_per_minute', 0) > 100:
            self.log_security_event(
                user,
                'excessive_access',
                f'분당 {access_pattern["requests_per_minute"]}회 요청'
            )

    def log_security_event(self, user, event_type, description):
        """보안 이벤트 로그 및 알림"""
        log_entry = {
            'timestamp': datetime.utcnow().isoformat(),
            'event_type': event_type,
            'user': user,
            'severity': 'high',
            'description': description
        }
        self.logger.warning(json.dumps(log_entry))
        # 실제로는 보안팀에 알림
        print(f"🚨 보안 경고: {description}")

# 사용 예시
audit = AuditLogger()
audit.log_access('user123', 'customer_data', 'read', 'success')
audit.log_modification('admin', 'user:456', 'role:user', 'role:admin')