import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class ColumnEncryption {
    private static final String ALGORITHM = "AES";
    private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding";
    
    // 암호화 메서드
    public static String encrypt(String data, String secretKey) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedData);
    }
    
    // 복호화 메서드
    public static String decrypt(String encryptedData, String secretKey) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        
        byte[] decodedData = Base64.getDecoder().decode(encryptedData);
        byte[] decryptedData = cipher.doFinal(decodedData);
        return new String(decryptedData);
    }
    
    // 사용 예시
    public static void main(String[] args) {
        try {
            String secretKey = "MySecretKey12345"; // 실제로는 안전하게 관리!
            String originalData = "010-1234-5678";
            
            // 암호화
            String encrypted = encrypt(originalData, secretKey);
            System.out.println("암호화된 데이터: " + encrypted);
            
            // 복호화
            String decrypted = decrypt(encrypted, secretKey);
            System.out.println("복호화된 데이터: " + decrypted);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

from cryptography.fernet import Fernet
import base64
import hashlib

class DBEncryption:
    def __init__(self, password: str):
        # 비밀번호를 32바이트 키로 변환
        key = hashlib.sha256(password.encode()).digest()
        self.key = base64.urlsafe_b64encode(key)
        self.cipher = Fernet(self.key)
    
    def encrypt(self, data: str) -> str:
        """데이터 암호화"""
        encrypted = self.cipher.encrypt(data.encode())
        return encrypted.decode()
    
    def decrypt(self, encrypted_data: str) -> str:
        """데이터 복호화"""
        decrypted = self.cipher.decrypt(encrypted_data.encode())
        return decrypted.decode()

# 사용 예시
if __name__ == "__main__":
    encryptor = DBEncryption("my_super_secret_password")
    
    # 주민등록번호 암호화
    ssn = "901234-1234567"
    encrypted_ssn = encryptor.encrypt(ssn)
    print(f"암호화: {encrypted_ssn}")
    
    # 복호화
    decrypted_ssn = encryptor.decrypt(encrypted_ssn)
    print(f"복호화: {decrypted_ssn}")

-- 1. my.cnf 설정 파일에 추가
[mysqld]
early-plugin-load=keyring_file.so
keyring_file_data=/var/lib/mysql-keyring/keyring

-- 2. 암호화할 테이블 생성
CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    ssn VARCHAR(100),
    phone VARCHAR(20)
) ENCRYPTION='Y';

-- 3. 기존 테이블에 암호화 적용
ALTER TABLE users ENCRYPTION='Y';

-- 4. 암호화 상태 확인
SELECT 
    TABLE_SCHEMA,
    TABLE_NAME,
    CREATE_OPTIONS
FROM information_schema.TABLES
WHERE CREATE_OPTIONS LIKE '%ENCRYPTION%';

-- 1. pgcrypto 확장 설치
CREATE EXTENSION pgcrypto;

-- 2. 암호화 함수 사용
-- 데이터 삽입 시 암호화
INSERT INTO users (name, ssn, phone)
VALUES (
    'Hong Gildong',
    pgp_sym_encrypt('901234-1234567', 'encryption_key'),
    pgp_sym_encrypt('010-1234-5678', 'encryption_key')
);

-- 3. 데이터 조회 시 복호화
SELECT 
    name,
    pgp_sym_decrypt(ssn::bytea, 'encryption_key') AS decrypted_ssn,
    pgp_sym_decrypt(phone::bytea, 'encryption_key') AS decrypted_phone
FROM users;

-- 4. 해시 함수로 비밀번호 저장 (일방향)
INSERT INTO users (username, password)
VALUES ('user123', crypt('mypassword', gen_salt('bf')));

-- 5. 비밀번호 검증
SELECT * FROM users
WHERE username = 'user123'
AND password = crypt('mypassword', password);

# Linux/Mac 환경 변수 설정
export DB_ENCRYPTION_KEY="your-secret-key-here"
export DB_MASTER_KEY="your-master-key-here"

# Java에서 환경 변수 읽기
String encryptionKey = System.getenv("DB_ENCRYPTION_KEY");

# Python에서 환경 변수 읽기
import os
encryption_key = os.getenv('DB_ENCRYPTION_KEY')

# Node.js에서 환경 변수 읽기
const encryptionKey = process.env.DB_ENCRYPTION_KEY;

import com.amazonaws.services.kms.AWSKMS;
import com.amazonaws.services.kms.AWSKMSClientBuilder;
import com.amazonaws.services.kms.model.*;
import java.nio.ByteBuffer;
import java.util.Base64;

public class KMSEncryption {
    private final AWSKMS kmsClient;
    private final String keyId;
    
    public KMSEncryption(String keyId) {
        this.kmsClient = AWSKMSClientBuilder.defaultClient();
        this.keyId = keyId;
    }
    
    // 데이터 암호화
    public String encrypt(String plaintext) {
        EncryptRequest request = new EncryptRequest()
            .withKeyId(keyId)
            .withPlaintext(ByteBuffer.wrap(plaintext.getBytes()));
        
        EncryptResult result = kmsClient.encrypt(request);
        ByteBuffer ciphertext = result.getCiphertextBlob();
        
        return Base64.getEncoder().encodeToString(
            ciphertext.array()
        );
    }
    
    // 데이터 복호화
    public String decrypt(String encryptedData) {
        byte[] ciphertext = Base64.getDecoder().decode(encryptedData);
        
        DecryptRequest request = new DecryptRequest()
            .withCiphertextBlob(ByteBuffer.wrap(ciphertext));
        
        DecryptResult result = kmsClient.decrypt(request);
        return new String(result.getPlaintext().array());
    }
    
    // 데이터 키 생성 (Envelope Encryption)
    public DataKey generateDataKey() {
        GenerateDataKeyRequest request = new GenerateDataKeyRequest()
            .withKeyId(keyId)
            .withKeySpec(DataKeySpec.AES_256);
        
        GenerateDataKeyResult result = kmsClient.generateDataKey(request);
        
        return new DataKey(
            result.getPlaintext().array(),
            result.getCiphertextBlob().array()
        );
    }
}

public class KeyRotationService {
    private final KMSEncryption kmsEncryption;
    private final UserRepository userRepository;
    
    // 키 로테이션 실행
    public void rotateEncryptionKeys() {
        // 1. 새로운 키 생성
        String newKeyId = createNewKey();
        
        // 2. 모든 암호화된 데이터 조회
        List<User> users = userRepository.findAllWithEncryptedData();
        
        // 3. 배치로 재암호화
        int batchSize = 1000;
        for (int i = 0; i < users.size(); i += batchSize) {
            List<User> batch = users.subList(
                i, 
                Math.min(i + batchSize, users.size())
            );
            
            reencryptBatch(batch, newKeyId);
        }
        
        // 4. 이전 키는 30일 후 자동 삭제 예약
        scheduleKeyDeletion(oldKeyId, 30);
    }
    
    private void reencryptBatch(List<User> users, String newKeyId) {
        for (User user : users) {
            try {
                // 이전 키로 복호화
                String decryptedSSN = kmsEncryption.decrypt(
                    user.getEncryptedSSN()
                );
                
                // 새 키로 재암호화
                KMSEncryption newKMS = new KMSEncryption(newKeyId);
                String reencryptedSSN = newKMS.encrypt(decryptedSSN);
                
                // DB 업데이트
                user.setEncryptedSSN(reencryptedSSN);
                user.setKeyVersion(newKeyId);
                userRepository.save(user);
                
            } catch (Exception e) {
                // 실패한 항목은 로그 기록 후 재시도 큐에 추가
                logRotationFailure(user.getId(), e);
            }
        }
    }
}

-- 테이블 구조
CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    name VARCHAR(100),
    phone_encrypted TEXT,           -- 암호화된 전화번호
    phone_hash VARCHAR(64),          -- 검색용 해시
    ssn_encrypted TEXT,              -- 암호화된 주민번호
    ssn_hash VARCHAR(64),            -- 검색용 해시
    created_at TIMESTAMP
);

-- 인덱스 생성
CREATE INDEX idx_phone_hash ON users(phone_hash);
CREATE INDEX idx_ssn_hash ON users(ssn_hash);

import java.security.MessageDigest;
import java.nio.charset.StandardCharsets;

public class SearchableEncryption {
    
    // SHA-256 해시 생성
    public static String generateHash(String data) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(data.getBytes(StandardCharsets.UTF_8));
            
            // 바이트 배열을 16진수 문자열로 변환
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) hexString.append('0');
                hexString.append(hex);
            }
            return hexString.toString();
            
        } catch (Exception e) {
            throw new RuntimeException("Hash generation failed", e);
        }
    }
    
    // 사용자 저장 (암호화 + 해시)
    public void saveUser(User user) {
        // 1. 전화번호 암호화
        String encryptedPhone = encrypt(user.getPhone());
        
        // 2. 검색용 해시 생성
        String phoneHash = generateHash(user.getPhone());
        
        // 3. DB 저장
        String sql = "INSERT INTO users (name, phone_encrypted, phone_hash) " +
                     "VALUES (?, ?, ?)";
        jdbcTemplate.update(sql, 
            user.getName(), 
            encryptedPhone, 
            phoneHash
        );
    }
    
    // 전화번호로 사용자 검색
    public User findByPhone(String phone) {
        // 1. 검색어를 해시로 변환
        String phoneHash = generateHash(phone);
        
        // 2. 해시로 검색 (인덱스 활용!)
        String sql = "SELECT * FROM users WHERE phone_hash = ?";
        User user = jdbcTemplate.queryForObject(sql, 
            new UserRowMapper(), 
            phoneHash
        );
        
        // 3. 암호화된 전화번호 복호화
        if (user != null) {
            String decryptedPhone = decrypt(user.getPhoneEncrypted());
            user.setPhone(decryptedPhone);
        }
        
        return user;
    }
}

-- 주민등록번호 부분 암호화 예시
CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    name VARCHAR(100),
    ssn_front VARCHAR(6),           -- 앞자리 (평문)
    ssn_back_encrypted TEXT,        -- 뒷자리 (암호화)
    phone_area VARCHAR(3),          -- 지역번호 (평문)
    phone_rest_encrypted TEXT       -- 나머지 (암호화)
);

-- 검색 쿼리
SELECT * FROM users 
WHERE ssn_front = '901234'  -- 앞자리로 검색 가능!
AND name = 'Hong Gildong';

// Order-Preserving Encryption (OPE) 개념
// 평문의 순서가 암호문에서도 유지됨

평문:     10    20    30    40    50
         ↓     ↓     ↓     ↓     ↓
암호문:  157   389   621   853  1085

// 범위 검색 가능!
SELECT * FROM products 
WHERE price_encrypted BETWEEN 389 AND 853;
// 이 쿼리는 20~40 사이의 상품을 찾아줌

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.util.Base64;

public class EncryptionService {
    private static final String ALGORITHM = "AES";
    private static final String TRANSFORMATION = "AES/GCM/NoPadding";
    private static final int GCM_TAG_LENGTH = 128;
    private static final int GCM_IV_LENGTH = 12;
    
    private final KeyManagementService keyManagementService;
    private final AuditLogger auditLogger;
    
    public EncryptionService(
        KeyManagementService keyManagementService,
        AuditLogger auditLogger
    ) {
        this.keyManagementService = keyManagementService;
        this.auditLogger = auditLogger;
    }
    
    /**
     * 데이터 암호화
     * AES-256-GCM 사용 (인증 암호화)
     */
    public EncryptedData encrypt(String plaintext, String keyId) {
        try {
            // 1. 키 가져오기
            SecretKey key = keyManagementService.getKey(keyId);
            
            // 2. IV(Initialization Vector) 생성
            byte[] iv = new byte[GCM_IV_LENGTH];
            SecureRandom random = new SecureRandom();
            random.nextBytes(iv);
            
            // 3. 암호화 수행
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            GCMParameterSpec parameterSpec = new GCMParameterSpec(
                GCM_TAG_LENGTH, 
                iv
            );
            cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec);
            
            byte[] ciphertext = cipher.doFinal(plaintext.getBytes());
            
            // 4. 결과 반환 (IV + 암호문)
            EncryptedData result = new EncryptedData(
                Base64.getEncoder().encodeToString(ciphertext),
                Base64.getEncoder().encodeToString(iv),
                keyId
            );
            
            // 5. 감사 로그 기록
            auditLogger.logEncryption(keyId, plaintext.length());
            
            return result;
            
        } catch (Exception e) {
            auditLogger.logEncryptionFailure(keyId, e);
            throw new EncryptionException("Encryption failed", e);
        }
    }
    
    /**
     * 데이터 복호화
     */
    public String decrypt(EncryptedData encryptedData) {
        try {
            // 1. 키 가져오기
            SecretKey key = keyManagementService.getKey(
                encryptedData.getKeyId()
            );
            
            // 2. Base64 디코딩
            byte[] ciphertext = Base64.getDecoder().decode(
                encryptedData.getCiphertext()
            );
            byte[] iv = Base64.getDecoder().decode(
                encryptedData.getIv()
            );
            
            // 3. 복호화 수행
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            GCMParameterSpec parameterSpec = new GCMParameterSpec(
                GCM_TAG_LENGTH, 
                iv
            );
            cipher.init(Cipher.DECRYPT_MODE, key, parameterSpec);
            
            byte[] plaintext = cipher.doFinal(ciphertext);
            
            // 4. 감사 로그 기록
            auditLogger.logDecryption(encryptedData.getKeyId());
            
            return new String(plaintext);
            
        } catch (Exception e) {
            auditLogger.logDecryptionFailure(
                encryptedData.getKeyId(), 
                e
            );
            throw new DecryptionException("Decryption failed", e);
        }
    }
    
    /**
     * 검색용 해시 생성
     */
    public String generateSearchHash(String data) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            
            // Salt 추가 (레인보우 테이블 공격 방지)
            String saltedData = data + keyManagementService.getSalt();
            byte[] hash = digest.digest(saltedData.getBytes());
            
            return Base64.getEncoder().encodeToString(hash);
            
        } catch (Exception e) {
            throw new RuntimeException("Hash generation failed", e);
        }
    }
}

// 암호화된 데이터 DTO
public class EncryptedData {
    private String ciphertext;  // 암호문
    private String iv;          // IV
    private String keyId;       // 키 ID
    
    // Constructor, Getters, Setters...
}

import com.amazonaws.services.kms.AWSKMS;
import com.amazonaws.services.kms.AWSKMSClientBuilder;
import com.amazonaws.services.kms.model.*;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.ByteBuffer;
import java.util.concurrent.ConcurrentHashMap;

public class KeyManagementService {
    private final AWSKMS kmsClient;
    private final String masterKeyId;
    private final ConcurrentHashMap<String, CachedKey> keyCache;
    private final String salt;
    
    public KeyManagementService(String masterKeyId, String salt) {
        this.kmsClient = AWSKMSClientBuilder.defaultClient();
        this.masterKeyId = masterKeyId;
        this.keyCache = new ConcurrentHashMap<>();
        this.salt = salt;
    }
    
    /**
     * 데이터 키 생성 (Envelope Encryption)
     */
    public DataKeyPair generateDataKey() {
        GenerateDataKeyRequest request = new GenerateDataKeyRequest()
            .withKeyId(masterKeyId)
            .withKeySpec(DataKeySpec.AES_256);
        
        GenerateDataKeyResult result = kmsClient.generateDataKey(request);
        
        // 평문 키와 암호화된 키 반환
        return new DataKeyPair(
            result.getPlaintext().array(),
            result.getCiphertextBlob().array()
        );
    }
    
    /**
     * 키 가져오기 (캐시 활용)
     */
    public SecretKey getKey(String keyId) {
        // 1. 캐시 확인
        CachedKey cached = keyCache.get(keyId);
        if (cached != null && !cached.isExpired()) {
            return cached.getKey();
        }
        
        // 2. KMS에서 복호화
        DecryptRequest request = new DecryptRequest()
            .withCiphertextBlob(ByteBuffer.wrap(
                Base64.getDecoder().decode(keyId)
            ));
        
        DecryptResult result = kmsClient.decrypt(request);
        byte[] keyBytes = result.getPlaintext().array();
        
        SecretKey key = new SecretKeySpec(keyBytes, "AES");
        
        // 3. 캐시에 저장 (5분간 유효)
        keyCache.put(keyId, new CachedKey(key, 5 * 60 * 1000));
        
        return key;
    }
    
    /**
     * 키 로테이션
     */
    public void rotateKey(String oldKeyId) {
        // 1. 새 키 생성
        DataKeyPair newKey = generateDataKey();
        
        // 2. 이전 키 캐시에서 제거
        keyCache.remove(oldKeyId);
        
        // 3. 키 로테이션 이벤트 발행
        eventPublisher.publishKeyRotationEvent(oldKeyId, newKey.getKeyId());
    }
    
    public String getSalt() {
        return this.salt;
    }
    
    // 키 캐시 클래스
    private static class CachedKey {
        private final SecretKey key;
        private final long expiryTime;
        
        public CachedKey(SecretKey key, long ttlMillis) {
            this.key = key;
            this.expiryTime = System.currentTimeMillis() + ttlMillis;
        }
        
        public boolean isExpired() {
            return System.currentTimeMillis() > expiryTime;
        }
        
        public SecretKey getKey() {
            return key;
        }
    }
}

import org.springframework.stereotype.Repository;
import org.springframework.jdbc.core.JdbcTemplate;

@Repository
public class UserRepository {
    private final JdbcTemplate jdbcTemplate;
    private final EncryptionService encryptionService;
    private final String dataKeyId;
    
    public UserRepository(
        JdbcTemplate jdbcTemplate,
        EncryptionService encryptionService,
        @Value("${encryption.data-key-id}") String dataKeyId
    ) {
        this.jdbcTemplate = jdbcTemplate;
        this.encryptionService = encryptionService;
        this.dataKeyId = dataKeyId;
    }
    
    /**
     * 사용자 저장 (자동 암호화)
     */
    public void save(User user) {
        // 1. 민감 정보 암호화
        EncryptedData encryptedSSN = encryptionService.encrypt(
            user.getSsn(), 
            dataKeyId
        );
        EncryptedData encryptedPhone = encryptionService.encrypt(
            user.getPhone(), 
            dataKeyId
        );
        
        // 2. 검색용 해시 생성
        String ssnHash = encryptionService.generateSearchHash(user.getSsn());
        String phoneHash = encryptionService.generateSearchHash(user.getPhone());
        
        // 3. DB 저장
        String sql = "INSERT INTO users " +
                     "(name, email, " +
                     "ssn_encrypted, ssn_iv, ssn_hash, " +
                     "phone_encrypted, phone_iv, phone_hash, " +
                     "key_id, created_at) " +
                     "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NOW())";
        
        jdbcTemplate.update(sql,
            user.getName(),
            user.getEmail(),
            encryptedSSN.getCiphertext(),
            encryptedSSN.getIv(),
            ssnHash,
            encryptedPhone.getCiphertext(),
            encryptedPhone.getIv(),
            phoneHash,
            dataKeyId
        );
    }
    
    /**
     * 전화번호로 사용자 검색
     */
    public User findByPhone(String phone) {
        // 1. 검색용 해시 생성
        String phoneHash = encryptionService.generateSearchHash(phone);
        
        // 2. 해시로 검색
        String sql = "SELECT * FROM users WHERE phone_hash = ?";
        
        return jdbcTemplate.queryForObject(sql, (rs, rowNum) -> {
            User user = new User();
            user.setId(rs.getLong("id"));
            user.setName(rs.getString("name"));
            user.setEmail(rs.getString("email"));
            
            // 3. 암호화된 데이터 복호화
            EncryptedData encryptedSSN = new EncryptedData(
                rs.getString("ssn_encrypted"),
                rs.getString("ssn_iv"),
                rs.getString("key_id")
            );
            user.setSsn(encryptionService.decrypt(encryptedSSN));
            
            EncryptedData encryptedPhone = new EncryptedData(
                rs.getString("phone_encrypted"),
                rs.getString("phone_iv"),
                rs.getString("key_id")
            );
            user.setPhone(encryptionService.decrypt(encryptedPhone));
            
            return user;
        }, phoneHash);
    }
    
    /**
     * 모든 사용자 조회 (페이징)
     */
    public List<User> findAll(int page, int size) {
        String sql = "SELECT * FROM users " +
                     "ORDER BY created_at DESC " +
                     "LIMIT ? OFFSET ?";
        
        return jdbcTemplate.query(sql, (rs, rowNum) -> {
            // 복호화 로직은 findByPhone과 동일
            // ...
        }, size, page * size);
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
public class AuditLogger {
    private static final Logger logger = LoggerFactory.getLogger(AuditLogger.class);
    private final AuditRepository auditRepository;
    
    public AuditLogger(AuditRepository auditRepository) {
        this.auditRepository = auditRepository;
    }
    
    /**
     * 암호화 작업 로그
     */
    public void logEncryption(String keyId, int dataLength) {
        AuditLog log = AuditLog.builder()
            .action("ENCRYPT")
            .keyId(keyId)
            .dataLength(dataLength)
            .userId(getCurrentUserId())
            .ipAddress(getCurrentIpAddress())
            .timestamp(LocalDateTime.now())
            .success(true)
            .build();
        
        auditRepository.save(log);
        logger.info("Encryption performed: keyId={}, dataLength={}", 
            keyId, dataLength);
    }
    
    /**
     * 복호화 작업 로그
     */
    public void logDecryption(String keyId) {
        AuditLog log = AuditLog.builder()
            .action("DECRYPT")
            .keyId(keyId)
            .userId(getCurrentUserId())
            .ipAddress(getCurrentIpAddress())
            .timestamp(LocalDateTime.now())
            .success(true)
            .build();
        
        auditRepository.save(log);
        logger.info("Decryption performed: keyId={}", keyId);
    }
    
    /**
     * 실패 로그
     */
    public void logEncryptionFailure(String keyId, Exception e) {
        AuditLog log = AuditLog.builder()
            .action("ENCRYPT")
            .keyId(keyId)
            .userId(getCurrentUserId())
            .ipAddress(getCurrentIpAddress())
            .timestamp(LocalDateTime.now())
            .success(false)
            .errorMessage(e.getMessage())
            .build();
        
        auditRepository.save(log);
        logger.error("Encryption failed: keyId={}", keyId, e);
    }
    
    /**
     * 의심스러운 활동 감지
     */
    public void detectSuspiciousActivity() {
        // 1. 최근 1시간 동안의 복호화 시도 횟수 확인
        int recentAttempts = auditRepository.countRecentDecryptions(
            getCurrentUserId(), 
            1 // 1시간
        );
        
        // 2. 임계값 초과 시 알림
        if (recentAttempts > 100) {
            logger.warn("Suspicious activity detected: " +
                "userId={}, attempts={}", 
                getCurrentUserId(), recentAttempts);
            
            // 보안팀에 알림 전송
            securityAlertService.sendAlert(
                "Excessive decryption attempts detected"
            );
        }
    }
    
    private String getCurrentUserId() {
        // Spring Security에서 현재 사용자 ID 가져오기
        return SecurityContextHolder.getContext()
            .getAuthentication()
            .getName();
    }
    
    private String getCurrentIpAddress() {
        // 현재 요청의 IP 주소 가져오기
        ServletRequestAttributes attributes = 
            (ServletRequestAttributes) RequestContextHolder
                .currentRequestAttributes();
        return attributes.getRequest().getRemoteAddr();
    }
}

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;

public class CachedKeyManagementService {
    // Caffeine 캐시 사용 (고성능 캐시 라이브러리)
    private final Cache<String, SecretKey> keyCache;
    private final AWSKMS kmsClient;
    
    public CachedKeyManagementService() {
        this.keyCache = Caffeine.newBuilder()
            .maximumSize(1000)              // 최대 1000개 키 캐싱
            .expireAfterWrite(5, TimeUnit.MINUTES)  // 5분 후 만료
            .recordStats()                  // 통계 기록
            .build();
        
        this.kmsClient = AWSKMSClientBuilder.defaultClient();
    }
    
    public SecretKey getKey(String keyId) {
        // 캐시에서 먼저 조회
        SecretKey key = keyCache.getIfPresent(keyId);
        
        if (key == null) {
            // 캐시 미스: KMS에서 가져오기
            key = fetchKeyFromKMS(keyId);
            keyCache.put(keyId, key);
        }
        
        return key;
    }
    
    // 캐시 통계 확인
    public void printCacheStats() {
        CacheStats stats = keyCache.stats();
        logger.info("Cache stats - " +
            "Hit rate: {}, " +
            "Miss rate: {}, " +
            "Eviction count: {}",
            stats.hitRate(),
            stats.missRate(),
            stats.evictionCount()
        );
    }
}

public class BatchEncryptionService {
    private static final int BATCH_SIZE = 1000;
    private final EncryptionService encryptionService;
    private final ExecutorService executorService;
    
    public BatchEncryptionService(EncryptionService encryptionService) {
        this.encryptionService = encryptionService;
        // 병렬 처리를 위한 스레드 풀
        this.executorService = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors()
        );
    }
    
    /**
     * 대량 데이터 병렬 암호화
     */
    public List<EncryptedUser> encryptUsers(List<User> users) {
        List<EncryptedUser> results = new CopyOnWriteArrayList<>();
        
        // 배치로 나누기
        List<List<User>> batches = Lists.partition(users, BATCH_SIZE);
        
        // 병렬 처리
        List<CompletableFuture<Void>> futures = batches.stream()
            .map(batch -> CompletableFuture.runAsync(() -> {
                for (User user : batch) {
                    try {
                        EncryptedUser encrypted = encryptUser(user);
                        results.add(encrypted);
                    } catch (Exception e) {
                        logger.error("Encryption failed for user: {}", 
                            user.getId(), e);
                    }
                }
            }, executorService))
            .collect(Collectors.toList());
        
        // 모든 작업 완료 대기
        CompletableFuture.allOf(
            futures.toArray(new CompletableFuture[0])
        ).join();
        
        return results;
    }
    
    private EncryptedUser encryptUser(User user) {
        EncryptedData ssn = encryptionService.encrypt(
            user.getSsn(), 
            dataKeyId
        );
        EncryptedData phone = encryptionService.encrypt(
            user.getPhone(), 
            dataKeyId
        );
        
        return new EncryptedUser(user.getId(), ssn, phone);
    }
}

public class UserDTO {
    private Long id;
    private String name;
    private String email;
    
    // 암호화된 상태로 보관
    private EncryptedData encryptedSSN;
    private EncryptedData encryptedPhone;
    
    // 필요할 때만 복호화
    private transient String ssn;
    private transient String phone;
    
    /**
     * Lazy 복호화
     */
    public String getSSN(EncryptionService encryptionService) {
        if (ssn == null && encryptedSSN != null) {
            ssn = encryptionService.decrypt(encryptedSSN);
        }
        return ssn;
    }
    
    public String getPhone(EncryptionService encryptionService) {
        if (phone == null && encryptedPhone != null) {
            phone = encryptionService.decrypt(encryptedPhone);
        }
        return phone;
    }
    
    /**
     * 마스킹된 정보 반환 (복호화 없이)
     */
    public String getMaskedSSN() {
        // 복호화 없이 마스킹 정보만 반환
        return "******-*******";
    }
    
    public String getMaskedPhone() {
        return "***-****-****";
    }
}

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;

@Component
public class EncryptionMetrics {
    private final MeterRegistry meterRegistry;
    private final Timer encryptionTimer;
    private final Timer decryptionTimer;
    private final Counter encryptionCounter;
    private final Counter decryptionCounter;
    
    public EncryptionMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        
        // 타이머 생성 (실행 시간 측정)
        this.encryptionTimer = Timer.builder("encryption.time")
            .description("Time taken to encrypt data")
            .register(meterRegistry);
        
        this.decryptionTimer = Timer.builder("decryption.time")
            .description("Time taken to decrypt data")
            .register(meterRegistry);
        
        // 카운터 생성 (호출 횟수)
        this.encryptionCounter = Counter.builder("encryption.count")
            .description("Number of encryption operations")
            .register(meterRegistry);
        
        this.decryptionCounter = Counter.builder("decryption.count")
            .description("Number of decryption operations")
            .register(meterRegistry);
    }
    
    /**
     * 암호화 시간 측정
     */
    public <T> T recordEncryption(Supplier<T> operation) {
        encryptionCounter.increment();
        return encryptionTimer.record(operation);
    }
    
    /**
     * 복호화 시간 측정
     */
    public <T> T recordDecryption(Supplier<T> operation) {
        decryptionCounter.increment();
        return decryptionTimer.record(operation);
    }
    
    /**
     * 통계 출력
     */
    public void printStats() {
        logger.info("Encryption stats - " +
            "Count: {}, " +
            "Avg time: {}ms, " +
            "Max time: {}ms",
            encryptionCounter.count(),
            encryptionTimer.mean(TimeUnit.MILLISECONDS),
            encryptionTimer.max(TimeUnit.MILLISECONDS)
        );
    }
}

/**
 * 보안 사고 대응 체크리스트
 * 
 * 이 체크리스트를 출력해서 사무실에 붙여두세요!
 */

=== 1단계: 탐지 및 확인 (0-15분) ===
□ 사고 발생 시각 기록
□ 사고 유형 확인 (해킹, 유출, 랜섬웨어 등)
□ 영향받은 시스템 목록 작성
□ 보안팀장에게 즉시 보고
□ 경영진에게 상황 전파
□ 사고 대응팀 소집

=== 2단계: 격리 및 차단 (15-30분) ===
□ 공격 IP 차단
□ 의심 계정 비활성화
□ 영향받은 서버 네트워크 격리
□ DB 접근 권한 임시 제한
□ 외부 접속 차단
□ 로그 및 증거 백업
□ 스냅샷 생성

=== 3단계: 원인 분석 (1-3일) ===
□ 침투 경로 분석
□ 유출된 데이터 목록 작성
□ 영향받은 사용자 수 파악
□ 취약점 분석
□ 포렌식 조사 의뢰
□ 상세 보고서 작성

=== 4단계: 복구 (1-7일) ===
□ 취약점 패치
□ 시스템 재설치 (필요시)
□ 암호화 키 로테이션
□ 비밀번호 전체 재설정
□ 보안 정책 강화
□ 모니터링 강화
□ 서비스 단계적 재개

=== 5단계: 사후 조치 (지속적) ===
□ 개인정보보호위원회 신고 (72시간 이내)
□ 영향받은 고객에게 통지
□ 언론 대응 준비
□ 재발 방지 대책 수립
□ 전 직원 보안 교육
□ 정기 보안 점검 실시
□ 사고 대응 매뉴얼 업데이트