Logout bosildi, token esa hamon ishlaydi: session va JWT, refresh token va bekor qilish
JWT imzosi to'g'ri bo'lsa, server uni rad etmaydi, hatto foydalanuvchi "hamma joydan chiqish"ni bosgan bo'lsa ham. Session va JWT ichida nima bor, refresh rotatsiyasi, denylist, token versiyasi va token qayerda saqlanishi Django misolida.
Foydalanuvchi telefonini yo'qotdi. Kompyuterdan kirib, "Barcha qurilmalardan chiqish" tugmasini bosdi va yengil nafas oldi. Lekin backend JWT bilan ishlaydi, access token esa 24 soat amal qiladi. Telefon qo'lida bo'lgan odam ertaga shu vaqtgacha bemalol so'rov yuborishi mumkin: token imzosi to'g'ri, exp hali kelmagan, server esa uni rad etishga sabab topmaydi.
Bu JWT'ning "xatosi" emas, uning tabiati. Token o'zini o'zi tasdiqlaydi, shuning uchun server uni har safar bazadan tekshirmaydi. Aynan shu xususiyat uni tez qiladi va aynan shu xususiyat logout'ni qiyinlashtiradi. Bu maqolada session va JWT ichida nima bo'layotganini ko'rib chiqamiz, refresh token rotatsiyasini Django'da yozamiz, tokenni bekor qilishning uch usulini solishtiramiz va qachon oddiy session yaxshiroq ekanini aytamiz.
Ikki model: holat serverda yoki tokenda
Server-side sessionda login qilgandan keyin server tasodifiy identifikator (session key) yaratadi va uni cookie'da brauzerga beradi. Kim ekanligingiz, qachon kirganingiz kabi ma'lumotlar serverda saqlanadi: bazada, Redis'da yoki boshqa joyda. Har bir so'rovda server cookie'dagi kalit bo'yicha yozuvni topadi. Kalitning o'zi hech narsa anglatmaydi, u shunchaki ko'rsatkich.
Django'da bu django.contrib.sessions orqali ishlaydi. Default backend ma'lumotni django_session jadvalida saqlaydi, cached_db esa avval keshdan o'qiydi, topilmasa bazaga boradi:
# 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
Login va logout bu modelda juda sodda:
# 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() session yozuvini o'chiradi. Shu ondan boshlab eski cookie hech narsani ochmaydi, chunki server uni tanimaydi. Bekor qilish shunchaki yozuvni o'chirishdan iborat. Bundan tashqari, Django session ichida parol hash'idan olingan qiymatni saqlaydi va har bir so'rovda uni tekshiradi: parol o'zgarsa, boshqa qurilmalardagi sessionlar avtomatik yaroqsiz bo'ladi (joriy sessionni saqlab qolish uchun update_session_auth_hash() bor).
Stateless token (JWT)da esa holat tokenning ichida bo'ladi. Server foydalanuvchi ID'si, muddat va boshqa claim'larni yozadi, imzolaydi va mijozga beradi. Keyingi so'rovlarda server faqat imzo va muddatni tekshiradi, bazaga bormaydi. Bir nechta servis bitta umumiy kalit (yoki ochiq kalit) bilan tokenni mustaqil tekshira oladi.
JWT ichida nima bor va imzo nimani kafolatlaydi
JWT (RFC 7519) nuqta bilan ajratilgan uch qismdan iborat: header.payload.signature. Birinchi ikki qism shunchaki base64url'da kodlangan JSON. Ular shifrlanmagan, ularni istalgan odam o'qiy oladi:
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})
Imzo header.payload qatoridan hisoblanadi. HS256 (HMAC-SHA256)da imzolash va tekshirish uchun bitta maxfiy kalit ishlatiladi. RS256 yoki ES256 kabi asimmetrik algoritmlarda esa auth-servis xususiy kalit bilan imzolaydi, boshqa servislar ochiq kalit bilan tekshiradi. Imzo faqat bitta narsani kafolatlaydi: tokenni kalit egasi yaratgan va keyin unga hech kim tegmagan. U tokenning hali "kerakli" ekanini kafolatlamaydi: foydalanuvchi bloklangani, parolni almashtirgani yoki logout qilgani tokenga ta'sir qilmaydi.
Shundan ikki amaliy xulosa chiqadi: payload'ga maxfiy ma'lumot (telefon raqami, karta, ichki ruxsatlar ro'yxati) yozmang va standart claim'lardan foydalaning: sub (kim), exp (qachongacha), iat (qachon chiqarilgan), iss/aud (kim chiqargan va kim uchun), jti (tokenning noyob ID'si).
Sodda yondashuv nega buziladi
Ko'p loyihalarda JWT birinchi marta mana shunday paydo bo'ladi:
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")
Birinchi qatorda imzo umuman tekshirilmayapti: payload'ni o'zgartirib, sub ga boshqa ID yozish kifoya. Ikkinchisida algoritmni tokenning o'zi tanlaydi. Bu klassik hujumlar yo'li: alg: none yoki asimmetrik ochiq kalitni HMAC sirri sifatida ishlatishga majburlash. Kutubxonalar bularning ayrimidan himoya qiladi, lekin bunga suyanmaslik kerak: ruxsat etilgan algoritmlar ro'yxati kodda qat'iy yozilishi shart. Uchinchisi eng keng tarqalgani: 30 kunlik access token. U o'g'irlansa, 30 kun davomida uni hech narsa to'xtatmaydi.
To'g'ri versiya algoritmni, aud, iss va majburiy claim'larni aniq ko'rsatadi:
# 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 va refresh: qisqa umr, uzoq session
Muammoning asosiy yechimi tokenni ikkiga bo'lish:
- Access token — qisqa muddatli JWT (5–15 daqiqa). Har bir API so'rovida yuboriladi va bazasiz tekshiriladi.
- Refresh token — uzoq muddatli (kunlar, haftalar), lekin faqat bitta endpoint'ga yuboriladi: yangi access token olish uchun. Uni JWT qilish shart emas. Tasodifiy satr qilib, bazada hash ko'rinishida saqlash ancha yaxshi, chunki baribir har safar tekshiriladi.
Shunda "logout" access token'ni emas, refresh token'ni bekor qilishga aylanadi. Access token ko'pi bilan bir necha daqiqa yashaydi.
Keyingi qadam — rotatsiya: har bir refresh'da eski token "ishlatilgan" deb belgilanadi va yangisi beriladi. Agar ishlatilgan token yana kelsa, demak uning nusxasi boshqa birovda. Bu holatda butun "oila"ni (bitta logindan tug'ilgan barcha refresh tokenlarni) bekor qilamiz:
# 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
Bu yerda ikki nozik joy bor. Birinchisi, select_for_update(): ikki parallel so'rov bitta tokenni bir vaqtda "ishlatilmagan" deb ko'rib, ikkita yangi token chiqarib yubormasligi uchun qatorni lock qilamiz. Ikkinchisi, istisnoni atomic() blokidan keyin ko'taramiz. Agar uni blok ichida ko'tarsak, Django transaction'ni rollback qiladi va oilani bekor qilgan UPDATE ham yo'qoladi.
Tokenni bekor qilish: uch usul
Access token hali ham qisqa muddat yashaydi. Ba'zan bu muddat ham ko'p: masalan, foydalanuvchi bloklanganda yoki "barcha qurilmalardan chiqish" bosilganda. Uch asosiy usul bor:
| Usul | Qanday ishlaydi | Narxi |
|---|---|---|
| Qisqa TTL | Access token 5 daqiqa yashaydi, refresh bekor qilinadi | Bekor qilish 5 daqiqagacha kechikadi |
Denylist (jti) |
Bekor qilingan jti Redis'da exp gacha saqlanadi |
Har bir so'rovda Redis'ga murojaat |
Versiya (ver) |
Foydalanuvchida token_version, tokendagi qiymat bilan solishtiriladi |
Har bir so'rovda foydalanuvchini o'qish |
Denylist bitta qurilmadagi logout uchun qulay: kalitning TTL'i tokenning qolgan umriga teng, shuning uchun Redis o'z-o'zidan tozalanadi. Versiya esa "hammasini o'chirish" uchun: raqamni bittaga oshirish eski raqam bilan chiqarilgan barcha tokenlarni bir zumda yaroqsiz qiladi.
# 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 uchun authentication klassi hammasini birlashtiradi:
# 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
E'tibor bering: denylist yoki versiya tekshiruvini qo'shgan zahoti JWT stateless bo'lmay qoladi. Har bir so'rovda baribir server holatiga murojaat qilasiz. Bu yomon emas, lekin agar har safar Redis yoki bazaga borayotgan bo'lsangiz, JWT'ning asosiy afzalligi sizda qolmagan va oddiy session ehtimol soddaroq.
Token qayerda saqlanadi: localStorage yoki cookie
Bu yerda ikki xil hujum bir-biriga qarama-qarshi turadi.
XSS (sahifaga begona JavaScript kirishi). localStorage ni sahifadagi istalgan skript o'qiy oladi. Bitta zararli npm paket yoki filtrlanmagan HTML yetarli: token boshqa serverga yuboriladi va hujumchi uni o'z kompyuteridan ishlatadi. HttpOnly cookie'ni JavaScript o'qiy olmaydi. XSS baribir sahifa ochiq turgan paytda foydalanuvchi nomidan so'rov yubora oladi, lekin tokenni olib keta olmaydi.
CSRF (boshqa saytdan so'rov). Cookie brauzer tomonidan avtomatik yuboriladi, shuning uchun begona sayt formasi ham uni "olib keladi". Bunga qarshi SameSite atributi (Lax cookie'ni cross-site POST va ichki so'rovlarda yubormaydi, faqat yuqori darajadagi GET o'tishlarida yuboradi; Strict esa hech qanday cross-site so'rovda yubormaydi) va Django'ning CSRF token'i bor. Authorization header'dagi token CSRF'ga moyil emas, chunki brauzer uni o'zi qo'shmaydi.
Amalda yaxshi ishlaydigan kombinatsiya:
- access token — SPA xotirasida (JavaScript o'zgaruvchisida),
Authorization: Bearerheader'da yuboriladi; - refresh token —
HttpOnly; Secure; SameSite=Strictcookie'da,Pathfaqat auth endpoint'lariga cheklangan; - sahifa yangilanganda SPA avval
/api/auth/refresh/ga murojaat qilib, yangi access token oladi.
# 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 oddiy Django view, shuning uchun CsrfViewMiddleware uni himoya qiladi: SPA X-CSRFToken header'ini yuborishi kerak. DRF APIView esa faqat SessionAuthentication uchun CSRF'ni tekshiradi, shuning uchun cookie bilan ishlaydigan endpoint'ni DRF'ga ko'chirsangiz, CSRF'ni o'zingiz qo'shishingiz kerak bo'ladi.
Production'dagi tuzoqlar
- Parallel refresh. Brauzerda ikki tab bir vaqtda access token muddati tugaganini ko'radi va ikkalasi refresh qiladi. Ikkinchisi allaqachon ishlatilgan tokenni yuboradi va reuse detection butun oilani o'chiradi: foydalanuvchi "sababsiz" logout bo'ladi. Yechim: mijozda bitta refresh'ni barcha so'rovlar kutadigan qilish (single-flight) yoki serverda ishlatilgan token uchun bir necha soniyalik grace period.
- Soat farqi.
expvaiatserverlar soatiga bog'liq. NTP'siz servislar bir-birining tokenini "kelajakdan kelgan" deb rad etishi mumkin;leewaybir necha soniya bilan cheklansin. - Kalit almashtirish. HS256 kalitini almashtirsangiz, barcha tokenlar bir zumda yaroqsiz bo'ladi. Asimmetrik kalitlarda header'dagi
kidva bir vaqtda bir nechta ochiq kalitni qabul qilish rotatsiyani silliq qiladi. - Katta payload. Rollar va ruxsatlar ro'yxatini tokenga joylash har bir so'rovni og'irlashtiradi va ruxsat o'zgarganda eski token eski huquqlar bilan yuraveradi.
- Refresh tokenni ochiq saqlash. Bazada xom refresh token saqlansa, baza dump'i bilan barcha foydalanuvchilar hisobiga kirish mumkin. Faqat hash saqlang.
- Logout faqat frontend'da.
localStorage.removeItem()qilish logout emas. Server tomonida hech narsa bekor qilinmasa, token o'g'irlangan nusxada yashashda davom etadi. - Eskirgan yozuvlar.
RefreshTokenvadjango_sessionjadvallari o'sib boradi. Muddati o'tgan qatorlarni o'chiradigan davriy vazifa qo'ying; session'lar uchun Django'daclearsessionsbuyrug'i bor.
Qachon session yaxshiroq
Ko'p Django loyihalarida halol javob: session. Agar frontend va backend bitta domen (yoki bitta sayt) ostida bo'lsa, server-rendered sahifalar yoki shu saytdagi SPA bo'lsa, session sizga bepul beradi: darhol ishlaydigan logout, HttpOnly cookie, tayyor CSRF himoyasi, admin panel bilan moslik. Har bir so'rovdagi Redis'dan bitta o'qish odatda sezilmaydi; buni taxmin qilmasdan, o'z yuklamangizda o'lchab ko'rish kerak.
JWT o'zini quyidagi holatlarda oqlaydi: bir nechta mustaqil servis tokenni markaziy servisga bormasdan tekshirishi kerak bo'lganda, servislararo qisqa muddatli tokenlarda, yoki tashqi identity provider (OpenID Connect) allaqachon JWT berayotganda. Mobil ilova uchun ham JWT majburiy emas: bazada saqlanadigan oddiy tasodifiy (opaque) token ko'pincha yetarli va uni bekor qilish oson.
Checklist
- Ruxsat etilgan algoritmlar kodda qat'iy yozilgan,
verify_signaturehech qachon o'chirilmaydi. exp,iat,sub,jtimajburiy;audvaisstekshiriladi.- Access token 5–15 daqiqa; refresh token bazada hash ko'rinishida, rotatsiya va reuse detection bilan.
- Bitta qurilmadan logout uchun
jtidenylist (TTL = qolgan umr), hamma joydan chiqish uchuntoken_version. - Token
localStorageda emas; refreshHttpOnly; Secure; SameSitecookie'da,Pathcheklangan. - Cookie bilan ishlaydigan har bir yozuvchi endpoint CSRF himoyasida.
- Payload'da maxfiy ma'lumot yo'q.
- Parallel refresh mijozda yoki grace period bilan hal qilingan.
- Muddati o'tgan tokenlar va sessionlar davriy tozalanadi.
Xulosa
Session'da holat serverda, shuning uchun bekor qilish oson. JWT'da holat tokenda, shuning uchun tekshirish arzon, bekor qilish esa qiyin. Qisqa access token, rotatsiya qilinadigan refresh token va jti/versiya tekshiruvi bu muammoni hal qiladi, lekin bu bilan stateless'likning bir qismidan voz kechasiz. Agar bitta saytingiz va bitta backend'ingiz bo'lsa, avval Django session'ni ko'rib chiqing: u allaqachon to'g'ri ishlaydi.
// izohlar
Izohlar yuklanmoqda...