Barcha yozuvlar
Dasturlash

'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:

  1. Ilova tayyorlanadi. Backend uchta tasodifiy qiymat yaratadi: state (CSRF'dan himoya), nonce (ID token'ni qayta ishlatishdan himoya) va code_verifier (PKCE siri). Hammasini session'ga saqlaydi.
  2. Brauzer Google'ga yo'naltiriladi. URL'da client_id, redirect_uri, scope, state, nonce va code_challenge = BASE64URL(SHA256(code_verifier)) bor. Verifier'ning o'zi hech qachon brauzerga chiqmaydi.
  3. Foydalanuvchi Google'da kiradi va rozilik beradi. Parolni siz ko'rmaysiz — bu OIDC'ning asosiy afzalligi.
  4. Google brauzerni redirect_uri?code=...&state=... ga qaytaradi. code — qisqa umrli, bir martalik kod. U hali token emas.
  5. Backend stateni tekshiradi va kodni server-server kanali orqali token endpoint'ga yuboradi: code, client_secret va code_verifier bilan.
  6. Google SHA256(code_verifier) ni avval olingan code_challenge bilan solishtiradi. Mos kelsa, access_token, id_token, expires_in, scope qaytaradi.
  7. Backend ID token'ni tekshiradi, foydalanuvchini sub bo'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_uri manzilida JWK to'plami sifatida e'lon qilinadi, kerakli kalit header'dagi kid orqali tanlanadi. Algoritmni token header'idan emas, o'z kodingizdan oling.
  • aud sizning client_idingizga teng bo'lishi shart. Yuqoridagi "bepul test" hujumiga qarshi aynan shu himoya qiladi.
  • iss — Google uchun https://accounts.google.com yoki accounts.google.com.
  • exp — muddati o'tmagan bo'lishi kerak. Server soatlari biroz farq qilishi mumkin, shuning uchun bir necha soniyalik leeway qo'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

  • aud tekshirilmaydi. 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.
  • algorithms ko'rsatilmaydi. Algoritm har doim kod tomonidan qat'iy belgilanishi kerak, token header'idan emas.
  • Email asosiy kalit sifatida. Email o'zgaradi, sub esa yo'q.
  • email_verified e'tiborsiz qoladi. Tasdiqlanmagan email — shunchaki matn.
  • hd faqat URL'da. Faqat korporativ Workspace domeni foydalanuvchilarini kiritmoqchi bo'lsangiz, hd parametrini so'rovga qo'shish yetarli emas — token'dagi hd claim'ni backend'da tekshiring.
  • state yo'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_uri mos kelmaydi. Google aniq moslikni talab qiladi: http va https, oxiridagi /, port — hammasi muhim. Reverse proxy ortida request.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 standart Lax qiymati bu oqim bilan ishlaydi.
  • Callback'ni qayta ochish. Kod bir martalik; sahifa yangilansa, Google invalid_grant qaytaradi. Session'dan pop qilish 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; UniqueConstraint bor.
  • email_verified tekshiriladi; mavjud akkauntga avtomatik bog'lash yo'q.
  • redirect_uri sozlamalardan 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...

    // keyingi qadam

    Keling, birga nimadir quramiz.

    Telegramda yozish
    aslbek@asldev: ~
    ❯