'Google orqali kirish' ichida nima bo'ladi: OAuth 2.0, OpenID Connect va PKCE
Backend'ga kelgan email yoki token — bu isbot emas. Authorization Code + PKCE oqimi, access token va ID token farqi hamda Django'da ID token'ni imzo, aud, iss va exp bo'yicha to'g'ri tekshirish.
Saytingizga "Google orqali kirish" tugmasini qo'shdingiz. Frontend dasturchi tez yechim topdi: tugma bosilganda brauzer Google'dan foydalanuvchi ma'lumotini oladi va backend'ga {"email": "ali@gmail.com"} yuboradi. Backend shu email bo'yicha foydalanuvchini topib, session ochadi. Hammasi ishlaydi, demo ham chiroyli chiqadi.
Endi kimdir DevTools'ni ochib, o'sha so'rovni boshqa email bilan qayta yuboradi. Backend unga ham "xush kelibsiz" deydi. Parol yo'q, Google yo'q, hech qanday tekshiruv yo'q.
Biroz "ehtiyotkorroq" variant ham bor: frontend Google'dan token oladi, backend'ga yuboradi, backend esa uni base64'dan ochib, ichidagi emailni o'qiydi. Bu ham deyarli bir xil teshik. Ushbu maqolada "Google orqali kirish" ortida aslida qanday protokol ishlashini, qaysi token nima uchunligini va Django backend'da ID token'ni qanday to'g'ri tekshirishni qadam-baqadam ko'rib chiqamiz.
Nega oddiy yondashuv buziladi
Asosiy xato: backend mijozdan kelgan da'voga ishonadi. Brauzer — bu sizning nazoratingizdan tashqaridagi muhit. Undan kelgan har qanday JSON, header yoki token "kimdir shunday deyapti" degani, xolos. Backend'ga isbot kerak: bu ma'lumotni haqiqatan Google bergan, aynan sizning ilovangiz uchun bergan va u hali eskirmagan.
Yana bir nozik holat: backend token'ni qabul qiladi va Google API'ga (masalan, userinfo) murojaat qilib, kimligini aniqlaydi. Token haqiqiy, Google javob beradi, nima muammo? Muammo shundaki, bu token boshqa ilova uchun berilgan bo'lishi mumkin. Tasavvur qiling: kimdir "Bepul test" degan ilova yasaydi, unga minglab odam Google orqali kiradi va ilova muallifi ularning token'larini yig'adi. Agar sizning backend'ingiz "Google qabul qildimi — demak, yaxshi" desa, u o'sha token'lar bilan sizning saytingizga ham shu odamlar nomidan kira oladi. Bu token substitution deb ataladi va undan faqat bitta narsa himoya qiladi: token kim uchun berilganini (aud) tekshirish.
OAuth 2.0 va OpenID Connect: kim nima qiladi
Avval atamalarni ajratib olaylik, chunki aynan shu yerda chalkashlik boshlanadi.
OAuth 2.0 — bu authorization, ya'ni ruxsat berish protokoli. U "bu ilova mening nomimdan Google Drive'dagi fayllarni o'qishi mumkin" degan savolga javob beradi. Natijada ilova access token oladi. OAuth 2.0 o'zi "foydalanuvchi kim?" degan savolga javob bermaydi.
OpenID Connect (OIDC) — OAuth 2.0 ustiga qurilgan authentication qatlami. openid scope so'ralganda provider qo'shimcha ravishda ID token qaytaradi: bu imzolangan JWT bo'lib, ichida "bu foydalanuvchi shu, uni men shu vaqtda, shu ilova uchun tasdiqladim" degan ma'lumot bor.
| ID token | Access token | |
|---|---|---|
| Kim uchun | Sizning ilovangiz (client) | Resource server (API) |
| Formati | Har doim JWT (OIDC talabi) | Provider belgilaydi; Google'da shaffof emas (opaque) |
aud |
Sizning client_id |
API |
| Nima uchun | Foydalanuvchini aniqlash | Scope doirasida API chaqirish |
| API'ga yuboriladimi | Yo'q | Ha, Authorization: Bearer |
ID token — ilovangizga "kim keldi" deydi. Access token — API'ga "bu ilovaga nimaga ruxsat berilgan" deydi. Ularni bir-birining o'rnida ishlatish ko'p xatolarning ildizi.
Google'ning barcha manzillari discovery hujjatida e'lon qilingan, ularni qo'lda yodlash shart emas:
# Discovery document: endpoints, supported algorithms, claims
curl -s https://accounts.google.com/.well-known/openid-configuration \
| python3 -m json.tool | grep -E '"(issuer|authorization_endpoint|token_endpoint|jwks_uri)"'
Authorization Code + PKCE: qadam-baqadam
Server tomoni bor veb-ilova uchun to'g'ri oqim — Authorization Code flow, PKCE bilan. Eski Implicit flow (token to'g'ridan-to'g'ri URL fragment'ida qaytadigan) RFC 9700 — OAuth 2.0 xavfsizlik bo'yicha Best Current Practice hujjatida tavsiya etilmaydi.
Oqim quyidagicha:
- Ilova tayyorlanadi. Backend uchta tasodifiy qiymat yaratadi:
state(CSRF'dan himoya),nonce(ID token'ni qayta ishlatishdan himoya) vacode_verifier(PKCE siri). Hammasini session'ga saqlaydi. - Brauzer Google'ga yo'naltiriladi. URL'da
client_id,redirect_uri,scope,state,noncevacode_challenge = BASE64URL(SHA256(code_verifier))bor. Verifier'ning o'zi hech qachon brauzerga chiqmaydi. - Foydalanuvchi Google'da kiradi va rozilik beradi. Parolni siz ko'rmaysiz — bu OIDC'ning asosiy afzalligi.
- Google brauzerni
redirect_uri?code=...&state=...ga qaytaradi.code— qisqa umrli, bir martalik kod. U hali token emas. - Backend
stateni tekshiradi va kodni server-server kanali orqali token endpoint'ga yuboradi:code,client_secretvacode_verifierbilan. - Google
SHA256(code_verifier)ni avval olingancode_challengebilan solishtiradi. Mos kelsa,access_token,id_token,expires_in,scopeqaytaradi. - Backend ID token'ni tekshiradi, foydalanuvchini
subbo'yicha topadi yoki yaratadi va o'zining Django session'ini ochadi.
PKCE nima uchun kerak, axir client_secret bor-ku? Kod brauzer orqali o'tadi: u server log'larida, proxy'larda, brauzer tarixida, mobil qurilmada esa boshqa ilovaning qo'lida qolishi mumkin. PKCE bo'lsa, ushlab olingan kod verifier'siz yaroqsiz. Shu sababli RFC 9700 PKCE'ni confidential client'lar uchun ham tavsiya qiladi.
Kod: Django'da login va callback
Birinchi view: PKCE juftligini yaratamiz va Google'ga yo'naltiramiz.
# accounts/views.py
import base64
import hashlib
import secrets
from urllib.parse import urlencode
from django.conf import settings
from django.shortcuts import redirect
GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth"
def _pkce_pair() -> tuple[str, str]:
# 64 random bytes -> 86 URL-safe chars (RFC 7636 allows 43..128)
verifier = secrets.token_urlsafe(64)
digest = hashlib.sha256(verifier.encode("ascii")).digest()
challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
return verifier, challenge
def google_login(request):
verifier, challenge = _pkce_pair()
state = secrets.token_urlsafe(32)
nonce = secrets.token_urlsafe(32)
request.session["oauth_google"] = {
"state": state,
"nonce": nonce,
"verifier": verifier,
}
params = {
"client_id": settings.GOOGLE_CLIENT_ID,
"redirect_uri": settings.GOOGLE_REDIRECT_URI, # exact match with Console
"response_type": "code",
"scope": "openid email profile",
"state": state,
"nonce": nonce,
"code_challenge": challenge,
"code_challenge_method": "S256",
}
return redirect(f"{GOOGLE_AUTH_URL}?{urlencode(params)}")
Callback view: stateni tekshiramiz, kodni almashtiramiz, ID token'ni tekshiramiz. Session'dan qiymatni pop qilish muhim — kod bir martalik bo'lgani kabi, bizning holatimiz ham bir martalik bo'lishi kerak.
# accounts/views.py (continued)
import requests
from django.contrib.auth import login
from django.http import HttpResponseBadRequest
from .google import InvalidIdToken, verify_google_id_token
from .services import AccountLinkRequired, get_or_create_user_from_google
GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token"
def google_callback(request):
saved = request.session.pop("oauth_google", None)
if saved is None:
return HttpResponseBadRequest("No login in progress")
if "error" in request.GET: # e.g. access_denied
return HttpResponseBadRequest("Login cancelled")
state = request.GET.get("state", "")
if not secrets.compare_digest(state.encode(), saved["state"].encode()):
return HttpResponseBadRequest("Invalid state")
resp = requests.post(
GOOGLE_TOKEN_URL,
data={
"grant_type": "authorization_code",
"code": request.GET.get("code", ""),
"redirect_uri": settings.GOOGLE_REDIRECT_URI,
"client_id": settings.GOOGLE_CLIENT_ID,
"client_secret": settings.GOOGLE_CLIENT_SECRET,
"code_verifier": saved["verifier"],
},
timeout=10,
)
if resp.status_code != 200:
return HttpResponseBadRequest("Token exchange failed")
tokens = resp.json()
try:
claims = verify_google_id_token(tokens["id_token"], nonce=saved["nonce"])
user = get_or_create_user_from_google(claims)
except (KeyError, InvalidIdToken):
return HttpResponseBadRequest("Invalid ID token")
except AccountLinkRequired:
return redirect("/login/?link=google")
login(request, user, backend="django.contrib.auth.backends.ModelBackend")
return redirect("/")
E'tibor bering: Google qaytargan token'lar bilan ish shu yerda tugaydi. Agar sizga faqat login kerak bo'lsa, access_tokenni saqlashning hojati yo'q — foydalanuvchi uchun o'z session'ingizni ochasiz va shu bilan vazifa bajarildi.
ID token'ni server tomonda tekshirish
Bu maqolaning eng muhim qismi. ID token — bu header.payload.signature ko'rinishidagi JWT. Payload'ni ochish uchun kalit kerak emas, u shunchaki base64url. Shuning uchun "ochib, ichidagi email'ni o'qish" — tekshirish emas. To'g'ri tekshiruv to'rt qismdan iborat:
- Imzo. Google token'ni o'zining yopiq kaliti bilan RS256 orqali imzolaydi. Ochiq kalitlar
jwks_urimanzilida JWK to'plami sifatida e'lon qilinadi, kerakli kalit header'dagikidorqali tanlanadi. Algoritmni token header'idan emas, o'z kodingizdan oling. audsizningclient_idingizga teng bo'lishi shart. Yuqoridagi "bepul test" hujumiga qarshi aynan shu himoya qiladi.iss— Google uchunhttps://accounts.google.comyokiaccounts.google.com.exp— muddati o'tmagan bo'lishi kerak. Server soatlari biroz farq qilishi mumkin, shuning uchun bir necha soniyalikleewayqo'yish odatiy amaliyot.
Bularga qo'shimcha ravishda, agar so'rovda nonce yuborgan bo'lsangiz, token'dagi nonce session'dagisiga teng bo'lishi kerak.
PyJWT bilan:
# accounts/google.py
import jwt
from django.conf import settings
GOOGLE_JWKS_URL = "https://www.googleapis.com/oauth2/v3/certs"
GOOGLE_ISSUERS = {"https://accounts.google.com", "accounts.google.com"}
# Module-level: the JWK set is cached between requests in this process
_jwks = jwt.PyJWKClient(GOOGLE_JWKS_URL, lifespan=3600, timeout=5)
class InvalidIdToken(Exception):
pass
def verify_google_id_token(token: str, nonce: str | None) -> dict:
try:
key = _jwks.get_signing_key_from_jwt(token) # picks key by "kid"
claims = jwt.decode(
token,
key.key,
algorithms=["RS256"], # never trust "alg" from the header
audience=settings.GOOGLE_CLIENT_ID,
options={"require": ["iss", "aud", "exp", "iat", "sub"]},
leeway=30, # small clock skew tolerance
)
except jwt.PyJWTError as exc:
raise InvalidIdToken(str(exc)) from exc
if claims["iss"] not in GOOGLE_ISSUERS:
raise InvalidIdToken("unexpected issuer")
if nonce is None or claims.get("nonce") != nonce:
raise InvalidIdToken("nonce mismatch")
return claims
PyJWKClient JWK to'plamini kesh qiladi va token'da notanish kid uchrasa, to'plamni qayta yuklaydi. Google kalitlarini vaqti-vaqti bilan almashtiradi (key rotation), shuning uchun ochiq kalitni kodga qattiq yozib qo'yish — kelajakdagi to'satdan buziladigan login degani.
Agar loyihada google-auth kutubxonasi bo'lsa, xuddi shu tekshiruv bitta chaqiruvda bajariladi:
from google.auth.transport import requests as google_requests
from google.oauth2 import id_token
# Checks signature, exp, aud and iss; raises ValueError on failure.
# The nonce still has to be compared by you.
claims = id_token.verify_oauth2_token(
token, google_requests.Request(), settings.GOOGLE_CLIENT_ID
)
Foydalanuvchini qanday bog'lash: sub, email emas
ID token'da email, email_verified, name, picture va eng muhimi — sub bor. sub — Google akkaunti uchun o'zgarmas, takrorlanmas identifikator. Email esa o'zgarishi mumkin. Shuning uchun bog'lanishni (provider, sub) juftligi bo'yicha qiling:
# accounts/models.py
from django.conf import settings
from django.db import models
class SocialAccount(models.Model):
user = models.ForeignKey(
settings.AUTH_USER_MODEL,
on_delete=models.CASCADE,
related_name="social_accounts",
)
provider = models.CharField(max_length=32)
subject = models.CharField(max_length=255) # the "sub" claim
email = models.EmailField(blank=True) # informational only
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
constraints = [
models.UniqueConstraint(
fields=["provider", "subject"],
name="uniq_social_provider_subject",
),
]
# accounts/services.py
from django.contrib.auth import get_user_model
from django.db import IntegrityError, transaction
from .google import InvalidIdToken
from .models import SocialAccount
class AccountLinkRequired(Exception):
pass
def get_or_create_user_from_google(claims: dict):
sub = claims["sub"]
account = (
SocialAccount.objects.select_related("user")
.filter(provider="google", subject=sub)
.first()
)
if account is not None:
return account.user
if claims.get("email_verified") is not True:
raise InvalidIdToken("email is not verified")
User = get_user_model()
email = claims["email"].lower()
if User.objects.filter(email__iexact=email).exists():
# Someone already registered with this email (e.g. with a password).
# Make them log in first and link Google from settings.
raise AccountLinkRequired(email)
try:
with transaction.atomic():
user = User.objects.create_user(username=f"google_{sub}", email=email)
SocialAccount.objects.create(
user=user, provider="google", subject=sub, email=email
)
except IntegrityError:
# A parallel callback for the same Google account won the race
return SocialAccount.objects.get(provider="google", subject=sub).user
return user
Bu yerda ikkita qaror bor. Birinchisi: email_verified true bo'lmasa, email'ga ishonmaymiz. Ikkinchisi: shu email bilan allaqachon foydalanuvchi bo'lsa, akkauntni avtomatik bog'lamaymiz. Avtomatik bog'lash qulay, lekin u email tekshiruvi kuchsiz bo'lgan har qanday provider qo'shilgan kuni account takeover'ga aylanadi. Xavfsiz yo'l — foydalanuvchi avval o'z usuli bilan kirsin, keyin sozlamalarda Google'ni ulasin. IntegrityError bloki esa foydalanuvchi callback'ni bir vaqtning o'zida ikki marta ochgan holat uchun: UniqueConstraint ikki nusxa yaratishga yo'l qo'ymaydi.
Google Identity Services: brauzerdagi oqim
Google'ning hozirgi JavaScript kutubxonasi — Google Identity Services (GIS). Uning "Sign in with Google" tugmasi va One Tap oynasi redirect'siz ishlaydi: foydalanuvchi akkauntni tanlaydi va callback'ingizga response.credential keladi. Bu credential — o'sha ID token. Access token emas va kod ham emas.
<!-- templates/accounts/login.html -->
<script src="https://accounts.google.com/gsi/client" async></script>
<div id="google-btn"></div>
<script>
window.onload = () => {
google.accounts.id.initialize({
client_id: "{{ google_client_id }}",
nonce: "{{ gis_nonce }}",
callback: async (response) => {
const r = await fetch("/auth/google/gis/", {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-CSRFToken": "{{ csrf_token }}",
},
body: JSON.stringify({ credential: response.credential }),
});
if (r.ok) window.location.href = "/";
},
});
google.accounts.id.renderButton(
document.getElementById("google-btn"),
{ theme: "outline", size: "large" },
);
};
</script>
Backend tomonda tekshiruv aynan bir xil — imzo, aud, iss, exp, nonce. Sahifa ochilganda nonceni session'ga yozamiz va GIS'ga beramiz:
# accounts/views.py (continued)
import json
from django.http import JsonResponse
from django.shortcuts import render
from django.views.decorators.http import require_POST
def login_page(request):
request.session["gis_nonce"] = secrets.token_urlsafe(32)
return render(request, "accounts/login.html", {
"google_client_id": settings.GOOGLE_CLIENT_ID,
"gis_nonce": request.session["gis_nonce"],
})
@require_POST
def google_gis(request):
nonce = request.session.pop("gis_nonce", None)
try:
credential = json.loads(request.body)["credential"]
claims = verify_google_id_token(credential, nonce=nonce)
user = get_or_create_user_from_google(claims)
except (ValueError, KeyError, TypeError, InvalidIdToken):
return JsonResponse({"error": "invalid_credential"}, status=400)
except AccountLinkRequired:
return JsonResponse({"error": "link_required"}, status=409)
login(request, user, backend="django.contrib.auth.backends.ModelBackend")
return JsonResponse({"ok": True})
Bu yerda Django'ning CSRF himoyasi o'z joyida qoladi: fetch so'rovi X-CSRFToken header'ini yuboradi. GIS oqimi authentication uchun. Agar sizga foydalanuvchi nomidan Google API chaqirish kerak bo'lsa, GIS'da bu alohida, authorization qismi orqali qilinadi (google.accounts.oauth2) va u yana Authorization Code oqimiga olib keladi.
Scopes: kamroq so'rang
Login uchun openid email profile yetarli. Ortiqcha scope so'rash rozilik ekranini qo'rqinchli qiladi va konversiyani tushiradi. Agar keyinchalik, masalan, kalendarga kirish kerak bo'lsa, uni o'sha funksiya ishlatilganda alohida so'rang (incremental authorization; Google'da include_granted_scopes=true). Refresh token faqat access_type=offline so'ralganda beriladi — login uchun u kerak emas.
Yana bir nozik jihat: foydalanuvchi rozilik ekranida ba'zi ruxsatlarni olib tashlashi mumkin. Token javobidagi scope maydoni haqiqatan berilgan ruxsatlarni ko'rsatadi — kerakli scope u yerda borligini tekshiring.
Production'da uchraydigan xatolar
audtekshirilmaydi. Boshqa ilova uchun berilgan token sizda ham ishlaydi. Eng xavfli va eng ko'p uchraydigan xato.- Imzosiz "decode".
jwt.decode(token, options={"verify_signature": False})debug uchun qulay, lekin production'da u har qanday soxta token'ni qabul qiladi. algorithmsko'rsatilmaydi. Algoritm har doim kod tomonidan qat'iy belgilanishi kerak, token header'idan emas.- Email asosiy kalit sifatida. Email o'zgaradi,
subesa yo'q. email_verifiede'tiborsiz qoladi. Tasdiqlanmagan email — shunchaki matn.hdfaqat URL'da. Faqat korporativ Workspace domeni foydalanuvchilarini kiritmoqchi bo'lsangiz,hdparametrini so'rovga qo'shish yetarli emas — token'dagihdclaim'ni backend'da tekshiring.stateyo'q. Bu login CSRF'ga yo'l ochadi: hujumchi qurbonni o'z akkauntiga kiritib qo'yadi va qurbon kiritgan ma'lumotlar hujumchining akkauntida qoladi.redirect_urimos kelmaydi. Google aniq moslikni talab qiladi:httpvahttps, oxiridagi/, port — hammasi muhim. Reverse proxy ortidarequest.build_absolute_uri()http://qaytarishi mumkin, shuning uchun manzilni sozlamalardan oling.SESSION_COOKIE_SAMESITE = "Strict". Google'dan qaytish cross-site navigatsiya, Strict cookie esa bunda yuborilmaydi — session yo'qoladi va har safar "Invalid state" chiqadi. Django'ning standartLaxqiymati bu oqim bilan ishlaydi.- Callback'ni qayta ochish. Kod bir martalik; sahifa yangilansa, Google
invalid_grantqaytaradi. Session'danpopqilish bu holatni toza xatoga aylantiradi. - Token'lar log'da.
code,id_token,access_tokenni log'ga yozmang va URL'da uzatmang.
Amaliy checklist
- Authorization Code + PKCE (
S256), Implicit flow emas. - Har bir login uchun yangi
state,nonce,code_verifier; session'da saqlanadi va bir marta ishlatiladi. - ID token: imzo (JWKS,
kid),algorithms=["RS256"],aud,iss,exp,nonce. - Foydalanuvchi
(provider, sub)bo'yicha bog'lanadi;UniqueConstraintbor. email_verifiedtekshiriladi; mavjud akkauntga avtomatik bog'lash yo'q.redirect_urisozlamalardan olinadi va Console'dagi bilan aynan bir xil.- Minimal scope; qo'shimcha ruxsatlar kerak bo'lganda so'raladi.
- Login'dan keyin o'z session'ingiz; Google token'lari keraksiz bo'lsa, saqlanmaydi.
- Token'lar log'ga va URL'ga tushmaydi.
Xulosa
"Google orqali kirish" — bu ikki protokol: OAuth 2.0 kodni token'ga almashtirish mexanizmini beradi, OpenID Connect esa unga imzolangan ID token qo'shadi. Backend hech qachon mijozning so'ziga ishonmasligi kerak: imzo, aud, iss, exp va nonce tekshirilmagan token — shunchaki base64 matn. Foydalanuvchini sub bo'yicha bog'lang, PKCE va stateni tashlab ketmang — shunda login tugmasi saytingizdagi eng zaif joy bo'lmay qoladi.
// izohlar
Izohlar yuklanmoqda...