Нажали «Выйти», а токен всё ещё работает: сессии против JWT, refresh и отзыв токенов
Если подпись JWT валидна, сервер его примет, даже после «выйти на всех устройствах». Разбираем сессии и JWT изнутри, ротацию refresh-токенов, denylist, версию токена и где хранить токен, на примерах Django.
Пользователь потерял телефон. Он заходит с компьютера, нажимает «Выйти на всех устройствах» и успокаивается. Но бэкенд работает на JWT, а access-токен живёт 24 часа. Тот, у кого теперь телефон, до завтрашнего вечера спокойно ходит в API: подпись валидна, exp не наступил, и у сервера нет ни одной причины отказать.
Это не баг JWT, а его природа. Токен подтверждает сам себя, поэтому сервер не лезет в базу на каждый запрос. Именно это делает JWT быстрым, и именно это делает logout сложным. Разберём, что происходит внутри сессий и JWT, напишем ротацию refresh-токенов на Django, сравним три способа отзыва токена и честно скажем, когда обычная сессия лучше.
Две модели: состояние на сервере или в токене
В серверной сессии после логина сервер генерирует случайный идентификатор (session key) и отдаёт его браузеру в cookie. Всё остальное — кто вы, когда вошли — хранится на сервере: в базе, в Redis, где угодно. На каждый запрос сервер находит запись по ключу из cookie. Сам ключ ничего не значит, это просто указатель.
В Django это django.contrib.sessions. Бэкенд по умолчанию хранит данные в таблице django_session, cached_db сначала читает из кеша и идёт в базу только при промахе:
# settings.py
SESSION_ENGINE = "django.contrib.sessions.backends.cached_db"
SESSION_COOKIE_AGE = 60 * 60 * 24 * 14 # 2 weeks (Django default)
SESSION_COOKIE_SECURE = True # HTTPS only
SESSION_COOKIE_HTTPONLY = True # default: JS cannot read it
SESSION_COOKIE_SAMESITE = "Lax" # default
CSRF_COOKIE_SECURE = True
Логин и логаут в этой модели предельно простые:
# accounts/views.py
from django.contrib.auth import authenticate, login, logout
from django.http import JsonResponse
from django.views.decorators.http import require_POST
@require_POST
def login_view(request):
user = authenticate(
request,
username=request.POST.get("username"),
password=request.POST.get("password"),
)
if user is None:
return JsonResponse({"detail": "invalid credentials"}, status=401)
login(request, user) # rotates the session key (session fixation protection)
return JsonResponse({"ok": True})
@require_POST
def logout_view(request):
logout(request) # flushes the session row: the old cookie is now worthless
return JsonResponse({"ok": True})
logout() удаляет запись сессии. С этого момента старая cookie ничего не открывает, потому что сервер её не узнаёт. Отзыв — это просто удаление строки. Кроме того, Django кладёт в сессию значение, производное от хеша пароля, и сверяет его на каждом запросе: сменили пароль — сессии на других устройствах автоматически становятся недействительными (чтобы сохранить текущую, есть update_session_auth_hash()).
В stateless-токене (JWT) состояние лежит внутри токена. Сервер записывает ID пользователя, срок жизни и другие claims, подписывает и отдаёт клиенту. Дальше он проверяет только подпись и срок, в базу не ходит. Несколько сервисов могут независимо проверять токен общим секретом или публичным ключом.
Что внутри JWT и что гарантирует подпись
JWT (RFC 7519) — это три части через точку: header.payload.signature. Первые две — обычный JSON в base64url. Они не зашифрованы, прочитать их может кто угодно:
import base64
import json
def peek(token: str) -> tuple[dict, dict]:
"""Read a JWT WITHOUT verifying it. For debugging only."""
header_b64, payload_b64, _signature = token.split(".")
def b64(part: str) -> bytes:
return base64.urlsafe_b64decode(part + "=" * (-len(part) % 4))
return json.loads(b64(header_b64)), json.loads(b64(payload_b64))
# peek(token)
# ({'alg': 'HS256', 'typ': 'JWT'},
# {'sub': '42', 'iat': 1763200000, 'exp': 1763200300, 'jti': '...', 'ver': 3})
Подпись считается от строки header.payload. В HS256 (HMAC-SHA256) один секретный ключ используется и для подписи, и для проверки. В асимметричных RS256 или ES256 auth-сервис подписывает приватным ключом, а остальные сервисы проверяют публичным. Подпись гарантирует ровно одно: токен выпустил владелец ключа, и после этого его никто не трогал. Она не гарантирует, что токен всё ещё «нужен»: блокировка пользователя, смена пароля или logout на токен никак не влияют.
Отсюда два практических вывода: не кладите в payload ничего секретного (телефон, карту, внутренний список прав) и используйте стандартные claims: sub (кто), exp (до когда), iat (когда выпущен), iss/aud (кто выпустил и для кого), jti (уникальный ID токена).
Почему наивный подход ломается
Во многих проектах JWT впервые появляется примерно так:
import jwt
# WRONG: the signature is never checked, anyone can forge "sub": "1"
claims = jwt.decode(token, options={"verify_signature": False})
# WRONG: the token chooses its own algorithm
alg = jwt.get_unverified_header(token)["alg"]
claims = jwt.decode(token, key, algorithms=[alg])
# WRONG: long-lived access token, nothing can take it back
jwt.encode({"sub": "42", "exp": now + timedelta(days=30)}, key, algorithm="HS256")
В первой строке подпись вообще не проверяется: достаточно поменять payload и вписать в sub чужой ID. Во второй алгоритм выбирает сам токен. Это путь к классическим атакам: alg: none или подмена, при которой публичный асимметричный ключ используется как HMAC-секрет. Библиотеки защищают от части этого, но полагаться на это нельзя: список разрешённых алгоритмов должен быть жёстко задан в коде. Третья ошибка самая распространённая — access-токен на 30 дней. Если его украли, 30 дней его ничто не остановит.
Правильная версия явно задаёт алгоритм, aud, iss и обязательные claims:
# auth/tokens.py
import uuid
from datetime import timedelta
import jwt
from django.conf import settings
from django.utils import timezone
ALGORITHM = "HS256"
ACCESS_TTL = timedelta(minutes=5)
ISSUER = "api.example.com"
AUDIENCE = "web"
def issue_access_token(user) -> str:
now = timezone.now()
payload = {
"sub": str(user.pk),
"iss": ISSUER,
"aud": AUDIENCE,
"iat": now, # PyJWT converts datetime to a Unix timestamp
"exp": now + ACCESS_TTL,
"jti": uuid.uuid4().hex, # unique id, needed for the denylist
"ver": user.token_version, # needed for "log out everywhere"
}
return jwt.encode(payload, settings.JWT_SIGNING_KEY, algorithm=ALGORITHM)
def decode_access_token(token: str) -> dict:
return jwt.decode(
token,
settings.JWT_SIGNING_KEY,
algorithms=[ALGORITHM], # fixed list, never taken from the token
audience=AUDIENCE,
issuer=ISSUER,
leeway=10, # seconds of clock skew tolerance
options={"require": ["exp", "iat", "sub", "jti"]},
)
Access и refresh: короткая жизнь, длинная сессия
Основное решение — разделить токен на два:
- Access-токен — короткоживущий JWT (5–15 минут). Отправляется с каждым API-запросом и проверяется без базы.
- Refresh-токен — долгоживущий (дни, недели), но отправляется только на один endpoint: получить новый access-токен. Делать его JWT не обязательно. Лучше случайная строка, которая хранится в базе в виде хеша: его всё равно проверяют каждый раз.
Тогда logout превращается в отзыв refresh-токена, а не access. Access проживёт максимум несколько минут.
Следующий шаг — ротация: при каждом refresh старый токен помечается использованным и выдаётся новый. Если использованный токен приходит снова, значит, у кого-то есть его копия. В этом случае отзываем всё «семейство» — все refresh-токены, порождённые одним логином:
# auth/models.py
from django.conf import settings
from django.contrib.auth.models import AbstractUser
from django.db import models
class User(AbstractUser):
token_version = models.PositiveIntegerField(default=0)
class RefreshToken(models.Model):
user = models.ForeignKey(
settings.AUTH_USER_MODEL,
on_delete=models.CASCADE,
related_name="refresh_tokens",
)
token_hash = models.CharField(max_length=64, unique=True) # sha256 hex, never the raw token
family = models.UUIDField(db_index=True) # one login = one family
created_at = models.DateTimeField(auto_now_add=True)
expires_at = models.DateTimeField()
used_at = models.DateTimeField(null=True, blank=True)
revoked_at = models.DateTimeField(null=True, blank=True)
# auth/refresh.py
import hashlib
import secrets
import uuid
from datetime import timedelta
from django.db import transaction
from django.utils import timezone
from .models import RefreshToken
from .tokens import issue_access_token
REFRESH_TTL = timedelta(days=30)
class RefreshError(Exception):
pass
def _hash(raw: str) -> str:
return hashlib.sha256(raw.encode()).hexdigest()
def issue_refresh_token(user, family=None) -> str:
raw = secrets.token_urlsafe(32)
RefreshToken.objects.create(
user=user,
token_hash=_hash(raw),
family=family or uuid.uuid4(),
expires_at=timezone.now() + REFRESH_TTL,
)
return raw
def rotate_refresh_token(raw: str) -> tuple[str, str]:
now = timezone.now()
reuse_detected = False
with transaction.atomic():
token = (
RefreshToken.objects.select_for_update(of=("self",))
.select_related("user")
.filter(token_hash=_hash(raw))
.first()
)
if token is None or token.revoked_at or token.expires_at <= now:
raise RefreshError("invalid refresh token")
if not token.user.is_active:
raise RefreshError("user is inactive")
if token.used_at is not None:
# An already rotated token came back: someone has a copy.
# Revoke the whole family, the real user will log in again.
RefreshToken.objects.filter(
family=token.family, revoked_at__isnull=True
).update(revoked_at=now)
reuse_detected = True
else:
token.used_at = now
token.save(update_fields=["used_at"])
new_raw = issue_refresh_token(token.user, family=token.family)
access = issue_access_token(token.user)
# Raise AFTER the block: raising inside atomic() would roll back the revoke.
if reuse_detected:
raise RefreshError("refresh token reuse detected")
return access, new_raw
Здесь два тонких места. Первое — select_for_update(): блокируем строку, чтобы два параллельных запроса не увидели один и тот же токен «неиспользованным» и не выпустили два новых. Второе — исключение поднимается после блока atomic(). Если поднять его внутри, Django откатит транзакцию, и UPDATE, отзывающий семейство, тоже пропадёт.
Отзыв токена: три способа
Access-токен всё равно живёт какое-то время. Иногда и это слишком долго: пользователя заблокировали или он нажал «выйти везде». Есть три основных способа:
| Способ | Как работает | Цена |
|---|---|---|
| Короткий TTL | Access живёт 5 минут, отзывается refresh | Отзыв запаздывает до 5 минут |
Denylist (jti) |
Отозванный jti хранится в Redis до exp |
Обращение к Redis на каждый запрос |
Версия (ver) |
У пользователя token_version, сверяется со значением в токене |
Чтение пользователя на каждый запрос |
Denylist удобен для выхода с одного устройства: TTL ключа равен оставшейся жизни токена, поэтому Redis чистится сам. Версия — для «выйти везде»: увеличение числа на единицу мгновенно делает недействительными все токены, выпущенные со старым значением.
# auth/revoke.py
import time
from django.core.cache import cache
from django.db.models import F
from django.utils import timezone
from .models import RefreshToken, User
def revoke_access_token(claims: dict) -> None:
"""Logout on this device: deny the jti until the token would expire anyway."""
ttl = claims["exp"] - int(time.time())
if ttl > 0:
cache.set(f"jwt:deny:{claims['jti']}", 1, timeout=ttl)
def logout_everywhere(user) -> None:
"""Every access token with the old "ver" and every refresh token dies."""
User.objects.filter(pk=user.pk).update(token_version=F("token_version") + 1)
RefreshToken.objects.filter(user=user, revoked_at__isnull=True).update(
revoked_at=timezone.now()
)
Класс аутентификации для DRF собирает всё вместе:
# auth/authentication.py
import jwt
from django.contrib.auth import get_user_model
from django.core.cache import cache
from rest_framework import authentication, exceptions
from .tokens import decode_access_token
class JWTAuthentication(authentication.BaseAuthentication):
def authenticate(self, request):
parts = authentication.get_authorization_header(request).split()
if not parts or parts[0].lower() != b"bearer":
return None # let other authentication classes try
if len(parts) != 2:
raise exceptions.AuthenticationFailed("Malformed Authorization header")
try:
claims = decode_access_token(parts[1].decode())
except jwt.InvalidTokenError: # includes ExpiredSignatureError
raise exceptions.AuthenticationFailed("Invalid or expired token")
if cache.get(f"jwt:deny:{claims['jti']}"):
raise exceptions.AuthenticationFailed("Token revoked")
User = get_user_model()
user = User.objects.filter(pk=claims["sub"], is_active=True).first()
if user is None or user.token_version != claims["ver"]:
raise exceptions.AuthenticationFailed("Token revoked")
return user, claims
def authenticate_header(self, request):
return "Bearer" # makes DRF answer 401 instead of 403
Заметьте: как только вы добавили denylist или проверку версии, JWT перестал быть stateless. На каждый запрос вы всё равно обращаетесь к состоянию на сервере. Это не плохо, но если вы каждый раз ходите в Redis или базу, главного преимущества JWT у вас уже нет, и обычная сессия, скорее всего, проще.
Где хранить токен: localStorage или cookie
Здесь друг другу противостоят две атаки.
XSS (чужой JavaScript на странице). localStorage читается любым скриптом на странице. Хватит одного вредоносного npm-пакета или неэкранированного HTML: токен улетает на чужой сервер, и атакующий использует его со своей машины. HttpOnly cookie из JavaScript не прочитать. XSS всё ещё может слать запросы от имени пользователя, пока страница открыта, но унести токен не сможет.
CSRF (запрос с чужого сайта). Cookie браузер отправляет автоматически, поэтому форма на чужом сайте тоже её «принесёт». Против этого есть атрибут SameSite (Lax не отправляет cookie в cross-site POST и подзапросах, оставляя только переходы верхнего уровня по GET; Strict не отправляет её ни в каких cross-site запросах) и CSRF-токен Django. Токен в заголовке Authorization CSRF не подвержен: браузер сам его не добавляет.
Комбинация, которая хорошо работает на практике:
- access-токен — в памяти SPA (в переменной JavaScript), отправляется в заголовке
Authorization: Bearer; - refresh-токен — в cookie
HttpOnly; Secure; SameSite=Strict,Pathограничен auth-эндпоинтами; - после перезагрузки страницы SPA сначала идёт на
/api/auth/refresh/за новым access-токеном.
# auth/views.py
from django.http import JsonResponse
from django.views.decorators.http import require_POST
from .refresh import REFRESH_TTL, RefreshError, rotate_refresh_token
from .tokens import ACCESS_TTL
REFRESH_COOKIE = "refresh"
REFRESH_PATH = "/api/auth/"
@require_POST # a plain Django view: CsrfViewMiddleware still protects it
def refresh_view(request):
raw = request.COOKIES.get(REFRESH_COOKIE)
if not raw:
return JsonResponse({"detail": "no refresh token"}, status=401)
try:
access, new_raw = rotate_refresh_token(raw)
except RefreshError:
response = JsonResponse({"detail": "invalid refresh token"}, status=401)
response.delete_cookie(REFRESH_COOKIE, path=REFRESH_PATH, samesite="Strict")
return response
response = JsonResponse(
{"access": access, "expires_in": int(ACCESS_TTL.total_seconds())}
)
response.set_cookie(
REFRESH_COOKIE,
new_raw,
max_age=int(REFRESH_TTL.total_seconds()),
path=REFRESH_PATH, # the browser sends it only to /api/auth/...
secure=True,
httponly=True,
samesite="Strict",
)
return response
refresh_view — обычная Django-view, поэтому её защищает CsrfViewMiddleware: SPA должна отправлять заголовок X-CSRFToken. DRF APIView проверяет CSRF только для SessionAuthentication, так что если перенесёте cookie-эндпоинт в DRF, CSRF придётся добавить самостоятельно.
Подводные камни в продакшене
- Параллельный refresh. Две вкладки одновременно видят, что access истёк, и обе идут за refresh. Вторая отправляет уже использованный токен, reuse detection отзывает семейство, и пользователя «без причины» выкидывает. Решение: на клиенте один refresh, которого ждут все запросы (single-flight), или на сервере grace period в несколько секунд для только что использованного токена.
- Расхождение часов.
expиiatзависят от часов серверов. Без NTP сервисы начинают отвергать токены друг друга как «пришедшие из будущего»;leewayдержите в пределах нескольких секунд. - Смена ключа. Сменили HS256-секрет — мгновенно умерли все токены. С асимметричными ключами
kidв заголовке и приём нескольких публичных ключей одновременно делают ротацию плавной. - Толстый payload. Список ролей и прав в токене утяжеляет каждый запрос, а при изменении прав старый токен продолжает жить со старыми правами.
- Refresh-токен в открытом виде. Если в базе лежат сырые refresh-токены, дамп базы даёт доступ ко всем аккаунтам. Храните только хеш.
- Logout только на фронтенде.
localStorage.removeItem()— это не logout. Если на сервере ничего не отозвано, украденная копия продолжает жить. - Мусор в таблицах.
RefreshTokenиdjango_sessionрастут. Поставьте периодическую задачу, удаляющую просроченные строки; для сессий в Django есть командаclearsessions.
Когда сессия лучше
Для многих Django-проектов честный ответ — сессия. Если фронтенд и бэкенд живут под одним доменом (или одним сайтом), страницы рендерятся на сервере или SPA лежит на том же сайте, сессия даёт бесплатно: мгновенный logout, HttpOnly cookie, готовую CSRF-защиту, совместимость с админкой. Одно чтение из Redis на запрос обычно незаметно; не гадайте, а измерьте на своей нагрузке.
JWT оправдан, когда несколько независимых сервисов должны проверять токен, не обращаясь к центральному; для короткоживущих межсервисных токенов; или когда внешний identity provider (OpenID Connect) уже выдаёт JWT. Для мобильного приложения JWT тоже не обязателен: обычный случайный (opaque) токен в базе часто достаточен, и отозвать его легко.
Чеклист
- Разрешённые алгоритмы жёстко заданы в коде,
verify_signatureникогда не отключается. exp,iat,sub,jtiобязательны;audиissпроверяются.- Access-токен 5–15 минут; refresh-токен в базе в виде хеша, с ротацией и reuse detection.
- Для выхода с одного устройства — denylist по
jti(TTL = оставшаяся жизнь), для «выйти везде» —token_version. - Токен не в
localStorage; refresh в cookieHttpOnly; Secure; SameSite,Pathограничен. - Каждый изменяющий endpoint, работающий через cookie, защищён от CSRF.
- В payload нет секретных данных.
- Параллельный refresh решён на клиенте или grace period'ом.
- Просроченные токены и сессии периодически чистятся.
Итог
В сессии состояние на сервере, поэтому отзыв прост. В JWT состояние в токене, поэтому проверка дешёвая, а отзыв сложный. Короткий access, ротируемый refresh и проверка jti/версии решают проблему, но ценой части stateless-свойств. Если у вас один сайт и один бэкенд, сначала посмотрите на сессии Django: они уже работают правильно.
// комментарии
Загружаем комментарии...