TLS와 HTTPS: 인증서는 무엇을 증명하나
HTTPS의 S를 만드는 TLS가 지키는 세 가지, 엿볼 수 없게(암호화), 바꿀 수 없게(무결성), 속일 수 없게(인증) 하는 원리를 작은 숫자로 직접 확인해요. 처음 만난 두 사람이 공개된 길에서 비밀 열쇠를 나누는 디피 헬먼 키 교환, 한 비트만 바뀌어도 알아채는 변조 검사, 루트 CA에서 사이트까지 이어지는 인증서 사슬 검증을 시뮬레이션하고, HTTPS가 숨겨 주는 것과 못 숨기는 것, 인증서 오류를 읽는 법, 내 사이트에 HTTPS를 붙일 때 챙길 것까지 다뤄요.
앞 강의에서 본 TCP 조각은 지나가는 길의 누구든 열어 볼 수 있어요. 같은 카페 와이파이를 쓰는 사람, 공유기, 통신사의 장비 모두요. 암호화하지 않은 HTTP라면 비밀번호와 로그인 쿠키가 그대로 보이고, 중간에서 내용을 바꿔치기할 수도 있어요. 실제로 페이지에 광고를 끼워 넣거나 내려받는 파일을 바꾼 사례들이 있었어요.
TLS(Transport Layer Security)는 TCP 위에서 이 문제를 풀어요. HTTP를 TLS로 감싸면 HTTPS가 돼요. TLS는 세 가지를 지켜요.
| 약속 | 막는 것 | 쓰는 도구 |
|---|---|---|
| 기밀성 | 엿보기 | 대칭키 암호 |
| 무결성 | 중간에서 바꿔치기 | 메시지 인증 코드(MAC) |
| 인증 | 가짜 서버 | 인증서와 전자 서명 |
처음 만난 사이에서 비밀 열쇠를 나누는 법
암호화 자체는 빠르고 튼튼한 대칭키 암호(같은 열쇠로 잠그고 여는 방식, AES나 ChaCha20)가 맡아요. 문제는 열쇠예요. 처음 접속한 서버와 미리 열쇠를 나눠 가졌을 리 없고, 열쇠를 그냥 보내면 엿듣는 사람도 가져가요. 공개된 길에서 대화만으로 둘만 아는 열쇠를 만드는 방법이 디피 헬먼 키 교환이에요.
p, g = 23, 5 # 모두에게 공개된 약속 (실제로는 수백 자리 수)
a, b = 6, 15 # 각자 혼자만 아는 비밀 수
A = pow(g, a, p) # 앨리스가 보내는 값: g의 a제곱을 p로 나눈 나머지
B = pow(g, b, p) # 밥이 보내는 값
print("네트워크에 보이는 값:", {"p": p, "g": g, "A": A, "B": B})
print("앨리스가 계산한 비밀:", pow(B, a, p))
print("밥이 계산한 비밀:", pow(A, b, p))
print("엿듣는 사람이 a를 찾으려면:", [x for x in range(1, p) if pow(g, x, p) == A])
print("2048비트 수의 자릿수:", len(str(2 ** 2048)))
네트워크에 보이는 값: {'p': 23, 'g': 5, 'A': 8, 'B': 19}
앨리스가 계산한 비밀: 2
밥이 계산한 비밀: 2
엿듣는 사람이 a를 찾으려면: [6]
2048비트 수의 자릿수: 617
- 앨리스와 밥은 공개된 p, g에 각자 비밀 수(a, b)를 써서 A, B를 만들어 보내요.
- 받은 값에 다시 자기 비밀 수를 써서 계산하면 둘 다 같은 수 2가 나와요. 둘 다 결국 g의 (a × b)제곱을 계산한 셈이기 때문이에요.
- 엿듣는 사람은 p, g, A, B를 다 봤지만 a도 b도 몰라요. A에서 a를 거꾸로 구하는 빠른 방법이 없어서 하나씩 해 보는 수밖에 없는데, 이 예제는 수가 작아서 바로 찾았어요. 실제로는 617자리짜리 수(2048비트)를 쓰거나, 훨씬 짧은 수로 그 이상의 세기를 내는 타원 곡선(X25519)을 써서 현실적인 시간 안에는 찾을 수 없어요.
TLS 1.3은 연결할 때마다 새 비밀 수를 만들고 끝나면 버려요. 그래서 나중에 서버의 열쇠가 털려도, 누군가 미리 녹음해 둔 지난 대화는 풀 수 없어요. 이 성질을 전방 비밀성(forward secrecy)이라고 해요. 요즘 브라우저는 미래의 양자 컴퓨터에도 대비해서, 기존 방식에 새 방식(ML-KEM)을 섞은 키 교환을 쓰기 시작했어요.
잠그고, 바꿔치기를 알아채기
나눈 비밀로 메시지를 잠그고, 중간에서 바뀌지 않았는지 확인하는 과정을 장난감으로 만들어 볼게요.
import hashlib
import hmac
secret = b"2" # 키 교환으로 함께 얻은 비밀
enc_key = hashlib.sha256(b"encrypt" + secret).digest() # 비밀 하나에서 용도별 키를 따로 뽑아요
mac_key = hashlib.sha256(b"mac" + secret).digest()
def keystream(key, nonce, n): # 키와 번호로 만든 '난수처럼 보이는' 바이트
out, counter = b"", 0
while len(out) < n:
out += hashlib.sha256(key + nonce.to_bytes(8, "big") + counter.to_bytes(8, "big")).digest()
counter += 1
return out[:n]
def xor(data, ks):
return bytes(d ^ k for d, k in zip(data, ks))
msg = "비밀번호=correct-horse".encode()
nonce = 1 # 메시지마다 다른 번호를 써야 해요
box = xor(msg, keystream(enc_key, nonce, len(msg)))
tag = hmac.new(mac_key, box, hashlib.sha256).digest()
print("엿듣는 사람이 보는 것:", box.hex()[:32], "...")
print("받는 쪽이 푼 것:", xor(box, keystream(enc_key, nonce, len(box))).decode())
tampered = bytearray(box)
tampered[0] ^= 1 # 중간에서 딱 한 비트를 바꿨어요
check = hmac.new(mac_key, bytes(tampered), hashlib.sha256).digest()
print("한 비트 바꾼 뒤 검사:", "통과" if hmac.compare_digest(tag, check) else "변조 발견, 버려요")
엿듣는 사람이 보는 것: fc913e33093b5f34a7a0f5b795cdb531 ...
받는 쪽이 푼 것: 비밀번호=correct-horse
한 비트 바꾼 뒤 검사: 변조 발견, 버려요
- 비밀 하나에서 잠그는 열쇠와 검사용 열쇠를 따로 뽑았어요. 한 열쇠를 여러 용도로 돌려 쓰지 않는 게 암호의 기본 습관이에요.
- 잠그기는 열쇠와 메시지 번호(nonce)로 만든 바이트를 메시지에 XOR로 섞는 방식이에요. 같은 바이트를 한 번 더 섞으면 원래대로 돌아와요. 같은 열쇠로 같은 번호를 두 번 쓰면 안 되기 때문에 메시지마다 번호를 바꿔요.
- 잠근 결과에 검사용 열쇠로 꼬리표(MAC)를 붙였어요. 중간에서 딱 한 비트만 바꿔도 꼬리표가 맞지 않아서 받는 쪽이 버려요. 암호화만 하고 검사를 하지 않으면, 내용은 못 읽어도 특정 비트를 뒤집어 뜻을 바꾸는 공격이 가능해요.
이건 원리를 보여 주는 장난감이에요. 실제 TLS는 잠그기와 검사를 한 번에 하는 AES-GCM이나 ChaCha20-Poly1305를 써요. 암호는 직접 만들지 말고 검증된 라이브러리를 써요.
상대가 진짜인지: 인증서
키 교환에는 빈틈이 하나 있어요. 처음부터 가짜 서버와 키를 교환하면, 아무리 튼튼하게 잠가도 가짜 서버와 비밀 이야기를 나누는 꼴이에요. 그래서 서버는 인증서를 보여 줘요. 인증서에는 "이 공개 키의 주인은 www.example.com이다"라는 내용과, 믿을 만한 기관(CA, 인증 기관)의 전자 서명이 들어 있어요.
전자 서명은 개인 키로만 만들 수 있고, 짝이 되는 공개 키로 누구나 확인할 수 있어요. 브라우저와 운영체제에는 믿을 수 있는 루트 CA의 공개 키 목록이 미리 들어 있고, 루트는 보통 중간 CA를 거쳐 사이트의 인증서에 서명해요. 이 사슬을 직접 검증해 볼게요. 열쇠는 아주 작은 소수로 만든 장난감 RSA예요.
import hashlib
import json
from math import gcd
def make_key(p, q, e=65537): # 장난감 RSA 열쇠 한 쌍 (공개 키, 개인 키)
n, phi = p * q, (p - 1) * (q - 1)
assert gcd(e, phi) == 1
return {"n": n, "e": e}, {"n": n, "d": pow(e, -1, phi)}
def digest(body, n):
data = json.dumps(body, sort_keys=True, ensure_ascii=False).encode()
return int.from_bytes(hashlib.sha256(data).digest(), "big") % n
def sign(body, priv):
return pow(digest(body, priv["n"]), priv["d"], priv["n"])
def verify(body, sig, pub):
return pow(sig, pub["e"], pub["n"]) == digest(body, pub["n"])
def issue(subject, pub, issuer, issuer_priv, valid=("2026-01-01", "2026-12-31")):
body = {"subject": subject, "key": pub, "issuer": issuer, "from": valid[0], "to": valid[1]}
return {"body": body, "sig": sign(body, issuer_priv)}
root_pub, root_priv = make_key(1009, 1013)
mid_pub, mid_priv = make_key(2003, 2011)
site_pub, site_priv = make_key(3001, 3011)
TRUSTED = {"믿는 루트 CA": root_pub} # 운영체제와 브라우저에 미리 들어 있는 목록
mid_cert = issue("중간 CA", mid_pub, "믿는 루트 CA", root_priv)
site_cert = issue("*.example.com", site_pub, "중간 CA", mid_priv)
def name_matches(pattern, host):
if pattern.startswith("*."): # 별표는 맨 앞 한 칸만 대신해요
return host.count(".") == pattern.count(".") and host.endswith(pattern[1:])
return pattern == host
def check(chain, host, today):
if not name_matches(chain[0]["body"]["subject"], host):
return f"실패: 이름이 달라요 ({chain[0]['body']['subject']}, 접속한 곳 {host})"
for cert, upper in zip(chain, chain[1:] + [None]):
body = cert["body"]
if not body["from"] <= today <= body["to"]:
return f"실패: '{body['subject']}' 인증서의 유효 기간이 아니에요"
if upper is None: # 사슬의 끝은 믿는 루트가 서명했어야 해요
pub = TRUSTED.get(body["issuer"])
if pub is None:
return f"실패: '{body['issuer']}'은(는) 믿는 목록에 없어요"
elif upper["body"]["subject"] != body["issuer"]:
return "실패: 사슬이 이어지지 않아요"
else:
pub = upper["body"]["key"]
if not verify(body, cert["sig"], pub):
return f"실패: '{body['subject']}' 인증서의 서명이 맞지 않아요"
return "통과"
print("1.", check([site_cert, mid_cert], "www.example.com", "2026-11-16"))
print("2.", check([site_cert, mid_cert], "example.com", "2026-11-16"))
print("3.", check([site_cert, mid_cert], "www.example.com", "2027-02-01"))
fake_pub, fake_priv = make_key(4001, 4003)
fake_root_pub, fake_root_priv = make_key(5003, 5009)
fake = issue("www.example.com", fake_pub, "가짜 루트 CA", fake_root_priv)
print("4.", check([fake], "www.example.com", "2026-11-16"))
forged = {"body": dict(site_cert["body"], key=fake_pub), "sig": site_cert["sig"]}
print("5.", check([forged, mid_cert], "www.example.com", "2026-11-16"))
1. 통과
2. 실패: 이름이 달라요 (*.example.com, 접속한 곳 example.com)
3. 실패: '*.example.com' 인증서의 유효 기간이 아니에요
4. 실패: '가짜 루트 CA'은(는) 믿는 목록에 없어요
5. 실패: '*.example.com' 인증서의 서명이 맞지 않아요
다섯 경우가 각각 실제로 만나는 오류에 대응해요.
- 통과: 사이트 인증서는 중간 CA가, 중간 CA 인증서는 믿는 루트가 서명했고, 이름과 기간도 맞아요.
- 이름이 다름:
*.example.com의 별표는 맨 앞 한 칸만 대신해서example.com자체는 포함하지 않아요. 브라우저에서는NET::ERR_CERT_COMMON_NAME_INVALID같은 오류로 보여요. - 기간이 지남: 인증서마다 유효 기간이 있어요. 갱신을 잊으면
NET::ERR_CERT_DATE_INVALID가 떠요. 내 컴퓨터의 시계가 크게 틀려도 같은 오류가 나요. - 모르는 루트: 공격자는 마음대로 루트를 만들어 아무 이름의 인증서에나 서명할 수 있어요. 하지만 그 루트가 믿는 목록에 없으니 통과하지 못해요. 직접 만든 인증서(자체 서명)를 쓰는 개발 서버에서 보는
NET::ERR_CERT_AUTHORITY_INVALID가 이 경우예요. - 바꿔치기: 진짜 인증서에서 공개 키만 자기 것으로 바꾸면 서명이 맞지 않아요. 서명은 인증서 내용 전체에 대해 만든 것이기 때문이에요.
결국 인증의 무게는 믿는 목록에 실려 있어요. 이 목록에 루트를 하나 넣을 수 있으면 모든 HTTPS를 풀어 볼 수 있어요. 실제로 회사 보안 장비나 일부 광고 차단·백신 프로그램은 자기 루트 인증서를 컴퓨터에 설치해서 HTTPS를 중간에서 풀어 검사해요. 이런 환경에서는 운영체제 목록 대신 자기 목록을 쓰는 프로그램(파이썬의 requests 등)에서 인증서 오류가 나기도 해요.
실제 사이트의 인증서 보기
파이썬의 ssl 모듈로 실제 서버와 TLS 연결을 맺고 인증서를 볼 수 있어요. 인터넷에 연결되어 있어야 해요.
import socket
import ssl
host = "www.python.org"
ctx = ssl.create_default_context() # 믿는 목록과 이름 확인을 기본으로 켜요
with socket.create_connection((host, 443), timeout=10) as sock:
with ctx.wrap_socket(sock, server_hostname=host) as tls:
cert = tls.getpeercert()
print("버전:", tls.version())
print("주인:", dict(x[0] for x in cert["subject"]).get("commonName"))
print("발급:", dict(x[0] for x in cert["issuer"]).get("organizationName"))
print("만료:", cert["notAfter"])
실행하면 TLSv1.3이라는 버전과 인증서의 주인, 발급 기관, 만료 날짜가 나와요. 발급 기관과 날짜는 실행하는 시점에 따라 달라요. create_default_context()는 믿는 목록 확인과 이름 확인을 기본으로 켜 둬요. 오류가 귀찮다고 확인을 끄는 코드(requests의 verify=False, ssl.CERT_NONE)를 실제 서비스에 넣으면, 바로 위 예제에서 막아 낸 가짜 서버들이 모두 통과해요.
TLS 1.3의 악수 과정
- ClientHello: 브라우저가 쓸 수 있는 암호 방식, 키 교환용 공개 값(앞 예제의 A), 접속하려는 이름(SNI)을 보내요.
- ServerHello: 서버가 고른 방식과 자기 공개 값(B)을 보내요. 이 순간부터 둘은 같은 비밀을 갖게 되고, 이후의 내용은 모두 암호화돼요.
- 서버가 인증서와, 인증서의 개인 키로 지금 대화에 서명한 값을 보내요. 남의 인증서를 훔쳐 보여 주기만 해서는 통과할 수 없게 하는 장치예요.
- 양쪽이 지금까지 주고받은 내용 전체의 요약을 서로 확인하고(Finished), 곧바로 HTTP 요청을 보내요.
왕복 한 번이면 끝나요. 앞 강의에서 계산한 "TCP 악수 1번 + TLS 악수 1번 + 요청과 응답 1번"에서 TLS 몫이 이거예요. 예전 TLS 1.2는 왕복이 두 번 필요했어요.
HTTPS가 숨기는 것과 못 숨기는 것
| 보이지 않아요 | 여전히 보여요 |
|---|---|
주소의 경로와 쿼리(/search?q=...) | 접속한 서버의 IP 주소 |
| 헤더, 쿠키, 로그인 정보 | 도메인 이름(SNI, 암호화하지 않은 DNS 조회) |
| 주고받는 내용 전체 | 언제, 얼마나 오래, 얼마만큼 주고받았는지 |
그래서 HTTPS를 써도 같은 와이파이의 누군가는 "이 사람이 어느 사이트에 접속했는지"까지는 알 수 있어요. 이름까지 숨기려고 DNS를 암호화하는 방식(DoH, DoT)과, ClientHello 속 이름을 암호화하는 ECH가 쓰이기 시작했어요.
내 사이트에 HTTPS 붙이기
- 인증서는 무료로 자동 발급받아요. Let's Encrypt 같은 기관이 무료 인증서를 주고, Vercel, Netlify, GitHub Pages, Cloudflare 같은 호스팅은 도메인만 연결하면 알아서 발급하고 갱신해요.
- 자동 갱신이 필수예요. 인증서의 최대 유효 기간은 계속 짧아지고 있어요. 업계 합의에 따라 2026년 3월부터 200일, 2027년 3월부터 100일, 2029년 3월부터는 47일이에요. 손으로 갱신하는 방식은 언젠가 반드시 잊어요.
- HTTP는 HTTPS로 보내요.
http://로 들어오면 301로https://주소에 보내요. - HSTS를 켜요. 응답에
Strict-Transport-Security: max-age=31536000헤더를 붙이면, 브라우저는 그 기간 동안 이 사이트에 처음부터 HTTPS로만 접속해요. 첫 HTTP 요청을 가로채서 HTTPS로 넘어가지 못하게 하는 공격(SSL 스트리핑)을 막아 줘요. - 섞인 콘텐츠를 없애요. HTTPS 페이지 안에서 이미지나 스크립트를
http://로 불러오면 브라우저가 막거나 경고해요. 모든 자원을 HTTPS로 불러와요.
실습
- 디피 헬먼 예제의 p를 큰 소수 2147483647로 바꾸고, a를 찾는 줄의 범위를 1000만까지만 늘려서 걸리는 시간을 재 보세요. 범위를 끝까지 늘리면 얼마나 걸릴까요?
- 암호화 예제에서 nonce만 바꾸면 엿듣는 사람이 보는 값이 어떻게 달라지나요? 같은 nonce로 두 메시지를 잠근 뒤 두 결과를 XOR해 보고, 왜 위험한지 설명해 보세요.
- 인증서 예제에서
sub.www.example.com과WWW.EXAMPLE.COM으로 접속하면 어떻게 되나요? 실제 브라우저는 도메인의 대문자를 어떻게 다룰지 생각해 보고name_matches를 고쳐 보세요. - 브라우저 주소창 왼쪽의 사이트 정보 아이콘을 눌러 자주 가는 사이트의 인증서를 열어 보세요. 발급 기관, 유효 기간, 사슬은 어떻게 되어 있나요?
curl -vI https://example.com의 출력에서 TLS 버전과 인증서 정보가 나오는 줄을 찾아보세요.
자주 하는 오해
- "HTTPS 사이트는 믿을 수 있는 사이트다." HTTPS는 연결이 안전하다는 뜻일 뿐이에요. 피싱 사이트도 무료로 인증서를 받아요. 주소창의 도메인을 확인하는 습관이 여전히 필요해요.
- "HTTPS면 내가 어느 사이트에 가는지 아무도 모른다." 도메인과 IP는 보일 수 있어요.
- "암호화만 하면 된다." 변조 검사와 상대 확인이 없으면 암호화는 반쪽이에요.
- "인증서 오류는 무시해도 된다." 그 오류가 바로 가짜 서버를 막는 장치예요. 개발 중에도 확인을 끄기보다 올바른 인증서를 쓰는 편이 나아요.
점검 문제
- TLS가 지키는 세 가지와 각각 막는 공격은?
- 디피 헬먼에서 엿듣는 사람이 공개된 값을 다 보고도 비밀을 알 수 없는 이유는?
- 전방 비밀성이란?
- 암호화와 별도로 MAC(꼬리표)이 필요한 이유는?
- 인증서 검증에서 확인하는 네 가지는?
- 공격자가 자기 루트로 서명한 인증서가 통과하지 못하는 이유는?
- HTTPS를 써도 같은 네트워크의 사람이 알 수 있는 것은?
- HSTS가 막는 공격은?
정답
- 기밀성(엿보기), 무결성(중간에서 바꿔치기), 인증(가짜 서버)이에요.
- 공개된 A에서 비밀 수 a를 거꾸로 구하는 빠른 방법이 없어서, 아주 큰 수에서는 하나씩 시도하는 것이 사실상 불가능하기 때문이에요.
- 연결마다 새 비밀을 만들고 버려서, 나중에 서버의 개인 키가 털려도 지난 대화를 풀 수 없는 성질이에요.
- 암호화만으로는 중간에서 비트를 바꾸는 공격을 알아챌 수 없기 때문이에요. 꼬리표가 맞지 않으면 받는 쪽이 메시지를 버려요.
- 이름이 맞는지, 유효 기간 안인지, 사슬의 서명이 모두 맞는지, 사슬의 끝이 믿는 루트인지예요.
- 그 루트가 운영체제와 브라우저의 믿는 목록에 없기 때문이에요.
- 접속한 서버의 IP, 도메인 이름(SNI와 암호화하지 않은 DNS), 주고받은 시각과 양이에요.
- 첫 HTTP 요청을 가로채서 HTTPS로 넘어가지 못하게 하는 SSL 스트리핑이에요.
다음 강의
이제 인터넷이 층마다 어떻게 움직이는지 살펴봤어요. 네트워크 트랙의 마지막 강의에서는 이 지식을 써서 "인터넷이 안 돼요", "사이트가 안 열려요" 같은 문제를 층별로 좁혀 가는 방법을 익혀요. ping, traceroute, nslookup, curl의 결과를 읽고, 파이썬으로 단계별 진단 도구도 만들어요.