Encryption

# RSA 비대칭키 암호화 - 공개키/개인키 쌍 사용
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes, serialization

class AsymmetricEncryption:
    """비대칭키 암호화: 공개키로 암호화, 개인키로 복호화"""

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

    def encrypt(self, plaintext: str) -> bytes:
        """공개키로 암호화 (누구나 암호화 가능)"""
        ciphertext = self.public_key.encrypt(
            plaintext.encode('utf-8'),
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        return ciphertext

    def decrypt(self, ciphertext: bytes) -> str:
        """개인키로 복호화 (키 소유자만 복호화 가능)"""
        plaintext = self.private_key.decrypt(
            ciphertext,
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        return plaintext.decode('utf-8')

    def export_public_key(self) -> str:
        """공개키를 PEM 형식으로 내보내기 (공유 가능)"""
        pem = self.public_key.public_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PublicFormat.SubjectPublicKeyInfo
        )
        return pem.decode('utf-8')

    def sign(self, message: str) -> bytes:
        """개인키로 서명 (발신자 증명)"""
        signature = self.private_key.sign(
            message.encode('utf-8'),
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        return signature

    def verify(self, message: str, signature: bytes) -> bool:
        """공개키로 서명 검증"""
        try:
            self.public_key.verify(
                signature,
                message.encode('utf-8'),
                padding.PSS(
                    mgf=padding.MGF1(hashes.SHA256()),
                    salt_length=padding.PSS.MAX_LENGTH
                ),
                hashes.SHA256()
            )
            return True
        except Exception:
            return False

# 사용 예시: 안전한 메시지 전송
sender = AsymmetricEncryption()
receiver = AsymmetricEncryption()

# 1. 발신자가 수신자의 공개키로 암호화
message = "기밀 정보입니다"
encrypted = receiver.public_key.encrypt(
    message.encode(),
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"암호화 완료: {len(encrypted)} bytes")

# 2. 수신자가 자신의 개인키로 복호화
decrypted = receiver.decrypt(encrypted)
print(f"복호화: {decrypted}")

# 해시 함수 & 비밀번호 해싱
import hashlib
import bcrypt
import secrets

# === 1. SHA-256 해시 (데이터 무결성 검증) ===
def sha256_hash(data: str) -> str:
    """SHA-256 해시 생성 - 파일 무결성, 데이터 검증용"""
    return hashlib.sha256(data.encode()).hexdigest()

# 같은 입력 = 같은 해시
print(sha256_hash("hello"))  # 2cf24dba5fb0a30e26e83b2ac5b9e29e...
print(sha256_hash("hello"))  # 동일한 해시

# 작은 변화 = 완전히 다른 해시 (눈사태 효과)
print(sha256_hash("hello!"))  # 전혀 다른 값


# === 2. 비밀번호 해싱 (bcrypt 권장) ===
def hash_password(password: str) -> bytes:
    """
    비밀번호 해싱 - bcrypt 사용
    - 솔트 자동 생성
    - 계산 비용 조절 가능 (brute-force 방어)
    """
    salt = bcrypt.gensalt(rounds=12)  # 2^12 반복
    return bcrypt.hashpw(password.encode(), salt)

def verify_password(password: str, hashed: bytes) -> bool:
    """비밀번호 검증"""
    return bcrypt.checkpw(password.encode(), hashed)

# 비밀번호 저장 시
password = "MySecretP@ss123"
hashed = hash_password(password)
print(f"저장할 해시: {hashed.decode()}")

# 로그인 시 검증
is_valid = verify_password("MySecretP@ss123", hashed)
print(f"비밀번호 일치: {is_valid}")  # True

is_valid = verify_password("wrong_password", hashed)
print(f"비밀번호 일치: {is_valid}")  # False


# === 3. 토큰 생성 (secrets 모듈) ===
# API 키, 세션 토큰 등 암호학적으로 안전한 랜덤 값
api_key = secrets.token_urlsafe(32)  # URL-safe 32바이트
session_token = secrets.token_hex(16)  # 16바이트 hex
print(f"API Key: {api_key}")
print(f"Session: {session_token}")