암호화의 기초

HTTP (평문)
  Client ──"password=1234"──→ Server
                 ↑
          공격자: "password=1234 잘 보인다!"

HTTPS (암호화)
  Client ──"x8f2k...a9z3"──→ Server
                 ↑
          공격자: "????" (읽을 수 없음)

Alice가 Bob에게 비밀 메시지를 보내려면:
  1. Alice와 Bob이 같은 키를 공유해야 함
  2. 키를 전달하려면... 안전한 채널이 필요
  3. 안전한 채널이 있었으면 암호화가 필요 없었음!

  Alice ──────?──────→ Bob
       "키를 어떻게 보내지?"
       (이 채널이 안전하지 않으니까 암호화가 필요한 건데...)

  닭이 먼저냐 달걀이 먼저냐!
  → 이 문제를 해결하는 것이 비대칭키 암호화

키 쌍 생성
  Bob이 공개키 + 개인키 쌍을 생성
  공개키: 모두에게 공개 (전화번호부처럼)
  개인키: Bob만 보관 (절대 유출 금지!)

암호화 (공개키로)
  Alice가 Bob의 공개키로 암호화
  "Hello" + Bob의 공개키 → "x8f2k"

복호화 (개인키로)
  Bob만 자신의 개인키로 복호화 가능
  "x8f2k" + Bob의 개인키 → "Hello"

핵심
  공개키로 암호화 → 개인키로만 복호화
  개인키로 암호화 → 공개키로만 복호화 (디지털 서명에 활용)

비대칭키: 느리지만 키 교환 문제 해결
대칭키:   빠르지만 키 교환 문제 있음

TLS의 해결책: 둘을 조합!

1. 비대칭키로 대칭키를 안전하게 교환
   Alice ── Bob의 공개키로 대칭키 암호화 ──→ Bob
   Bob: 개인키로 복호화 → 대칭키 획득

2. 이후 데이터는 대칭키(AES)로 암호화
   Alice ← AES(대칭키) → Bob
   속도 빠름!

결론
  비대칭키 = "키 배달부" (느리지만 안전한 키 전달)
  대칭키 = "실제 암호화" (빠른 데이터 암호화)

1. 단방향성
   "Hello" → a591a6d4... (가능)
   a591a6d4... → "Hello" (불가능!)

2. 고정 길이
   "Hi"            → 32바이트 해시
   "War and Peace" → 32바이트 해시 (같은 길이!)

3. 결정성
   "Hello" → 항상 a591a6d4...
   "Hello" → 항상 a591a6d4... (매번 동일)

4. 눈사태 효과
   "Hello"  → a591a6d40289...
   "Hello!" → 7b0a22198c...  (한 글자 차이, 완전히 다른 해시!)

import hashlib
import hmac
import secrets

# 해시 함수 데모
def hash_demo():
    """SHA-256 해시 계산"""
    message = "Hello, TLS!"
    hash_value = hashlib.sha256(message.encode()).hexdigest()
    print(f"메시지: {message}")
    print(f"SHA-256: {hash_value}")
    print(f"길이: {len(hash_value)} hex chars = {len(hash_value)*4} bits")
    
    # 눈사태 효과
    message2 = "Hello, TLS?"  # 느낌표 → 물음표
    hash_value2 = hashlib.sha256(message2.encode()).hexdigest()
    print(f"\n메시지: {message2}")
    print(f"SHA-256: {hash_value2}")
    print(f"1글자 차이인데 해시가 완전히 다름!")

# HMAC: 해시 + 비밀 키 = 메시지 인증 코드
def hmac_demo():
    """HMAC으로 메시지 무결성 + 인증 검증"""
    key = secrets.token_bytes(32)
    message = b"transfer: $1000 to account 1234"
    
    mac = hmac.new(key, message, hashlib.sha256).hexdigest()
    print(f"\nHMAC: {mac}")
    
    # 검증: 같은 키와 메시지면 같은 MAC
    mac_verify = hmac.new(key, message, hashlib.sha256).hexdigest()
    print(f"검증: {hmac.compare_digest(mac, mac_verify)}")  # True
    
    # 변조된 메시지
    tampered = b"transfer: $9999 to account 5678"
    mac_tampered = hmac.new(key, tampered, hashlib.sha256).hexdigest()
    print(f"변조 검증: {hmac.compare_digest(mac, mac_tampered)}")  # False

hash_demo()
hmac_demo()

서명 (송신자: Alice)
  1. 문서의 해시값 계산: SHA-256("계약서 내용") → abc123...
  2. 해시값을 Alice의 개인키로 암호화 → 서명값
  3. [문서 + 서명값] 전송

  ┌───────────┐    개인키     ┌──────────┐
  │ 문서 해시 │──────────────→│  서명값  │
  │ abc123... │  암호화       │ x9y8z7.. │
  └───────────┘               └──────────┘

검증 (수신자: Bob)
  1. 서명값을 Alice의 공개키로 복호화 → 해시값 A
  2. 받은 문서의 해시값을 직접 계산   → 해시값 B
  3. A == B이면 → ✓ 문서 변조 없음 + Alice가 서명함

  ┌──────────┐    공개키      ┌───────────┐
  │  서명값  │───────────────→│ 해시값 A  │
  │ x9y8z7.. │  복호화        │ abc123... │
  └──────────┘                └───────────┘
                                  ↕ 비교
  ┌───────────┐   SHA-256     ┌───────────┐
  │ 받은 문서 │──────────────→│ 해시값 B  │
  └───────────┘               │ abc123... │
                              └───────────┘
  A == B → ✓ 유효한 서명!