Cryptography

# RSA 및 하이브리드 암호화 예제 (Python)
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os
import base64

class HybridEncryptor:
    """
    하이브리드 암호화 (RSA + AES)
    - RSA로 대칭키 암호화 (키 교환)
    - AES로 실제 데이터 암호화 (성능)
    """

    def __init__(self):
        # RSA 4096비트 키 쌍 생성 (2048은 최소, 4096 권장)
        self.private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=4096
        )
        self.public_key = self.private_key.public_key()

    def get_public_key_pem(self) -> bytes:
        """공개키를 PEM 형식으로 내보내기"""
        return self.public_key.public_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PublicFormat.SubjectPublicKeyInfo
        )

    def encrypt(self, plaintext: str, recipient_public_key) -> dict:
        """
        하이브리드 암호화:
        1. 랜덤 AES 세션 키 생성
        2. RSA-OAEP로 세션 키 암호화
        3. AES-GCM으로 데이터 암호화
        """
        # 1. 랜덤 256비트 AES 세션 키 생성
        session_key = os.urandom(32)
        nonce = os.urandom(12)

        # 2. RSA-OAEP로 세션 키 암호화 (PSS 패딩 권장)
        encrypted_key = recipient_public_key.encrypt(
            session_key,
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )

        # 3. AES-GCM으로 데이터 암호화
        aesgcm = AESGCM(session_key)
        ciphertext = aesgcm.encrypt(nonce, plaintext.encode(), None)

        return {
            'encrypted_key': base64.b64encode(encrypted_key).decode(),
            'ciphertext': base64.b64encode(ciphertext).decode(),
            'nonce': base64.b64encode(nonce).decode()
        }

    def decrypt(self, encrypted_data: dict) -> str:
        """하이브리드 복호화"""
        # 1. RSA로 세션 키 복호화
        encrypted_key = base64.b64decode(encrypted_data['encrypted_key'])
        session_key = self.private_key.decrypt(
            encrypted_key,
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )

        # 2. AES로 데이터 복호화
        nonce = base64.b64decode(encrypted_data['nonce'])
        ciphertext = base64.b64decode(encrypted_data['ciphertext'])

        aesgcm = AESGCM(session_key)
        plaintext = aesgcm.decrypt(nonce, ciphertext, None)

        return plaintext.decode()


# 디지털 서명 예제
from cryptography.hazmat.primitives.asymmetric import padding as sign_padding

def sign_message(private_key, message: bytes) -> bytes:
    """RSA-PSS 디지털 서명"""
    signature = private_key.sign(
        message,
        sign_padding.PSS(
            mgf=sign_padding.MGF1(hashes.SHA256()),
            salt_length=sign_padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    return signature

def verify_signature(public_key, message: bytes, signature: bytes) -> bool:
    """서명 검증"""
    try:
        public_key.verify(
            signature, message,
            sign_padding.PSS(
                mgf=sign_padding.MGF1(hashes.SHA256()),
                salt_length=sign_padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        return True
    except Exception:
        return False

// Node.js 암호화 예제
const crypto = require('crypto');

// === AES-256-GCM 암호화 ===
class AESCrypto {
    constructor(password) {
        // 비밀번호에서 키 파생 (scrypt 사용)
        this.salt = crypto.randomBytes(16);
        this.key = crypto.scryptSync(password, this.salt, 32); // 256비트
    }

    encrypt(plaintext) {
        // 12바이트 IV (GCM 권장)
        const iv = crypto.randomBytes(12);

        const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv);
        let encrypted = cipher.update(plaintext, 'utf8', 'base64');
        encrypted += cipher.final('base64');

        // Auth Tag (GCM 무결성 검증용)
        const authTag = cipher.getAuthTag();

        return {
            ciphertext: encrypted,
            iv: iv.toString('base64'),
            authTag: authTag.toString('base64'),
            salt: this.salt.toString('base64')
        };
    }

    decrypt(encryptedData) {
        const decipher = crypto.createDecipheriv(
            'aes-256-gcm',
            this.key,
            Buffer.from(encryptedData.iv, 'base64')
        );

        decipher.setAuthTag(Buffer.from(encryptedData.authTag, 'base64'));

        let decrypted = decipher.update(encryptedData.ciphertext, 'base64', 'utf8');
        decrypted += decipher.final('utf8');

        return decrypted;
    }
}

// === RSA 키 쌍 생성 및 암호화 ===
function generateRSAKeyPair() {
    return crypto.generateKeyPairSync('rsa', {
        modulusLength: 4096,  // 4096비트 권장
        publicKeyEncoding: { type: 'spki', format: 'pem' },
        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
    });
}

function rsaEncrypt(publicKey, data) {
    return crypto.publicEncrypt(
        {
            key: publicKey,
            padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
            oaepHash: 'sha256'
        },
        Buffer.from(data)
    ).toString('base64');
}

// === 해시 및 HMAC ===
function hashSHA256(data) {
    return crypto.createHash('sha256').update(data).digest('hex');
}

function hmacSHA256(key, data) {
    return crypto.createHmac('sha256', key).update(data).digest('hex');
}

// === ECDH 키 교환 (Perfect Forward Secrecy) ===
function ecdhKeyExchange() {
    // Alice와 Bob의 ECDH 키 쌍 생성
    const alice = crypto.createECDH('prime256v1');  // P-256
    alice.generateKeys();

    const bob = crypto.createECDH('prime256v1');
    bob.generateKeys();

    // 공개키 교환 후 공유 비밀 계산
    const aliceSecret = alice.computeSecret(bob.getPublicKey());
    const bobSecret = bob.computeSecret(alice.getPublicKey());

    // 두 비밀이 동일함! (이것으로 세션 키 파생)
    console.log('Shared secret match:', aliceSecret.equals(bobSecret));

    return aliceSecret;
}

// 사용 예시
const aes = new AESCrypto('my-secure-password');
const encrypted = aes.encrypt('비밀 메시지');
console.log('Encrypted:', encrypted.ciphertext);
console.log('Decrypted:', aes.decrypt(encrypted));