Devin.KR

인증·세션 - 비밀번호 저장부터 세션 만료까지

개발자KR 조회 3

이 장에서 배우는 것

커뮤니티 게시판에 가입과 로그인을 붙였다. 로그인에 성공하면 서버가 세션 토큰을 발급하고, 이후 요청에서는 그 토큰으로 로그인한 계정을 찾는다. 앞 장에서 입력을 검증해 요청 데이터의 범위를 정했다면, 이번 장에서는 그 요청을 보낸 사람의 신원을 어떻게 확인하고 확인 결과를 언제까지 사용할지 정한다. 게시판 예제에서는 만료 검사가 빠진 세션 코드를 찾아 고치고, 가입부터 만료 후 재로그인까지 한 번의 실행으로 점검한다.

  • hashlib.scrypt와 계정마다 생성한 솔트(salt)로 비밀번호 검증값을 만든다.
  • 실패 횟수를 계정별로 기록하고, 제한 중에는 비밀번호 검증을 건너뛴다.
  • secrets로 세션 토큰을 만들고, 서버에서 만료와 재발급을 처리한다.
  • 쿠키의 HttpOnly, Secure, SameSite가 각각 어떤 전송과 접근에 관여하는지 설명한다.
  • 같은 검사에 수정 전후 함수를 넣고, 만료 경계에서 결과가 어떻게 달라지는지 확인한다.

문제 상황

게시판 팀은 로그인 세션을 5분 동안 유지하기로 했다. AI가 작성한 초안은 발급할 때 만료 시각을 저장했고, 응답 쿠키에도 수명을 붙였다. 코드 검토에서 세션 조회 함수를 펼쳐 보니 토큰으로 저장소를 조회한 뒤 계정 이름을 바로 반환했다. 요청을 처리하는 함수 어디에도 현재 시각과 만료 시각을 비교하는 줄이 없었다.

정상 흐름만 실행하면 이 결함을 찾기 어렵다. 가입과 로그인에 성공하고, 발급 직후 게시판 요청을 보내면 계정 이름이 제대로 돌아온다. 브라우저가 쿠키 수명에 맞춰 전송을 중단하는 모습도 정상처럼 보인다. 서버가 보장해야 할 조건은 만료 시각에 도달한 토큰을 담은 요청을 거절한다는 것이다. 이 조건은 브라우저를 띄우지 않고도 조회 함수에 발급 토큰과 고정 시각을 넘겨 확인할 수 있다.

수정을 맡길 때는 사용할 라이브러리만 나열하기보다 확인할 경계를 요청문에 넣는다. 다음은 이 게시판 코드에 대한 요청문 예시다.

세션 조회 함수가 현재 시각과 저장된 만료 시각을 비교하도록 수정해 달라. 만료 1초 전에는 계정 이름을 반환하고, 만료 시각부터는 거절해야 한다. 다시 로그인하면 새 토큰을 발급하고 직전 토큰을 무효화해 달라. 고정 시각으로 동작하는 검사와 수정 diff를 함께 보여 달라.

제안을 받으면 먼저 수정 전 함수에 경계 검사를 실행한다. 검사가 실제로 문제를 드러낸 뒤에 수정본을 적용하고 같은 검사를 다시 실행한다. 그다음 diff에서 만료 비교가 토큰을 발급하는 쪽에만 추가되지는 않았는지, 계정 이름을 반환하기 전에 실행되는지 확인한다. 이 순서를 따르면 테스트가 통과했을 때 어떤 동작이 달라졌는지 설명할 수 있다.

비밀번호를 확인하는 값만 저장한다

가입할 때 서버는 새 솔트와 비밀번호를 hashlib.scrypt에 넣어 검증값을 계산한다. 계정 테이블에는 솔트와 검증값을 함께 저장한다. 로그인할 때는 그 계정의 솔트를 꺼내 입력된 비밀번호로 다시 계산하고, hmac.compare_digest로 두 바이트열을 비교한다. 비교가 일치하면 비밀번호 확인을 통과한 것이다. 저장된 솔트는 다음 로그인에서 같은 계산을 재현하는 데 쓰이므로 검증값 옆에 둘 수 있다.

같은 비밀번호를 택한 두 계정에도 서로 다른 솔트가 들어간다. 이 차이 때문에 한 계정에서 얻은 계산 결과를 다른 계정의 검증값과 그대로 대조할 수 없다. 솔트와 별개로 scrypt의 비용 설정은 한 번의 검증에 필요한 연산과 메모리를 늘린다. 저장소가 노출되면 솔트와 검증값을 이용한 비밀번호 추측은 여전히 가능하므로 두 역할이 모두 필요하다.

가입 때 저장한 솔트로 로그인 입력을 다시 계산해 저장된 검증값과 비교한다

예제는 솔트 16바이트와 검증값 32바이트를 사용한다. n, r, p는 계산 비용에 관여하고, maxmem은 라이브러리에 허용하는 메모리 상한이다. 예제는 한 종류의 설정으로 만든 레코드만 취급하므로 설정을 코드에 둔다. 여러 버전의 레코드가 공존하는 서비스에서는 레코드별로 설정이나 설정 버전을 저장해야 한다. 이전 설정으로 검증에 성공한 로그인에서 입력된 비밀번호를 이용해 현재 설정으로 다시 저장할 수 있다. 실제 비용 설정을 고를 때는 한 요청의 응답 시간과 동시 로그인 시 메모리 사용량을 함께 측정한다.

비밀번호 계산 전에 로그인 시도를 제한한다

게시판 예제는 한 계정에서 첫 실패가 기록된 시각부터 60초를 센다. 그 구간에 세 번 실패하면, 그 다음 시도부터는 제한이 끝날 때까지 비밀번호를 계산하지 않는다. 제한된 요청이 들어와도 종료 시각은 연장되지 않는다. 종료 시각과 현재 시각이 같아지면 새 시도가 가능하다. 제한에 걸리기 전에 로그인에 성공하면 해당 계정의 실패 기록을 지운다.

제한을 검증 전에 적용하면 제한 중인 요청이 비싼 계산을 계속 일으키지 않는다. 존재하지 않는 계정도 같은 실패 기록을 쓰고, 제한에 도달하기 전에는 더미 솔트로 같은 비용의 계산을 수행한다. 비밀번호가 틀렸을 때와 외부에 같은 거절 결과를 반환한다. 이 방식은 계정 존재에 따른 응답 차이를 줄이는 조치다. 저장소 조회나 요청 처리 전체의 시간까지 동일하다고 가정할 수는 없다.

계정별 제한은 여러 출발지에서 같은 계정으로 들어오는 요청에 공통으로 적용된다. 그만큼 다른 사람의 실패 때문에 계정 소유자도 잠시 기다릴 수 있고, 여러 계정 이름으로 흩어진 요청은 각각 별도로 집계된다. 이 예제의 정책은 단일 프로세스의 메모리에 기록한다. 여러 프로세스에서 동일한 한도를 적용하려면 공유 저장소에서 확인과 갱신을 원자적으로 처리해야 한다. 요청 출발지나 서비스 전체에 대한 한도를 함께 둔다면 계정별 제한과 각각 무엇을 제어하는지 구분해 검증한다.

세션의 유효 기간은 서버에서 결정한다

로그인에 성공하면 서버는 secrets.token_bytes로 뽑은 32바이트를 16진수 문자열로 바꿔 세션 토큰으로 반환한다. 서버 세션 테이블의 키는 토큰 자체를 해시한 값이다. 이후 요청에서는 전달받은 토큰을 같은 방식으로 해시해 조회한다. 사용자가 고른 비밀번호에는 반복 추측 비용을 높이는 scrypt를 쓰고, 난수로 생성한 세션 토큰의 조회 키에는 sha256을 쓴다. 로그인 응답의 토큰 문자열을 그대로 전달하는 요청은 로그인한 사람의 요청으로 처리되므로, 이 문자열은 실행 결과나 진단 로그에 출력하지 않는다.

발급 시각이 1000이고 수명이 300초라면 만료 시각은 1300이다. 서버는 1299까지 토큰을 받아들이고, 1300에 도달하면 세션 레코드를 지우고 요청을 거절한다. 게시판 요청을 보낼 때마다 300초를 다시 부여하는 동작은 없다. 새 수명이 필요하면 비밀번호를 다시 확인하는 로그인 절차를 거친다. 로그인에 성공할 때마다 그 계정의 직전 세션을 폐기하므로 이 예제에서는 계정당 세션 하나만 유지된다. 같은 계정으로 다른 기기에서 로그인하면 먼저 로그인한 기기는 새로 로그인해야 한다.

발급된 세션은 만료 시각부터 거절되며 다시 로그인해야 새 토큰을 받는다

응답의 Set-Cookie는 브라우저에 토큰을 보관하고 어떤 조건에서 전송할지 알려 준다. 서버는 별도로 보관한 만료 시각으로 요청을 판정한다. 쿠키의 Max-Age를 300초로 맞추면 브라우저도 그 수명에 맞춰 쿠키를 정리한다. 완성 코드는 헤더 값을 생성해 속성을 검사하고, 요청에 해당하는 호출에서는 토큰과 서버 시각을 조회 함수에 직접 넘긴다.

세션 쿠키 속성이 브라우저에 정하는 동작
속성예제 설정의미
HttpOnly켜짐페이지 스크립트가 일반적인 쿠키 읽기 인터페이스로 값을 가져갈 수 없게 한다. 브라우저는 조건에 맞는 요청에 쿠키를 계속 첨부한다.
Secure켜짐일반적인 배포에서 브라우저가 쿠키를 보안 연결인 HTTPS 요청에만 첨부하도록 한다.
SameSiteLax다른 사이트에서 시작된 대부분의 요청에 쿠키를 보내지 않는다. 일반 링크를 따라가는 최상위의 안전한 메서드 탐색은 허용한다.
Max-Age300초수신한 쿠키를 얼마 동안 유지할지 브라우저에 지정한다.

Lax는 다른 사이트의 링크를 통해 게시판에 들어올 때 로그인 상태를 유지하고 싶은 경우에 맞는다. 예를 들어 링크를 따라가는 최상위 GET 요청에는 쿠키가 첨부될 수 있으므로, 게시글 삭제처럼 상태를 바꾸는 동작을 GET에 배치하면 이 설정을 전제로 한 보호 범위를 벗어난다. 쿠키 속성은 각각의 브라우저 동작을 제한하고, 서버의 세션 판정은 토큰을 받은 뒤 적용된다.

완성 코드

다음 코드를 main.py로 저장한다. 계정은 SQLite 메모리 데이터베이스에 넣고, 로그인 실패 기록과 세션은 프로세스의 딕셔너리에 둔다. BoardAuth의 기본 난수 공급원은 secrets.token_bytes다. 실행 예제에서만 시드가 고정된 공급원을 주입하며, 모든 시각은 검사에서 정수로 직접 전달한다. 예제의 계정과 비밀번호는 이 실행에서만 쓰는 데이터다.

main.py

import hashlib
import hmac
import random
import secrets
import sqlite3
from contextlib import closing
from dataclasses import dataclass
from http.cookies import SimpleCookie


SESSION_SECONDS = 300
FAILURE_WINDOW = 60
MAX_FAILURES = 3


def password_digest(password, salt):
    return hashlib.scrypt(
        password.encode("utf-8"),
        salt=salt,
        n=2**15,
        r=8,
        p=3,
        maxmem=64 * 1024 * 1024,
        dklen=32,
    )


def token_key(token):
    return hashlib.sha256(token.encode("ascii")).digest()


def session_cookie(token):
    cookies = SimpleCookie()
    cookies["board_session"] = token
    cookie = cookies["board_session"]
    cookie["path"] = "/"
    cookie["httponly"] = True
    cookie["secure"] = True
    cookie["samesite"] = "Lax"
    cookie["max-age"] = str(SESSION_SECONDS)
    return cookie.OutputString()


@dataclass(frozen=True)
class Session:
    account: str
    expires_at: int


class BoardAuth:
    def __init__(self, db, random_bytes=secrets.token_bytes):
        self.db = db
        self.random_bytes = random_bytes
        self.dummy_salt = random_bytes(16)
        self.failures = {}
        self.sessions = {}
        self.active_keys = {}
        self.db.execute(
            "CREATE TABLE accounts ("
            "name TEXT PRIMARY KEY, salt BLOB NOT NULL, "
            "digest BLOB NOT NULL)"
        )

    def register(self, account, password):
        salt = self.random_bytes(16)
        digest = password_digest(password, salt)
        with self.db:
            self.db.execute(
                "INSERT INTO accounts VALUES (?, ?, ?)",
                (account, salt, digest),
            )

    def login(self, account, password, now):
        for name, (_, until) in list(self.failures.items()):
            if now >= until:
                del self.failures[name]

        count, until = self.failures.get(
            account, (0, now + FAILURE_WINDOW)
        )
        if count >= MAX_FAILURES:
            return "제한", None

        row = self.db.execute(
            "SELECT salt, digest FROM accounts WHERE name = ?",
            (account,),
        ).fetchone()
        salt, expected = row if row else (self.dummy_salt, bytes(32))
        actual = password_digest(password, salt)
        matches = hmac.compare_digest(actual, expected)
        if row is None or not matches:
            self.failures[account] = (count + 1, until)
            return "거절", None

        self.failures.pop(account, None)
        return "성공", self.issue_session(account, now)

    def issue_session(self, account, now):
        token = self.random_bytes(32).hex()
        key = token_key(token)
        previous = self.active_keys.get(account)
        if previous is not None:
            self.sessions.pop(previous, None)

        self.sessions[key] = Session(account, now + SESSION_SECONDS)
        self.active_keys[account] = key
        return token

    def lookup_before_fix(self, token, now):
        session = self.sessions.get(token_key(token))
        return session.account if session else None

    def lookup(self, token, now):
        key = token_key(token)
        session = self.sessions.get(key)
        if session is None:
            return None
        if now >= session.expires_at:
            del self.sessions[key]
            del self.active_keys[session.account]
            return None
        return session.account


def expires_on_time(lookup, token, account, deadline):
    return (
        lookup(token, deadline - 1) == account
        and lookup(token, deadline) is None
    )


def check_flow(board):
    password = "게시판 예제 비밀번호"
    board.register("mira", password)
    board.register("duri", password)
    first, second = board.db.execute(
        "SELECT salt, digest FROM accounts ORDER BY name"
    ).fetchall()
    assert first[0] != second[0]
    assert first[1] != second[1]
    print("가입: 같은 비밀번호의 솔트와 검증값이 다르다")

    for now in (940, 941, 942):
        assert board.login("mira", "다른 입력", now) == ("거절", None)
    assert board.login("mira", password, 999) == ("제한", None)
    assert board.login("없는 계정", password, 999) == ("거절", None)
    print("로그인 제한: 세 번 실패한 뒤 999초에 제한")

    status, token = board.login("mira", password, 1000)
    assert status == "성공" and token is not None
    print("로그인 제한 해제: 1000초에 성공")

    cookies = SimpleCookie()
    cookies.load(session_cookie(token))
    cookie = cookies["board_session"]
    assert cookie.value == token
    assert cookie["path"] == "/"
    assert cookie["httponly"] and cookie["secure"]
    assert cookie["samesite"] == "Lax"
    assert cookie["max-age"] == "300"
    print("쿠키: HttpOnly, Secure, SameSite=Lax, Max-Age=300")

    deadline = 1000 + SESSION_SECONDS
    before = expires_on_time(board.lookup_before_fix, token, "mira", deadline)
    after = expires_on_time(board.lookup, token, "mira", deadline)
    assert not before and after
    assert token_key(token) not in board.sessions
    print("만료 경계 검사: 수정 전 실패, 수정 후 통과")

    status, fresh = board.login("mira", password, 1301)
    assert status == "성공" and fresh is not None and fresh != token
    assert board.lookup(token, 1301) is None
    assert board.lookup(fresh, 1301) == "mira"
    print("만료 후 재로그인: 새 토큰 승인")

    status, rotated = board.login("mira", password, 1302)
    assert status == "성공" and rotated is not None and rotated != fresh
    assert board.lookup(fresh, 1302) is None
    assert board.lookup(rotated, 1302) == "mira"
    print("만료 전 재로그인: 직전 토큰 거절, 새 토큰 승인")


def main():
    fixture_random = random.Random(42)
    with closing(sqlite3.connect(":memory:")) as db:
        board = BoardAuth(db, random_bytes=fixture_random.randbytes)
        check_flow(board)


if __name__ == "__main__":
    main()

줄별 해설

password_digest의 encode는 Python 문자열을 UTF-8 바이트열로 바꾼다. 가입과 로그인에서 같은 인코딩을 사용하므로 같은 문자열과 솔트로 같은 검증값이 나온다. register의 첫 줄은 호출마다 솔트를 새로 뽑는다. 그 아래에서는 SQL의 ? 자리에 계정 이름과 바이트열을 인자로 전달하고, 계정 이름의 중복은 테이블의 기본 키 제약으로 처리한다. with self.db는 삽입을 트랜잭션으로 묶는다. 프로그램을 마칠 때 연결을 닫는 역할은 main의 closing이 맡는다.

login의 첫 반복문은 기간이 끝난 실패 기록을 삭제한다. list로 항목의 복사본을 만들었으므로 반복 중에 원래 딕셔너리에서 항목을 지울 수 있다. 처음 보는 이름에는 실패 횟수 0과 현재 시각에서 60초 뒤의 종료 시각을 적용한다. 실제 실패가 생겼을 때 그 종료 시각과 증가한 횟수를 저장한다. 이어지는 제한 분기는 계정 조회와 scrypt 호출보다 앞에 있다. 예제의 999초 요청이 올바른 비밀번호를 담고 있어도 제한이 적용되는 이유다.

fetchone은 행을 찾지 못하면 None을 반환한다. 이때는 더미 솔트와 길이가 같은 비교용 바이트열을 선택한다. 두 경우 모두 compare_digest를 호출하고, 행이 없으면 비교 결과와 관계없이 거절한다. 비교를 통과한 계정만 실패 기록을 지운 뒤 issue_session을 호출한다. 예제의 성공·거절·제한 문자열은 검사에서 내부 판정을 읽기 위한 값이다. 웹 요청에 연결할 때는 이 값을 응답으로 바꾸는 층에서 메시지와 상태 코드를 정한다.

issue_session의 active_keys 조회는 그 계정에 남아 있는 직전 세션을 찾는다. 새 토큰을 반환하기 전에 기존 조회 키를 지우고, 새 키와 만료 시각을 저장한다. lookup_before_fix에는 만료 값을 읽는 줄이 없다. lookup의 now >= session.expires_at 분기는 계정 이름을 반환하기 전에 실행된다. 이 분기에서 세션과 계정별 조회 키를 함께 지우므로, 만료를 만난 뒤에는 두 딕셔너리가 같은 상태를 나타낸다. 예제는 발급한 형식의 토큰을 내부 함수에 넘기며, now 역시 서버가 제공하는 시각을 모델링한다.

expires_on_time은 만료 1초 전 승인과 만료 시각 거절을 모두 확인한다. check_flow는 같은 토큰으로 수정 전 함수를 먼저 부른다. 그 함수는 세션을 지우지 않으므로 이어지는 수정 후 검사도 같은 발급 상태에서 시작한다. 수정 후 검사가 레코드를 삭제한 뒤에는 로그인으로 새 세션을 만들어 만료 후 복구와 만료 전 교체를 따로 확인한다. 각 출력은 해당 조건을 assert로 확인한 뒤 나온다. 실행 명령에는 -O를 붙이지 않아야 이 검사가 실행된다.

이 시뮬레이션에서는 한 번에 하나의 함수 호출이 끝난다. 동시 요청을 처리하는 서버로 옮길 때는 같은 계정의 세션 교체와 조회가 겹치는 경우도 검토해야 한다. 현재 코드는 조회된 만료 세션을 즉시 정리한다. 요청이 다시 오지 않은 세션까지 정리하려면 저장소의 만료 기능이나 만료 시각을 기준으로 하는 정리 작업을 사용한다.

실행 결과

첫 명령은 구문을 컴파일한다. 성공하면 출력이 없다. 다음 명령은 별도의 서버나 네트워크 없이 전체 흐름을 실행하고 종료한다.

python3 -W error -m py_compile main.py
python3 main.py
가입: 같은 비밀번호의 솔트와 검증값이 다르다
로그인 제한: 세 번 실패한 뒤 999초에 제한
로그인 제한 해제: 1000초에 성공
쿠키: HttpOnly, Secure, SameSite=Lax, Max-Age=300
만료 경계 검사: 수정 전 실패, 수정 후 통과
만료 후 재로그인: 새 토큰 승인
만료 전 재로그인: 직전 토큰 거절, 새 토큰 승인

다섯 번째 줄의 실패는 수정 전 함수가 만료 시각에도 계정을 반환했다는 검사 결과다. 수정 후 함수까지 해당 요청을 승인하면 assert not before and after에서 실행이 멈춘다. 반대로 만료 1초 전부터 요청을 거절해도 같은 검사에 걸린다. 출력에 난수나 실제 시각을 사용하지 않으므로 두 함수의 차이를 실행할 때마다 같은 문장으로 확인할 수 있다.

실무에서 자주 틀리는 것

아래의 짧은 코드는 main.py를 저장한 디렉터리에서 각각 실행할 수 있다. 수정 전후의 조건을 나란히 두고 assert로 차이를 확인한다.

계정마다 다른 솔트를 만들어야 한다

솔트 값을 상수로 두면 같은 비밀번호에서 같은 검증값이 나온다. 아래 검사는 서로 다른 두 솔트를 넣었을 때 검증값이 달라지는지 확인한다. 검사에서는 비교할 값을 고정하고, 실제 발급 경로인 register에서는 새 난수를 받는다.

from main import password_digest

password = "검사용 비밀번호"

# 수정 전
shared_salt = bytes(16)
assert password_digest(password, shared_salt) == password_digest(
    password, shared_salt
)

# 수정 후에 만족해야 하는 조건을 고정 입력으로 확인한다.
first_salt = bytes(16)
second_salt = bytes([1]) * 16
assert password_digest(password, first_salt) != password_digest(
    password, second_salt
)

제한에 걸린 요청은 해시 함수까지 도달하지 않아야 한다

제한 분기를 넣어도 함수 앞에서 검증값을 이미 계산했다면 요청 비용은 줄지 않는다. 아래에서는 실제 해시 계산을 호출 횟수 기록으로 바꿨다. 응답 결과가 둘 다 False여도 계산을 수행했는지가 다르다.

def before_fix(limited, verify):
    valid = verify()
    return not limited and valid


def after_fix(limited, verify):
    if limited:
        return False
    return verify()


calls = []


def verify():
    calls.append("검증")
    return True


assert before_fix(True, verify) is False
assert calls == ["검증"]
calls.clear()
assert after_fix(True, verify) is False
assert calls == []
assert after_fix(False, verify) is True
assert calls == ["검증"]

만료 시각의 등호를 확인한다

정수 초를 쓰는 코드에서 >만 검사하면 만료 시각과 정확히 같은 초에 토큰이 한 번 더 승인된다. 유효 구간을 발급 시각 이상, 만료 시각 미만으로 정의하면 유효성을 묻는 함수는 <를, 만료 여부를 묻는 분기는 >=를 사용한다.

def before_fix(now, expires_at):
    return now <= expires_at


def after_fix(now, expires_at):
    return now < expires_at


assert before_fix(1300, 1300)
assert after_fix(1299, 1300)
assert not after_fix(1300, 1300)
assert not after_fix(1301, 1300)

한눈에 보기

가입부터 재로그인까지 서버가 보장할 조건
단계서버 동작검사 기준
가입새 솔트로 scrypt 검증값을 만든다.같은 비밀번호를 입력한 두 계정에서 솔트와 검증값이 모두 다르다.
로그인계정별 제한을 확인한 뒤 저장된 솔트로 검증한다.제한 중에는 올바른 비밀번호도 보류하고, 종료 시각에는 다시 검증한다.
세션 발급난수 토큰을 반환하고 서버에 조회 키와 만료 시각을 저장한다.새 토큰으로 로그인 계정을 조회할 수 있고 쿠키에 지정한 속성이 들어간다.
세션 조회서버 시각을 저장된 만료 시각과 비교한다.만료 1초 전에는 승인하고 만료 시각부터 거절한다.
재로그인새 토큰을 발급하고 이전 세션을 폐기한다.이전 세션의 원래 수명이 남았어도 직전 토큰은 거절한다.

연습 문제

  1. 첫 실패가 940초일 때 941초, 942초에 다시 실패한다. 999초, 1000초에 올바른 비밀번호를 제출하면 각각 어떤 결과가 나오는지 쓰고, 제한된 요청이 종료 시각을 연장하는지도 설명한다.
  2. lookup의 만료 조건에서 >=를 >로 바꾼다. expires_on_time의 두 조회 결과를 차례대로 예측하고, 전체 실행에서 어느 검사가 변화를 발견하는지 설명한다.
  3. issue_session에서 직전 세션을 지우는 분기가 빠졌다고 가정한다. 1301초에 받은 토큰과 1302초에 받은 토큰을 1302초에 각각 조회하면 어떤 결과가 나오는지 쓰고, 1301초에 받은 토큰의 원래 만료 시각을 계산한다.
  4. 다른 사이트의 글에서 게시판으로 가는 링크를 눌렀다. SameSite=Lax 쿠키가 이 탐색 요청에 첨부될 수 있는지 설명하고, 쿠키가 첨부된 요청의 세션이 이미 만료되었다면 서버가 무엇을 반환해야 하는지 쓴다.

정답과 해설

  1. 999초에는 ("제한", None)을 반환한다. 1000초에는 첫 실패에 60초를 더한 종료 시각에 도달하므로 카운터가 지워지고, 올바른 비밀번호를 확인한 뒤 성공과 토큰을 반환한다. 제한 분기는 실패 기록을 쓰기 전에 반환하므로 999초 요청은 종료 시각을 연장하지 않는다.
  2. 1299초에는 기존처럼 계정 이름이 나온다. 1300초에는 1300 > 1300이 거짓이므로 여전히 계정 이름이 나온다. 따라서 수정 후 함수에 대한 expires_on_time도 거짓이 되고 assert not before and after에서 멈춘다.
  3. 두 토큰 모두 계정 이름을 반환한다. 1301초에 받은 토큰의 원래 만료 시각은 1601초다. 1302초는 그보다 이르므로 새 로그인 시 지우는 동작이 빠지면 유효한 상태로 남는다. 완성 코드의 마지막 검사에서 board.lookup(fresh, 1302) is None 조건이 거짓이 된다.
  4. 일반 링크를 따라가는 최상위 GET 요청에는 쿠키가 첨부될 수 있다. 서버는 쿠키를 받아도 토큰의 만료 시각을 확인한다. 만료에 도달했다면 이 예제에서는 None을 반환한다. 웹 서비스에서는 그 결과를 로그인 화면이나 인증이 필요하다는 응답에 연결할 수 있다.

현업에서 이렇게 본다

세션 수정안을 검토할 때는 정상 로그인 화면보다 요청이 세션을 읽는 줄을 먼저 찾는다. 발급 코드에서 5분을 저장하는 줄이 보여도, 처리 함수가 그 값을 읽는지 확인해야 만료를 검증할 수 있다. 여기에 만료 1초 전, 만료 시각, 재로그인 직후의 입력을 고정하면 AI가 만든 diff를 세 번의 구체적인 판단으로 읽을 수 있다. 한 번 더 로그인했을 때 다른 기기의 로그인도 끝나는지는 제품에서 정할 동작이므로, 선택한 정책을 검사 이름과 기대 결과에 드러낸다. 다음 장에서는 여기서 확인한 계정 이름을 바탕으로 그 계정이 요청한 게시글에 접근할 권한이 있는지 판단한다.

댓글 0

아직 댓글이 없습니다. 첫 댓글을 남겨 보세요.

댓글을 남기려면 로그인이 필요합니다.