비밀번호, 해시, 2단계 인증

비밀번호를 서버에 어떻게 저장해야 털려도 안전한지, 그리고 비밀번호가 새도 계정을 지키는 2단계 인증이 어떻게 동작하는지 직접 만들어 봐요. 그냥 해시한 비밀번호가 흔한 비밀번호 목록 하나로 순식간에 풀리는 모습, 사람마다 다른 소금(솔트)과 일부러 느린 해시가 무엇을 바꾸는지 확인하고, 비밀번호 길이에 따라 다 시도해 보는 데 걸리는 시간을 계산해요. 표준 문서의 시험 값과 똑같이 나오는 TOTP 코드 생성기를 만들고, 피싱에 강한 패스키, 로그인 화면과 비밀번호 재설정에서 지킬 것까지 다뤄요.

초급강의 2 / 6약 14분

보안 사고 소식에는 "회원 정보가 유출됐다"는 말이 자주 나와요. 그때 비밀번호가 어떻게 저장되어 있었느냐에 따라, 사용자의 다른 계정까지 줄줄이 털리기도 하고 아무 일 없이 지나가기도 해요. 그리고 사람들은 같은 비밀번호를 여러 곳에 쓰기 때문에, 한 곳의 유출이 다른 곳의 사고가 돼요. 이번 강의에서는 비밀번호를 안전하게 저장하는 법과, 비밀번호가 새도 계정을 지켜 주는 2단계 인증을 직접 만들어 봐요.

원칙: 서버는 비밀번호를 몰라야 해요

비밀번호를 그대로(평문으로) 저장하면, 데이터베이스가 새는 순간 모든 사람의 비밀번호가 그대로 드러나요. 직원이나 백업 파일을 통해 새기도 해요. 그래서 서버는 비밀번호 자체가 아니라 해시만 저장해요. 해시는 같은 입력에 늘 같은 결과를 내지만, 결과에서 입력을 거꾸로 알아낼 수 없는 계산이에요. 로그인할 때는 입력한 비밀번호를 같은 방법으로 해시해서 저장된 값과 비교해요. 그런데 "그냥 해시"만으로는 부족해요.

import hashlib

common = ["123456", "password", "qwerty123", "iloveyou", "summer2026", "minji1234"]   # 흔한 비밀번호 목록
leaked = {                                            # 털린 서버에 있던 '그냥 해시'
    "minji": hashlib.sha256(b"summer2026").hexdigest(),
    "junho": hashlib.sha256(b"x9#Lq2!vRt7@pZ").hexdigest(),
    "seoyeon": hashlib.sha256(b"summer2026").hexdigest(),
}
print("민지와 서연의 해시가 같나요?", leaked["minji"] == leaked["seoyeon"])

table = {hashlib.sha256(p.encode()).hexdigest(): p for p in common}   # 미리 계산해 둔 표
for user, h in leaked.items():
    print(f"{user}: {table.get(h, '목록에 없음')}")
민지와 서연의 해시가 같나요? True
minji: summer2026
junho: 목록에 없음
seoyeon: summer2026

두 가지 문제가 보여요.

  • 같은 비밀번호는 같은 해시가 돼요. 민지와 서연의 해시가 같으니, 한 명의 비밀번호를 알아내면 다른 사람 것도 알게 돼요.
  • 흔한 비밀번호는 미리 계산해 둘 수 있어요. 공격자는 실제로 유출된 수억 개의 비밀번호로 해시 표를 만들어 두고, 털린 해시를 표에서 찾기만 해요. 흔한 비밀번호를 쓴 민지와 서연은 바로 풀렸어요. 길고 무작위인 준호의 비밀번호만 표에 없었어요.

소금과 느린 해시

두 문제를 막는 방법이 있어요.

  1. 소금(솔트): 사람마다 다른 무작위 값을 비밀번호에 섞어서 해시해요. 같은 비밀번호도 저장 값이 달라지고, 미리 계산한 표가 쓸모없어져요. 공격자는 사람마다 따로 추측해야 해요.
  2. 느린 해시: SHA-256 같은 일반 해시는 빠르게 계산하도록 만든 거예요. 전용 장비는 1초에 수십억 번 계산해요. 비밀번호용으로는 일부러 느리게 만든 해시(Argon2id, bcrypt, scrypt, PBKDF2)를 써서 추측 하나하나에 시간이 들게 해요.

파이썬 표준 라이브러리의 PBKDF2로 해 볼게요. 반복 횟수 60만 번은 보안 기관들이 PBKDF2-SHA256에 권하는 수준이에요.

import hmac
import os

def hash_password(password, salt=None, iterations=600_000):
    salt = salt or os.urandom(16)                     # 사람마다 다른 무작위 소금
    digest = hashlib.pbkdf2_hmac("sha256", password.encode(), salt, iterations)
    return f"pbkdf2_sha256${iterations}${salt.hex()}${digest.hex()}"

def verify_password(password, stored):
    _, iterations, salt_hex, digest_hex = stored.split("$")
    digest = hashlib.pbkdf2_hmac("sha256", password.encode(), bytes.fromhex(salt_hex), int(iterations))
    return hmac.compare_digest(digest.hex(), digest_hex)   # 걸리는 시간이 늘 같은 비교

a = hash_password("summer2026")
b = hash_password("summer2026")
print("같은 비밀번호, 다른 저장 값:", a != b)
print("저장 값의 모양:", a.split("$")[0], a.split("$")[1], "| 소금", len(a.split("$")[2]) // 2, "바이트")
print("맞는 비밀번호:", verify_password("summer2026", a), "| 틀린 비밀번호:", verify_password("summer2027", a))
같은 비밀번호, 다른 저장 값: True
저장 값의 모양: pbkdf2_sha256 600000 | 소금 16 바이트
맞는 비밀번호: True | 틀린 비밀번호: False
  • 같은 summer2026인데 저장 값이 달라요. 소금 덕분이에요.
  • 저장 값에 방식, 반복 횟수, 소금을 함께 적어 뒀어요. 소금은 비밀이 아니에요. 각 사람마다 달라서 미리 계산한 표를 막는 게 목적이에요. 나중에 반복 횟수를 늘리고 싶을 때, 사용자가 로그인하는 순간 새 방식으로 다시 저장할 수 있어요.
  • 비교에는 == 대신 hmac.compare_digest를 썼어요. ==는 앞에서부터 비교하다 다른 글자가 나오면 바로 멈춰서, 응답 시간의 차이로 몇 글자가 맞았는지 새어 나갈 수 있어요. 이 함수는 늘 같은 시간이 걸려요.

얼마나 느려졌는지 재 볼게요.

import time

def guesses_per_second(fn, n):
    start = time.perf_counter()
    for i in range(n):
        fn(f"guess{i}")
    return n / (time.perf_counter() - start)

salt = os.urandom(16)
fast = guesses_per_second(lambda p: hashlib.sha256(salt + p.encode()).digest(), 200_000)
slow = guesses_per_second(lambda p: hashlib.pbkdf2_hmac("sha256", p.encode(), salt, 600_000), 3)
print("느린 해시가 10만 배 넘게 느린가요?", fast / slow > 100_000)
느린 해시가 10만 배 넘게 느린가요? True

정상적인 사용자는 로그인할 때 한 번, 0.몇 초를 기다릴 뿐이에요. 하지만 수십억 개를 시도해야 하는 공격자에게는 그 10만 배가 그대로 걸림돌이 돼요. 실제로는 직접 만들지 말고, Argon2id나 bcrypt를 지원하는 검증된 라이브러리(파이썬이라면 argon2-cffi, bcrypt)나 프레임워크의 기능을 써요.

비밀번호의 강도: 길이가 이겨요

공격자가 모든 조합을 시도한다면 얼마나 걸릴까요? 가능한 조합의 수를 비트로 세면 비교하기 쉬워요. 1비트 늘 때마다 조합이 두 배가 돼요.

import math

def bits(choices, length):
    return length * math.log2(choices)

def human(seconds):
    year = 365 * 24 * 3600
    if seconds >= 1e8 * year:
        return f"{seconds / year / 1e8:,.0f}억 년"
    if seconds >= 1e4 * year:
        return f"{seconds / year / 1e4:,.0f}만 년"
    for unit, size in (("년", year), ("일", 86400), ("시간", 3600), ("분", 60)):
        if seconds >= size:
            return f"{seconds / size:,.0f}{unit}"
    return f"{seconds:.0f}초"

FAST, SLOW = 10_000_000_000, 10_000                  # 가정한 초당 추측: 빠른 해시를 전용 장비로 / 느린 해시
for label, b in [("소문자 8자", bits(26, 8)),
                 ("소문자+대문자+숫자 8자", bits(62, 8)),
                 ("소문자 14자", bits(26, 14)),
                 ("7,776개 낱말 중 무작위 5개", bits(7776, 5))]:
    print(f"{label}: {b:.0f}비트 | 빠른 해시 {human(2 ** b / FAST)}, 느린 해시 {human(2 ** b / SLOW)}")
소문자 8자: 38비트 | 빠른 해시 21초, 느린 해시 242일
소문자+대문자+숫자 8자: 48비트 | 빠른 해시 6시간, 느린 해시 692년
소문자 14자: 66비트 | 빠른 해시 205년, 느린 해시 2억 년
7,776개 낱말 중 무작위 5개: 65비트 | 빠른 해시 90년, 느린 해시 9,015만 년
  • 느린 해시는 같은 비밀번호를 수백만 배 오래 버티게 해요. 소문자 8자는 빠른 해시로 21초 만에 다 시도되지만, 느린 해시로는 242일이 걸려요.
  • 길이가 복잡함보다 세요. 대문자와 숫자를 섞은 8자(48비트)보다, 소문자만 쓴 14자(66비트)가 훨씬 강해요. 무작위로 고른 낱말 다섯 개도 소문자 14자와 비슷한 세기예요. 외우기는 훨씬 쉬운데요.
  • 이 계산은 무작위로 골랐을 때의 이야기예요. Summer2026!처럼 사람이 만든 비밀번호는 겉보기에 복잡해도 "낱말 + 연도 + 느낌표" 같은 흔한 틀을 따라서, 공격자의 목록에서 훨씬 일찍 나와요.

그래서 사용자에게는 이렇게 권하고, 서비스는 이렇게 만들어요.

  • 사용자: 비밀번호 관리자를 써서 사이트마다 길고 무작위인 비밀번호를 쓰게 해요. 사람이 기억할 것은 관리자의 비밀번호 하나뿐이에요.
  • 서비스: 최소 길이는 넉넉히(예: 12자 이상) 두고, 긴 비밀번호와 띄어쓰기를 막지 않아요. "특수 문자 필수", "90일마다 바꾸기" 같은 규칙은 오히려 뻔한 틀을 만들어서 요즘은 권하지 않아요. 대신 이미 유출된 비밀번호 목록에 있는지 확인해서 막아요.

2단계 인증: 비밀번호가 새도 지키는 문

비밀번호를 아무리 잘 저장해도, 사용자가 피싱 사이트에 비밀번호를 직접 입력하거나 다른 사이트에서 같은 비밀번호가 새면 소용없어요. 그래서 아는 것(비밀번호) 말고 가진 것(휴대폰, 보안 키)을 하나 더 확인해요. 인증 앱에 뜨는 6자리 숫자가 대표적이에요. 이 숫자는 TOTP라는 공개된 방식으로 만들어요. 서버와 앱이 처음에 비밀 값 하나를 나눠 가지고, 둘 다 지금 시각과 그 비밀로 같은 숫자를 계산해요. 직접 만들어서 표준 문서(RFC 6238)에 실린 시험 값과 비교해 볼게요.

import base64
import struct

def totp(secret, at, digits=6, step=30):
    counter = int(at) // step                         # 30초마다 바뀌는 번호
    mac = hmac.new(secret, struct.pack(">Q", counter), hashlib.sha1).digest()
    offset = mac[-1] & 0x0F                           # 마지막 바이트가 고르는 위치에서 4바이트를 꺼내요
    code = struct.unpack(">I", mac[offset:offset + 4])[0] & 0x7FFFFFFF
    return str(code % 10 ** digits).zfill(digits)

rfc_secret = b"12345678901234567890"                  # 표준 문서(RFC 6238)의 시험용 비밀
print("표준 문서의 시험 값과 비교:", totp(rfc_secret, 59, digits=8), totp(rfc_secret, 1111111109, digits=8))

secret = base64.b32decode("JBSWY3DPEHPK3PXP")         # 앱에 QR로 넘겨주는 비밀(예시)
now = 1_794_787_200                                 # 2026-11-16 00:00(세계 표준시)
print("지금 코드:", totp(secret, now), "| 30초 뒤:", totp(secret, now + 30))

def verify_code(secret, code, now, window=1):         # 시계가 조금 어긋나도 앞뒤 한 칸까지 받아 줘요
    return any(hmac.compare_digest(totp(secret, now + k * 30), code) for k in range(-window, window + 1))
print("30초 전 코드도 받나요?", verify_code(secret, totp(secret, now - 30), now),
      "| 2분 전 코드는?", verify_code(secret, totp(secret, now - 120), now))
표준 문서의 시험 값과 비교: 94287082 07081804
지금 코드: 930575 | 30초 뒤: 985420
30초 전 코드도 받나요? True | 2분 전 코드는? False
  • 표준 문서에 실린 값(59초에 94287082, 1111111109초에 07081804)과 똑같이 나왔어요. 인증 앱들도 이 계산을 해요.
  • 시각을 30초 단위로 나눈 번호와 비밀을 HMAC으로 섞어서, 30초마다 새 숫자가 나와요. 서버와 앱이 인터넷으로 통신할 필요가 없어서, 비행기 안에서도 코드가 뜨는 거예요.
  • 휴대폰 시계가 조금 어긋날 수 있으니 앞뒤 한 칸(30초)까지는 받아 줘요. 2분 전 코드는 거절해요. 실제로는 한 번 쓴 코드를 다시 못 쓰게 기록해 두고, 코드 입력도 횟수를 제한해요. 6자리는 100만 가지뿐이라 무한정 시도하게 두면 맞힐 수 있거든요.
  • 비밀 값은 처음 등록할 때 QR 코드로 한 번만 넘겨요. 서버는 이 비밀을 비밀번호 해시처럼 조심해서 보관해야 해요. 해시가 아니라 계산에 다시 써야 하는 값이라 암호화해서 저장해요.

문자 인증과 패스키

  • 문자 메시지 코드는 없는 것보다 훨씬 낫지만, 휴대폰 번호를 빼앗는 유심 탈취 같은 공격에 약해요. 가능하면 인증 앱이나 보안 키를 권해요.
  • TOTP도 피싱은 막지 못해요. 가짜 로그인 페이지가 사용자가 입력한 비밀번호와 6자리 코드를 받아 실시간으로 진짜 사이트에 넣으면 뚫려요.
  • 패스키(WebAuthn)는 이 약점까지 막아요. 기기 안의 열쇠로 서명하는데, 그 서명이 진짜 사이트의 도메인에 묶여 있어서 가짜 사이트에서는 아예 동작하지 않아요. 서버에는 공개 키만 저장되니 털려도 쓸모가 없어요. 비밀번호 없이 지문이나 얼굴로 로그인하는 방식이 점점 널리 쓰이고 있어요.

로그인과 관련 기능에서 지킬 것

  • 오류 메시지는 똑같이. "없는 아이디예요"와 "비밀번호가 틀렸어요"를 구별해 알려 주면, 공격자가 가입된 아이디를 골라낼 수 있어요. "아이디 또는 비밀번호가 맞지 않아요"로 같게 답해요.
  • 시도 횟수를 제한해요. 같은 계정이나 같은 주소에서 연속으로 실패하면 기다리게 하거나 추가 확인을 요구해요. 다른 사이트에서 털린 아이디와 비밀번호를 그대로 넣어 보는 공격(크리덴셜 스터핑)을 늦춰요. 계정을 영원히 잠그면 남이 일부러 잠가 버릴 수 있으니 조심해요.
  • 비밀번호 재설정 링크는 일회용으로. 짐작할 수 없는 무작위 값으로 만들고(파이썬의 secrets.token_urlsafe), 짧은 시간 뒤 만료되고, 한 번 쓰면 사라지게 해요. 서버에는 이 값도 해시로 저장해요.
  • 로그인 쿠키를 지켜요. HTTP 강의에서 본 HttpOnly, Secure, SameSite를 붙이고, 로그인하면 세션 번호를 새로 발급해요. 비밀번호를 바꾸면 다른 기기의 로그인도 끊어요.
  • 비밀번호 로그를 남기지 않아요. 요청 본문을 통째로 기록하다가 비밀번호가 로그에 남는 사고가 흔해요.

실습

  1. 흔한 비밀번호 목록에 내가 떠올릴 수 있는 뻔한 비밀번호 열 개를 더해 보세요. "그냥 해시" 표가 얼마나 빨리 커지나요?
  2. hash_password의 반복 횟수를 6만, 60만, 600만으로 바꿔 가며 한 번 계산하는 데 걸리는 시간을 재 보세요. 로그인이 너무 느려지지 않는 선은 어디일까요?
  3. 비밀번호 강도 표에 "숫자 4자리"(휴대폰 잠금 번호)와 "한글 낱말 3개(낱말 2,000개 중 무작위)"를 더해 보세요.
  4. TOTP 예제에서 step을 60으로 바꾸면 무엇이 달라지나요? 표준과 다르게 바꾸면 인증 앱과 어떤 문제가 생길까요?
  5. secrets.token_urlsafe(32)로 재설정 토큰을 만들고, 그 토큰의 SHA-256 해시만 저장한 뒤, 사용자가 가져온 토큰을 확인하는 함수를 만들어 보세요.

자주 하는 실수

  • 비밀번호를 평문으로 저장한다. 데이터베이스가 새는 순간 모두 드러나요.
  • SHA-256 같은 빠른 해시로만 저장한다. 소금이 없으면 미리 계산한 표에, 있어도 빠른 추측에 무너져요. 느린 해시를 써요.
  • 소금을 모두에게 같게 쓴다. 같은 비밀번호가 같은 값이 돼요. 사람마다 무작위로 만들어요.
  • 비밀번호 해시를 직접 만든다. 검증된 라이브러리의 Argon2id나 bcrypt를 써요.
  • 복잡함 규칙만 늘린다. 뻔한 틀만 늘어나요. 길이를 넉넉히, 유출된 비밀번호는 막아요.
  • 로그인 실패 이유를 자세히 알려 준다. 가입된 아이디가 드러나요.
  • 2단계 인증 코드를 무한정 시도하게 둔다. 6자리는 언젠가 맞혀져요. 횟수를 제한해요.

점검 문제

  1. 서버가 비밀번호 대신 해시를 저장하는 이유는?
  2. 소금 없이 해시만 저장하면 생기는 두 가지 문제는?
  3. 소금은 비밀이 아닌데도 효과가 있는 이유는?
  4. 비밀번호용으로 일부러 느린 해시를 쓰는 이유는?
  5. 비밀번호를 비교할 때 == 대신 hmac.compare_digest를 쓰는 이유는?
  6. 대문자와 숫자를 섞은 8자보다 소문자 14자가 강한 이유는?
  7. TOTP 코드는 서버와 앱이 통신하지 않는데도 어떻게 같은 숫자가 나오나요?
  8. 패스키가 TOTP보다 피싱에 강한 이유는?

정답

  1. 데이터베이스가 새도 비밀번호 자체는 드러나지 않게 하기 위해서예요. 해시에서 비밀번호를 거꾸로 계산할 수 없고, 로그인할 때는 입력값을 같은 방법으로 해시해 비교하면 돼요.
  2. 같은 비밀번호가 같은 해시가 되어 한 명이 풀리면 같은 비밀번호를 쓴 모두가 풀리고, 흔한 비밀번호의 해시를 미리 계산한 표로 바로 찾을 수 있어요.
  3. 사람마다 다른 소금이 섞이면 미리 계산한 표가 쓸모없어지고, 공격자가 사람마다 처음부터 따로 추측해야 하기 때문이에요.
  4. 정상 사용자는 로그인 때 한 번만 계산하면 되지만, 공격자는 수십억 번을 계산해야 해서 추측 하나하나가 느려지면 공격 전체가 그만큼 느려지기 때문이에요.
  5. ==는 다른 글자를 만나면 바로 멈춰서 비교 시간의 차이로 정보가 샐 수 있지만, compare_digest는 늘 같은 시간이 걸리기 때문이에요.
  6. 가능한 조합의 수가 길이에 따라 거듭제곱으로 늘어나서, 14자 소문자(66비트)가 8자 혼합(48비트)보다 조합이 훨씬 많기 때문이에요.
  7. 처음에 나눠 가진 비밀과 지금 시각을 30초 단위로 나눈 번호를 둘 다 같은 방식(HMAC)으로 계산하기 때문이에요.
  8. 패스키의 서명은 진짜 사이트의 도메인에 묶여 있어서 가짜 사이트에서는 동작하지 않지만, TOTP 코드는 사람이 가짜 사이트에 입력하면 공격자가 그대로 진짜 사이트에 넣을 수 있기 때문이에요.

다음 강의

비밀번호 말고도 서비스에는 지켜야 할 비밀이 많아요. API 키, 데이터베이스 비밀번호, 결제 연동 키 같은 것들이요. 다음 강의에서는 이런 비밀을 코드와 저장소에서 떼어 내 안전하게 보관하고, 새거나 오래된 비밀을 바꾸는 법을 배워요.