암호화

# RSA 암호화 + 디지털 서명 (Python cryptography)
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization
import base64

class RSACrypto:
    """RSA 암호화 및 디지털 서명"""

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

    def encrypt(self, plaintext: str) -> str:
        """공개키로 암호화 (상대방이 보낸 공개키 사용)"""
        ciphertext = self.public_key.encrypt(
            plaintext.encode('utf-8'),
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        return base64.b64encode(ciphertext).decode('utf-8')

    def decrypt(self, ciphertext: str) -> str:
        """개인키로 복호화 (자신의 개인키 사용)"""
        plaintext = self.private_key.decrypt(
            base64.b64decode(ciphertext),
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        return plaintext.decode('utf-8')

    def sign(self, message: str) -> str:
        """개인키로 서명 (발신자 신원 증명)"""
        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 base64.b64encode(signature).decode('utf-8')

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

# 사용 예시: 안전한 메시지 전송
alice = RSACrypto()
bob = RSACrypto()

# Alice가 Bob에게 암호화된 메시지 전송
message = "계약금 1억원을 아래 계좌로 송금"

# Bob의 공개키로 암호화 (Bob만 복호화 가능)
encrypted = bob.encrypt(message)

# Alice의 개인키로 서명 (Alice가 보낸 것 증명)
signature = alice.sign(message)

# Bob이 수신 후
decrypted = bob.decrypt(encrypted)
is_valid = alice.verify(decrypted, signature)  # Alice 공개키로 검증

print(f"메시지: {decrypted}")
print(f"서명 검증: {'유효' if is_valid else '위조 의심'}")

# 패스워드 안전 저장 (bcrypt + Argon2)
import bcrypt
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
import secrets

class PasswordManager:
    """안전한 패스워드 관리 (Argon2id 권장)"""

    def __init__(self, use_argon2: bool = True):
        self.use_argon2 = use_argon2
        if use_argon2:
            # Argon2id: 메모리 하드 + GPU 저항
            self.hasher = PasswordHasher(
                time_cost=3,          # 반복 횟수
                memory_cost=65536,     # 64MB 메모리
                parallelism=4,         # 4 스레드
                hash_len=32,           # 해시 길이
                salt_len=16            # Salt 길이
            )

    def hash_password(self, password: str) -> str:
        """패스워드를 해시하여 저장용 문자열 반환"""
        if self.use_argon2:
            return self.hasher.hash(password)
        else:
            # bcrypt: 자동 salt 생성, cost factor 12 권장
            salt = bcrypt.gensalt(rounds=12)
            return bcrypt.hashpw(password.encode(), salt).decode()

    def verify_password(self, password: str, hash_str: str) -> bool:
        """입력된 패스워드가 저장된 해시와 일치하는지 확인"""
        try:
            if self.use_argon2:
                self.hasher.verify(hash_str, password)
                return True
            else:
                return bcrypt.checkpw(password.encode(), hash_str.encode())
        except (VerifyMismatchError, ValueError):
            return False

    def needs_rehash(self, hash_str: str) -> bool:
        """해시 파라미터 업그레이드 필요 여부 확인"""
        if self.use_argon2:
            return self.hasher.check_needs_rehash(hash_str)
        return False

# 사용 예시: 회원가입/로그인
pm = PasswordManager(use_argon2=True)

# 회원가입 시
user_password = "MySecure@Pass123!"
stored_hash = pm.hash_password(user_password)
print(f"DB 저장: {stored_hash}")

# 로그인 시
login_attempt = "MySecure@Pass123!"
if pm.verify_password(login_attempt, stored_hash):
    print("로그인 성공!")

    # 해시 파라미터 업그레이드 체크
    if pm.needs_rehash(stored_hash):
        new_hash = pm.hash_password(login_attempt)
        print("해시 업그레이드 완료")
else:
    print("로그인 실패")

# 패스워드 강도 검증 추가 권장
def check_password_strength(password: str) -> dict:
    return {
        "length": len(password) >= 12,
        "uppercase": any(c.isupper() for c in password),
        "lowercase": any(c.islower() for c in password),
        "digit": any(c.isdigit() for c in password),
        "special": any(c in "!@#$%^&*" for c in password)
    }