암호화 기초: 대칭키, 공개키, 서명

암호 기술의 세 가지 도구인 해시, 대칭키 암호, 공개키 암호를 실제로 쓰는 검증된 라이브러리로 다뤄요. 글자 하나에 절반이 바뀌는 해시, base64가 암호화가 아닌 이유, 한 비트만 바뀌어도 거절하는 AES-GCM과 함께 묶는 정보, 같은 번호를 두 번 쓰면 비밀이 그대로 드러나는 사고를 확인해요. Ed25519 서명으로 배포 파일이 진짜인지 확인하고, X25519로 처음 만난 두 사람이 열쇠를 나눠 메시지를 주고받고, random으로 만든 토큰이 시각만으로 맞혀지는 모습까지 보며 실제로 쓸 때의 규칙을 정리해요.

고급강의 5 / 6약 14분

TLS 강의에서 디피 헬먼 키 교환, 장난감 암호, 장난감 RSA 서명으로 원리를 봤어요. 이번에는 실제로 쓰는 도구로 같은 일을 해 보고, 쓸 때 지켜야 할 규칙을 정리해요. 예제는 파이썬에서 가장 널리 쓰는 암호 라이브러리 cryptography를 써요(pip install cryptography로 설치해요). 가장 중요한 규칙부터 말할게요. 암호는 직접 만들지 않아요. 수학이 맞아도 구현의 작은 실수 하나로 무너지거든요. 검증된 라이브러리의 검증된 방식을, 정해진 사용법대로 써요.

세 가지 도구

도구하는 일열쇠대표
해시데이터의 지문. 되돌릴 수 없어요없음SHA-256
대칭키 암호잠그고 풀기. 같은 열쇠로하나를 나눠 가져요AES-GCM, ChaCha20-Poly1305
공개키 암호키 교환, 전자 서명개인 키와 공개 키 한 쌍X25519(교환), Ed25519(서명), RSA

해시는 지문이고, base64는 아무것도 아니에요

import base64
import hashlib

a = hashlib.sha256("39000원을 민지에게".encode()).digest()
b = hashlib.sha256("39001원을 민지에게".encode()).digest()
diff = sum(bin(x ^ y).count("1") for x, y in zip(a, b))
print("글자 하나 차이, 해시에서 달라진 비트:", diff, "/ 256")

stored = base64.b64encode("correct-horse".encode()).decode()
print("base64로 '숨긴' 비밀번호:", stored, "→ 되돌리면:", base64.b64decode(stored).decode())
글자 하나 차이, 해시에서 달라진 비트: 124 / 256
base64로 '숨긴' 비밀번호: Y29ycmVjdC1ob3JzZQ== → 되돌리면: correct-horse
  • 해시는 입력이 조금만 달라도 결과의 절반쯤이 바뀌어요(눈사태 효과). 그래서 파일이 바뀌었는지 확인하는 지문으로 써요. 되돌릴 수 없으니 암호화가 아니에요. 비밀번호 저장에는 앞 강의의 느린 해시를 써요.
  • base64는 바이너리를 글자로 옮겨 적는 표기 방식일 뿐이에요. 열쇠도 없이 누구나 되돌려요. "인코딩해서 숨겼다"는 말은 숨기지 않았다는 뜻이에요. 설정 파일이나 쿠키에서 base64 문자열을 보면 일단 풀어 보세요. 생각보다 많은 정보가 그대로 들어 있어요.

대칭키 암호: AES-GCM

같은 열쇠로 잠그고 푸는 방식이에요. 빠르고 튼튼해서 실제 데이터를 잠그는 일은 거의 다 이 방식이 해요. 요즘은 잠그기와 변조 검사를 한 번에 하는 AEAD 방식(AES-GCM, ChaCha20-Poly1305)을 써요.

import os
from cryptography.exceptions import InvalidTag
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

key = AESGCM.generate_key(bit_length=256)              # 대칭키: 잠그는 쪽과 여는 쪽이 같은 열쇠
aes = AESGCM(key)
nonce = os.urandom(12)                                 # 메시지마다 새로 뽑는 번호
message = "카드 번호 끝자리 1234".encode()
context = b"user:42"                                    # 함께 묶어 두는 정보(암호화는 안 되지만 바뀌면 들켜요)

box = aes.encrypt(nonce, message, context)
print("원문", len(message), "바이트 → 암호문", len(box), "바이트(꼬리표 16바이트 포함)")
print("푼 결과:", aes.decrypt(nonce, box, context).decode())

tampered = bytearray(box)
tampered[0] ^= 1
for label, args in (("한 비트 바꾸면", (nonce, bytes(tampered), context)),
                    ("다른 사용자로 풀면", (nonce, box, b"user:43")),
                    ("다른 열쇠로 풀면", None)):
    try:
        if args is None:
            AESGCM(AESGCM.generate_key(bit_length=256)).decrypt(nonce, box, context)
        else:
            aes.decrypt(*args)
        print(label, "→ 풀렸어요(?!)")
    except InvalidTag:
        print(label, "→ InvalidTag: 거절")
원문 28 바이트 → 암호문 44 바이트(꼬리표 16바이트 포함)
푼 결과: 카드 번호 끝자리 1234
한 비트 바꾸면 → InvalidTag: 거절
다른 사용자로 풀면 → InvalidTag: 거절
다른 열쇠로 풀면 → InvalidTag: 거절
  • 암호문은 원문보다 16바이트 길어요. 그 16바이트가 꼬리표(인증 태그)예요. 한 비트만 바뀌어도 꼬리표가 맞지 않아 풀기를 거절해요. TLS 강의에서 따로 붙였던 MAC이 들어 있는 셈이에요.
  • 함께 묶는 정보(context)는 암호화되지 않지만, 바뀌면 들켜요. 사용자 42의 데이터로 잠근 암호문을 공격자가 사용자 43의 칸에 옮겨 붙여도 풀리지 않아요. 데이터베이스 칸을 잠글 때 행의 번호를 함께 묶어 두면 이런 바꿔치기를 막을 수 있어요.
  • nonce는 비밀이 아니라 암호문 옆에 함께 저장해요. 대신 같은 열쇠로는 절대 다시 쓰면 안 돼요. 왜인지 볼게요.

같은 번호를 두 번 쓰면

known = "오늘 회의는 3시예요".encode()                     # 공격자가 내용을 아는 메시지
secret = "금고 비밀번호는 0427".encode()                   # 공격자가 모르는 메시지
reused = os.urandom(12)
c1 = aes.encrypt(reused, known, None)                  # 같은 열쇠, 같은 번호로 두 번 잠그면
c2 = aes.encrypt(reused, secret, None)
recovered = bytes(x ^ y ^ z for x, y, z in zip(c1, c2, known))
print("번호를 다시 쓰면 공격자가 알아낸 것:", recovered.decode(errors="replace"))
번호를 다시 쓰면 공격자가 알아낸 것: 금고 비밀번호는 0427

열쇠를 모르는 공격자가 두 암호문과 한쪽의 원문만으로 다른 쪽의 비밀을 그대로 읽어 냈어요. AES-GCM은 열쇠와 번호로 만든 바이트를 원문에 섞는 방식이라(TLS 강의의 장난감과 같은 구조예요), 같은 번호로 잠근 두 암호문을 섞으면 두 원문을 섞은 것과 같아지거든요. 같은 번호의 재사용은 꼬리표를 위조하는 길까지 열어 줘요. 그래서 번호는 메시지마다 무작위로 새로 뽑아요(12바이트 무작위면 겹칠 걱정이 거의 없어요). 같은 열쇠로 수십억 개를 잠근다면 열쇠를 바꿔 주고요.

공개키 암호 1: 서명

공개키 암호는 열쇠가 한 쌍이에요. 개인 키는 나만 갖고, 공개 키는 누구에게나 나눠 줘요. 개인 키로 서명하면 누구나 공개 키로 "정말 그 사람이 만들었고, 바뀌지 않았다"를 확인할 수 있어요. 프로그램 배포 파일이 진짜인지 확인하는 데 많이 써요.

from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from cryptography.hazmat.primitives import serialization

private_key = Ed25519PrivateKey.generate()             # 개인 키: 나만 가져요
public_key = private_key.public_key()                  # 공개 키: 누구에게나 나눠 줘요
release = b"app-2.3.0.zip sha256=4f9a8b7c..."
signature = private_key.sign(release)
raw_public = public_key.public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw)
print("공개 키", len(raw_public), "바이트, 서명", len(signature), "바이트")

for label, data in (("그대로", release), ("내용을 바꾸면", release.replace(b"2.3.0", b"2.3.1"))):
    try:
        public_key.verify(signature, data)
        print(label, "→ 서명 확인: 내가 만든 그대로예요")
    except InvalidSignature:
        print(label, "→ InvalidSignature: 믿으면 안 돼요")
공개 키 32 바이트, 서명 64 바이트
그대로 → 서명 확인: 내가 만든 그대로예요
내용을 바꾸면 → InvalidSignature: 믿으면 안 돼요
  • Ed25519는 공개 키 32바이트, 서명 64바이트로 아주 작고 빨라요. 같은 세기의 RSA는 열쇠가 수백 바이트예요. SSH 강의에서 만든 ed25519 키가 바로 이거예요.
  • 서명은 파일 자체가 아니라 해시에 하는 경우가 많아요. 예제처럼 "파일 이름과 SHA-256 지문"에 서명하면, 받는 사람은 파일의 지문을 직접 계산해 비교하고 서명을 확인해요.
  • 서명과 HMAC(앞 강의의 웹훅 서명)의 차이는 열쇠예요. HMAC은 확인하는 쪽도 같은 비밀을 가져야 하니 서로 믿는 둘 사이에서 쓰고, 공개키 서명은 누구나 확인할 수 있지만 만들 수는 개인 키를 가진 사람만 해요.

공개키 암호 2: 키 교환

대칭키 암호는 빠르지만 "열쇠를 어떻게 나눠 갖지?"가 문제였어요. 공개키 방식의 키 교환이 이걸 풀어요. TLS 강의의 디피 헬먼을 실제로 쓰는 타원 곡선 버전(X25519)으로 해 볼게요.

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey
from cryptography.hazmat.primitives.kdf.hkdf import HKDF

alice, bob = X25519PrivateKey.generate(), X25519PrivateKey.generate()
shared_a = alice.exchange(bob.public_key())             # 각자 상대의 공개 키만 받아요
shared_b = bob.exchange(alice.public_key())
print("둘이 만든 비밀이 같나요?", shared_a == shared_b, "| 길이", len(shared_a), "바이트")

def derive(shared):                                    # 나눈 비밀에서 실제로 쓸 열쇠를 뽑아요
    return HKDF(algorithm=hashes.SHA256(), length=32, salt=None, info=b"chat v1").derive(shared)

n = os.urandom(12)
box = AESGCM(derive(shared_a)).encrypt(n, "안녕, 밥".encode(), None)
print("밥이 푼 메시지:", AESGCM(derive(shared_b)).decrypt(n, box, None).decode())
둘이 만든 비밀이 같나요? True | 길이 32 바이트
밥이 푼 메시지: 안녕, 밥

공개 키만 주고받았는데 둘이 같은 비밀을 갖게 됐어요. 그 비밀을 그대로 쓰지 않고 HKDF로 용도에 맞는 열쇠를 뽑아요(info에 용도를 적어, 같은 비밀에서도 용도마다 다른 열쇠가 나오게 해요). 그다음은 빠른 대칭키 암호가 맡아요. HTTPS, 메신저의 종단 간 암호화 모두 이렇게 공개키로 열쇠를 나누고, 대칭키로 잠가요.

다만 이 교환은 "상대가 진짜 밥인지"를 확인하지 않아요. 중간에서 공격자가 자기 공개 키를 끼워 넣으면 각자 공격자와 열쇠를 나누게 돼요. 그래서 TLS는 인증서의 서명으로 상대의 공개 키가 진짜인지 확인해요. 키 교환과 서명은 늘 함께 다녀요.

무작위 값은 secrets로

열쇠, 번호(nonce), 토큰, 소금은 모두 짐작할 수 없는 무작위 값이어야 해요. 파이썬의 random은 그런 용도가 아니에요.

import random
import secrets

def weak_token(seed):
    rng = random.Random(seed)
    return "".join(rng.choice("abcdefghijklmnopqrstuvwxyz0123456789") for _ in range(16))

issued_at = 1_794_787_200                              # 토큰을 만든 시각(초)을 씨앗으로 썼다면
victim = weak_token(issued_at)
guess = next(t for s in range(issued_at - 5, issued_at + 5) if (t := weak_token(s)) == victim)
print("random으로 만든 토큰을 시각만으로 맞혔나요?", guess == victim)
print("secrets 토큰 길이:", len(secrets.token_urlsafe(32)), "글자")
random으로 만든 토큰을 시각만으로 맞혔나요? True
secrets 토큰 길이: 43 글자

random은 씨앗이 같으면 늘 같은 값을 내요. 시뮬레이션이나 게임에는 그게 장점이지만, 토큰을 만든 시각을 씨앗으로 썼다면 공격자는 그 언저리의 시각을 몇 개 시도해서 토큰을 그대로 만들어 내요. 비밀번호 재설정 링크가 이렇게 만들어져 있다면 남의 계정을 가져갈 수 있어요. 보안에 쓰는 값은 운영체제의 안전한 난수에서 나오는 secrets(또는 os.urandom)로 만들어요.

실제로 쓸 때의 규칙

  • 직접 만들지 않아요. 암호 방식도, 그 조합도요. cryptography의 Fernet처럼 "잠그기에 필요한 것을 다 정해 둔" 고수준 도구가 있으면 그걸 먼저 써요.
  • AEAD를 써요. AES-GCM이나 ChaCha20-Poly1305처럼 변조 검사가 함께 있는 방식이요. 옛날 방식(ECB, 검사 없는 CBC)은 쓰지 않아요.
  • 번호는 메시지마다 새로, 무작위는 secrets로.
  • 열쇠 관리가 가장 어려운 부분이에요. 튼튼한 금고도 열쇠를 문 옆에 걸어 두면 소용없어요. 암호화된 데이터와 열쇠를 같은 곳에 두지 않고, 앞 강의의 비밀 관리 방법으로 열쇠를 지켜요.
  • 무엇을 지키는지 구별해요. 전송 중의 암호화(TLS)는 오가는 길을, 저장 데이터의 암호화는 디스크와 백업이 털렸을 때를 지켜요. 둘은 서로를 대신하지 못해요.
  • 세월에 대비해요. 지금의 공개키 방식은 언젠가 충분히 큰 양자 컴퓨터에 깨질 수 있어서, 양자 컴퓨터에도 버티는 방식으로 옮겨 가는 중이에요. TLS 강의에서 본 ML-KEM이 그 예예요. 방식을 바꾸기 쉽게 만들어 두는 것도 좋은 설계예요.

실습

  1. 해시 예제에서 금액을 한 글자씩 바꿔 가며 달라진 비트 수를 열 번 재 보세요. 평균이 얼마쯤 나오나요?
  2. AES-GCM 예제에서 context를 None으로 잠근 뒤 b"user:42"로 풀어 보세요. 어떻게 되나요? 언제 함께 묶는 정보가 필요할까요?
  3. cryptography.fernet.Fernet으로 메시지를 잠그고 풀어 보세요. 토큰을 base64로 풀어 보면 어떤 부분으로 이뤄져 있나요?
  4. 서명 예제에서 공개 키를 파일로 저장했다가 다시 읽어서 확인하는 코드를 써 보세요(serialization을 써요).
  5. 키 교환 예제에 "공격자 이브"를 끼워 넣어, 앨리스와 밥이 각자 이브와 열쇠를 나누게 되는 상황을 만들어 보세요. 무엇이 있어야 이걸 막을 수 있을까요?

자주 하는 실수

  • 해시를 암호화라고 부른다. 되돌릴 수 없는 지문일 뿐이에요.
  • base64로 숨겼다고 생각한다. 누구나 되돌려요.
  • 변조 검사 없는 암호를 쓴다. 읽지는 못해도 바꿔치기는 할 수 있어요. AEAD를 써요.
  • 같은 열쇠로 번호를 다시 쓴다. 비밀이 그대로 드러나요.
  • random으로 토큰이나 열쇠를 만든다. 짐작할 수 있어요. secrets를 써요.
  • 키 교환만 하고 상대를 확인하지 않는다. 중간에서 끼어들 수 있어요. 서명이나 인증서로 확인해요.
  • 열쇠를 암호화된 데이터 옆에 둔다. 같이 털려요.
  • 직접 암호 방식을 만든다. 검증된 라이브러리의 검증된 방식을 써요.

점검 문제

  1. 해시, 대칭키 암호, 공개키 암호는 각각 무엇에 쓰나요?
  2. base64가 암호화가 아닌 이유는?
  3. AES-GCM의 암호문이 원문보다 16바이트 긴 이유와, 그 16바이트가 하는 일은?
  4. 함께 묶는 정보(context)를 쓰면 어떤 공격을 막을 수 있나요?
  5. 같은 열쇠로 같은 번호를 두 번 쓰면 왜 위험한가요?
  6. 전자 서명과 HMAC의 차이는?
  7. X25519 키 교환만으로는 부족하고 서명이 함께 필요한 이유는?
  8. 토큰을 random이 아니라 secrets로 만들어야 하는 이유는?

정답

  1. 해시는 데이터가 바뀌었는지 확인하는 지문, 대칭키 암호는 같은 열쇠로 데이터를 잠그고 풀기, 공개키 암호는 열쇠를 나누는 키 교환과 누구나 확인할 수 있는 전자 서명에 써요.
  2. 열쇠 없이 정해진 규칙으로 바이너리를 글자로 옮겨 적는 표기 방식이라, 누구나 되돌릴 수 있기 때문이에요.
  3. 16바이트의 꼬리표(인증 태그)가 붙기 때문이에요. 암호문이 한 비트라도 바뀌거나 열쇠나 함께 묶은 정보가 다르면 꼬리표가 맞지 않아 풀기를 거절해요.
  4. 한 사용자의 암호문을 다른 사용자의 자리에 옮겨 붙이는 바꿔치기를 막을 수 있어요. 함께 묶은 정보가 다르면 풀리지 않아요.
  5. 같은 열쇠와 번호로 만든 바이트가 두 원문에 똑같이 섞여서, 두 암호문을 섞으면 두 원문을 섞은 것과 같아지기 때문이에요. 한쪽 원문을 알면 다른 쪽이 그대로 드러나요.
  6. 전자 서명은 개인 키로 만들고 공개 키로 누구나 확인할 수 있어요. HMAC은 만드는 쪽과 확인하는 쪽이 같은 비밀을 나눠 가져야 해요.
  7. 키 교환은 상대가 진짜인지 확인하지 않아서, 중간에서 공격자가 자기 공개 키를 끼워 넣으면 각자 공격자와 열쇠를 나누게 되기 때문이에요. 서명이나 인증서로 상대의 공개 키가 진짜인지 확인해야 해요.
  8. random은 씨앗이 같으면 같은 값을 내서, 씨앗(예: 만든 시각)을 짐작하면 토큰을 그대로 만들어 낼 수 있기 때문이에요. secrets는 운영체제의 안전한 난수를 써서 짐작할 수 없어요.

다음 강의

보안 트랙의 마지막 강의에서는 지금까지 배운 것을 서버에 적용해요. 서버를 처음 받았을 때부터 운영하는 동안까지, 접속, 계정, 방화벽, 업데이트, 기록, 백업을 하나씩 확인하는 점검표를 만들어요.