403 ketdi, teshik qoldi: CSRF va CORS farqi va nega ikkalasi kerak
CORS so'rovni to'xtatmaydi, faqat javobni skriptdan yashiradi. SameSite, CSRF token, Origin tekshiruvi va preflight qanday ishlaydi, Django'da CSRF_TRUSTED_ORIGINS va django-cors-headers'ni teshik ochmasdan qanday sozlash kerak.
Bitta forma, besh million so'm
Tasavvur qiling: foydalanuvchi internet-bankingga kirgan, brauzerda sessionid cookie'si saqlangan. Keyin u Telegram'dagi "yutuq" havolasini ochadi. Sahifa bo'sh ko'rinadi, lekin ichida mana shu forma bor:
<!-- https://evil.example/yutuq.html -->
<form id="f" action="https://bank.example.uz/transfer/" method="POST">
<input type="hidden" name="to" value="8600123412341234">
<input type="hidden" name="amount" value="5000000">
</form>
<script>document.getElementById("f").submit();</script>
Brauzer formani bank.example.uz ga yuboradi va cookie'ni o'zi qo'shib yuboradi. Server nuqtai nazaridan bu oddiy, autentifikatsiyadan o'tgan POST so'rov: sessiya to'g'ri, foydalanuvchi to'g'ri. Bu CSRF (Cross-Site Request Forgery, ya'ni saytlararo so'rovni soxtalashtirish). Hujumchi javobni ko'rmaydi ham, unga bu kerak emas: pul allaqachon o'tkazildi.
Endi ikkinchi holat. Frontend app.example.uz da, API api.example.uz da. Dasturchi fetch yozadi, konsolda qizil yozuv: "blocked by CORS policy". Uni tuzatgach, POST'da 403 chiqadi: "CSRF verification failed". Eng tez "yechim" doim bir xil: CORS_ALLOW_ALL_ORIGINS = True va view ustiga @csrf_exempt. Frontend ishlay boshlaydi. Yuqoridagi hujum esa endi butunlay ochiq.
Bu ikki mavzu doim aralashib ketadi, chunki ikkalasida ham "cross-origin" so'zi bor va ikkalasi ham brauzerda xato bilan namoyon bo'ladi. Aslida ular qarama-qarshi yo'nalishdagi muammolarni hal qiladi. Shu maqolada ularni bir-biridan ajratamiz va Django'da qanday qilib ikkalasini birga to'g'ri sozlashni ko'ramiz.
Nega sodda yondashuv buziladi
Ko'p uchraydigan noto'g'ri tasavvurlar:
- "Bizda CORS sozlangan, begona sayt so'rov yubora olmaydi." Yubora oladi. CORS javobni o'qishni cheklaydi, so'rov yuborishni emas. Yuqoridagi HTML forma umuman CORS'ga bo'ysunmaydi: formalar boshqa saytlarga CORS paydo bo'lishidan ancha oldin ham yuborilgan.
- "API faqat JSON qabul qiladi, demak xavfsiz." Bu faqat server haqiqatan
Content-Type: application/jsonni talab qilsa va qolganini rad etsa to'g'ri. Agar viewrequest.POSTdan ham o'qisa yoki body'ni content-type'ga qaramay parse qilsa, oddiy forma yetarli. - "Biz POST ishlatamiz, GET emas." Yaxshi, lekin ko'p loyihada "qulaylik uchun"
request.GETham qabul qilinadi. - "Endpoint login talab qiladi." Aynan shuning uchun CSRF ishlaydi: hujum foydalanuvchining login qilingan sessiyasidan foydalanadi.
Barcha xatolar bitta view'da:
# views.py: DON'T do this
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from .services import transfer_money
@csrf_exempt # "the frontend kept getting 403, so..."
@login_required
def transfer(request):
# Also bad: GET is accepted too, so SameSite=Lax will not save us
data = request.POST or request.GET
transfer_money(request.user, data["to"], int(data["amount"]))
return JsonResponse({"ok": True})
CSRF: brauzer nimani o'zi yuboradi
CSRF'ning ildizi bitta: brauzer cookie'ni so'rov qaysi sahifadan boshlanganiga emas, qaysi domenga ketayotganiga qarab qo'shadi (hech bo'lmaganda tarixan shunday edi, SameSite buni qisman o'zgartirdi). Server faqat cookie'ga qarab "buni foydalanuvchi o'zi bosdi" degan xulosaga kelsa, aldanadi. Barcha himoya choralari bitta savolga javob beradi: bu so'rovni haqiqatan bizning sahifamiz yubordimi?
SameSite cookie
SameSite atributi brauzerga cookie'ni saytlararo so'rovlarda yuborish yoki yubormaslikni aytadi:
| Qiymat | Saytlararo so'rovda cookie | Izoh |
|---|---|---|
Strict |
Yuborilmaydi | Boshqa saytdagi havoladan kirilganda ham foydalanuvchi "login qilmagan" bo'lib ko'rinadi |
Lax |
Faqat yuqori darajadagi GET navigatsiyada (havolani bosish) | Django'da standart qiymat; POST forma, fetch, <img> uchun yuborilmaydi |
None |
Har doim | Secure majburiy, aks holda brauzer cookie'ni qabul qilmaydi |
Atribut ko'rsatilmasa, Chromium asosidagi brauzerlar cookie'ni Lax deb hisoblaydi, lekin bunga hamma brauzerda tayanib bo'lmaydi. Django SESSION_COOKIE_SAMESITE va CSRF_COOKIE_SAMESITE ni standart holatda "Lax" qilib qo'yadi.
Bu yerda ikki nozik joy bor. Birinchisi: Lax GET navigatsiyani o'tkazib yuboradi, shuning uchun holatni o'zgartiradigan GET endpoint baribir himoyasiz qoladi. Ikkinchisi: "site" va "origin" bir narsa emas. Site — bu sxema va ro'yxatdan o'tkaziladigan domen (example.uz), demak blog.example.uz va api.example.uz bitta site hisoblanadi. Biror subdomenda XSS yoki boshqa birov boshqaradigan kontent bo'lsa, SameSite u yerdan keladigan so'rovlarni to'xtatmaydi.
SameSite yaxshi qo'shimcha qatlam, lekin yagona himoya emas. Django'ning CSRF tekshiruvi uning ustida ishlashi kerak.
CSRF token
Klassik himoya: server sahifaga oldindan bilib bo'lmaydigan token joylaydi va har bir POST'da shu tokenni talab qiladi. Begona sayt cookie'ni yubora oladi, lekin uni o'qiy olmaydi (same-origin policy), demak tokenni o'z formasiga qo'ya olmaydi.
Django'da bu "double submit" ko'rinishida ishlaydi. csrftoken cookie'sida maxfiy qiymat (secret) saqlanadi, sahifaga esa ({% csrf_token %} yoki get_token() orqali) shu qiymatning har safar boshqacha niqoblangan (masked) varianti chiqadi. Niqoblash BREACH turidagi hujumlardan himoya qiladi: token har bir javobda boshqacha ko'rinadi. So'rov kelganda middleware formadagi csrfmiddlewaretoken maydonini yoki X-CSRFToken header'ni oladi, niqobni yechadi va cookie'dagi qiymat bilan solishtiradi.
Origin tekshiruvi
Django 4.0 dan beri CsrfViewMiddleware avval Origin header'ni tekshiradi. Brauzer bu header'ni sahifadagi JavaScript orqali o'zgartirishga yo'l qo'ymaydi, shuning uchun u "so'rov qayerdan kelgan" degan savolga ishonchli javob beradi. Soddalashtirilgan mantiq:
# Simplified logic of CsrfViewMiddleware.process_view (not the real source)
SAFE_METHODS = ("GET", "HEAD", "OPTIONS", "TRACE")
def csrf_check(request):
if request.method in SAFE_METHODS:
return True
origin = request.META.get("HTTP_ORIGIN")
if origin is not None:
# must equal scheme://request.get_host() or match CSRF_TRUSTED_ORIGINS
if not origin_is_trusted(origin, request):
return False # 403: "Origin checking failed"
elif request.is_secure():
# HTTPS without Origin: Referer becomes mandatory and is checked strictly
if not referer_is_trusted(request):
return False
secret = read_csrf_cookie(request) # the csrftoken cookie
token = (
request.POST.get("csrfmiddlewaretoken")
or request.META.get("HTTP_X_CSRFTOKEN")
)
return tokens_match(secret, token) # unmask + constant-time compare
E'tibor bering: Origin scheme://host ko'rinishida solishtiriladi. Sahifa https://app.example.uz da, API esa https://api.example.uz da bo'lsa, origin host'ga mos kelmaydi va CSRF_TRUSTED_ORIGINS kerak bo'ladi.
To'g'rilangan view hech qanday maxsus kod talab qilmaydi: middleware standart holatda yoqilgan, biz uni o'chirmaymiz va GET'ni yopamiz, xolos:
# views.py
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse
from django.views.decorators.http import require_POST
from .forms import TransferForm
from .services import transfer_money
@login_required
@require_POST # state changes only via POST; GET gets 405
def transfer(request):
form = TransferForm(request.POST)
if not form.is_valid():
return JsonResponse({"errors": form.errors}, status=400)
transfer_money(
request.user,
form.cleaned_data["to"],
form.cleaned_data["amount"],
)
return JsonResponse({"ok": True})
CORS aslida nima
Endi teskari yo'nalish. Brauzerda same-origin policy bor: evil.example dagi skript api.example.uz ga so'rov yuborishi mumkin, lekin javobni o'qiy olmaydi. CORS (Cross-Origin Resource Sharing) — server brauzerga "bu origin mening javobimni o'qisa bo'ladi" deb ruxsat beradigan mexanizm. Ya'ni CORS cheklov emas, balki mavjud cheklovni yumshatish.
Bundan asosiy xulosa kelib chiqadi: CORS server himoyasi emas, brauzer siyosati. U foydalanuvchini begona saytlardan himoya qiladi, serveringizni esa hech kimdan himoya qilmaydi. curl, Postman yoki boshqa backend uchun CORS degan narsa yo'q:
# No browser here, so no CORS. The request reaches Django as usual.
curl -sS -i -X POST https://api.example.uz/api/transfer/ \
-H 'Origin: https://evil.example' \
-H 'Content-Type: application/json' \
-d '{"to": "8600123412341234", "amount": 5000000}'
# Whatever stops it (403/401) comes from CSRF or auth, not from CORS.
Simple request va preflight
Brauzer cross-origin so'rovlarni ikki turga ajratadi. "Simple" so'rov — bu GET, HEAD yoki POST, faqat oddiy header'lar bilan va Content-Type application/x-www-form-urlencoded, multipart/form-data yoki text/plain bo'lgan holat. Bunday so'rov darhol yuboriladi, server uni bajaradi, keyin esa javobda Access-Control-Allow-Origin bo'lmasa, brauzer javobni skriptdan yashiradi. Pul o'tkazmasi esa allaqachon bajarilgan bo'ladi.
Qolgan hamma so'rovlar (PUT, DELETE, application/json, X-CSRFToken kabi o'zimizning header'lar) uchun brauzer avval OPTIONS preflight so'rovini yuboradi va server ruxsat bersagina asl so'rovni jo'natadi:
// 1) "Simple" request: no preflight, the server EXECUTES it,
// the browser only hides the response from this script.
fetch("https://api.example.uz/api/transfer/", {
method: "POST",
credentials: "include",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: "to=8600123412341234&amount=5000000",
});
// 2) JSON + custom header: the browser sends OPTIONS first,
// and the real POST only goes out if the server allows it.
fetch("https://api.example.uz/api/transfer/", {
method: "POST",
credentials: "include",
headers: { "Content-Type": "application/json", "X-CSRFToken": "..." },
body: JSON.stringify({ to: "8600123412341234", amount: 5000000 }),
});
Preflight almashinuvi taxminan shunday ko'rinadi (django-cors-headers javobi):
OPTIONS /api/transfer/ HTTP/1.1
Host: api.example.uz
Origin: https://app.example.uz
Access-Control-Request-Method: POST
Access-Control-Request-Headers: content-type, x-csrftoken
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://app.example.uz
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: DELETE, GET, OPTIONS, PATCH, POST, PUT
Access-Control-Allow-Headers: accept, authorization, content-type, user-agent, x-csrftoken, x-requested-with
Access-Control-Max-Age: 86400
Vary: origin
Access-Control-Max-Age brauzerga preflight natijasini qancha vaqt keshlashni aytadi. Brauzerlarning o'z yuqori chegarasi bor, shuning uchun juda katta qiymat to'liq hurmat qilinmasligi mumkin.
Credentials bilan CORS
Standart holatda cross-origin fetch cookie yubormaydi. credentials: "include" bilan yuboradi, lekin skript javobni o'qishi uchun server ikki shartni bajarishi kerak: Access-Control-Allow-Credentials: true va Access-Control-Allow-Origin da * emas, aniq origin. Credentials bilan Allow-Headers va Allow-Methods dagi * ham wildcard sifatida ishlamaydi.
Eng xavfli xato aynan shu yerda tug'iladi: * ishlamagani uchun dasturchi kelgan Origin ni shunchaki qaytarib yuboradi:
# middleware.py: DON'T do this
class AllowEverythingCorsMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
response = self.get_response(request)
origin = request.headers.get("Origin")
if origin:
# reflects ANY site and allows cookies: evil.example can now
# read /api/me/, card lists, balances of a logged-in user
response["Access-Control-Allow-Origin"] = origin
response["Access-Control-Allow-Credentials"] = "true"
return response
Bu CSRF'dan ham yomonroq bo'lishi mumkin. CSRF'da hujumchi "ko'r-ko'rona" so'rov yuboradi, bu yerda esa u foydalanuvchining ma'lumotlarini o'qiy oladi, jumladan javobdagi CSRF tokenni ham. Demak, noto'g'ri sozlangan CORS CSRF himoyasini ham yo'qqa chiqaradi.
Django'da to'g'ri sozlash
Tipik arxitektura: SPA app.example.uz da, Django API api.example.uz da, autentifikatsiya session cookie orqali. Bu yerda ikkala mexanizm ham kerak: CORS — SPA javoblarni o'qiy olishi uchun, CSRF — boshqa hech kim foydalanuvchi nomidan so'rov yubora olmasligi uchun.
# settings.py (pip install django-cors-headers)
INSTALLED_APPS = [
# ...
"corsheaders",
]
MIDDLEWARE = [
"django.middleware.security.SecurityMiddleware",
"corsheaders.middleware.CorsMiddleware", # as high as possible, before CommonMiddleware
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
]
# CORS: who may READ our responses from JavaScript
CORS_ALLOWED_ORIGINS = [
"https://app.example.uz",
"https://admin.example.uz",
]
CORS_ALLOW_CREDENTIALS = True
CORS_URLS_REGEX = r"^/api/.*$"
# CSRF: whose state-changing requests we accept (scheme is required)
CSRF_TRUSTED_ORIGINS = [
"https://app.example.uz",
"https://admin.example.uz",
]
CSRF_COOKIE_DOMAIN = ".example.uz" # so JS on app.example.uz can read csrftoken
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SESSION_COOKIE_SAMESITE = "Lax" # Django's default, written out on purpose
CSRF_COOKIE_SAMESITE = "Lax"
# Only if your reverse proxy always sets/overwrites this header
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
CSRF_TRUSTED_ORIGINS Django 4.0 dan beri sxemani talab qiladi (https://...), subdomenlar uchun https://*.example.uz ko'rinishi ham qo'llab-quvvatlanadi. CSRF_COOKIE_DOMAIN esa shuning uchun kerakki, api.example.uz o'rnatgan cookie'ni app.example.uz dagi JavaScript o'qiy olmaydi.
SPA ishga tushganda CSRF cookie'sini olish uchun bitta endpoint yetarli:
# views.py
from django.http import JsonResponse
from django.views.decorators.csrf import ensure_csrf_cookie
from django.views.decorators.http import require_GET
@require_GET
@ensure_csrf_cookie
def csrf_bootstrap(request):
# The SPA calls this once on startup; Django sets the csrftoken cookie.
return JsonResponse({"detail": "ok"})
Frontend tomoni:
function getCookie(name) {
const m = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
return m ? decodeURIComponent(m[1]) : null;
}
await fetch("https://api.example.uz/api/csrf/", { credentials: "include" });
const res = await fetch("https://api.example.uz/api/transfer/", {
method: "POST",
credentials: "include",
headers: {
"Content-Type": "application/json",
"X-CSRFToken": getCookie("csrftoken"),
},
body: JSON.stringify({ to: "8600123412341234", amount: 50000 }),
});
DRF ishlatsangiz, SessionAuthentication login qilgan foydalanuvchi uchun CSRF'ni o'zi tekshiradi. Authorization: Bearer header orqali ishlaydigan token yoki JWT autentifikatsiyasiga CSRF kerak emas, chunki brauzer bu header'ni o'zi qo'shmaydi. Lekin JWT'ni cookie'da saqlasangiz, CSRF muammosi qaytib keladi.
# settings.py
REST_FRAMEWORK = {
"DEFAULT_AUTHENTICATION_CLASSES": [
# cookie-based: DRF enforces CSRF for session-authenticated users
"rest_framework.authentication.SessionAuthentication",
# header-based (Authorization: Bearer ...): browser never adds it on its own
"rest_framework_simplejwt.authentication.JWTAuthentication",
],
}
Production'da uchraydigan tuzoqlar
- Proxy ortida "Origin checking failed". Nginx TLS'ni o'zida tugatadi va so'rovni Django'ga HTTP orqali uzatadi.
request.is_secure()Falseqaytaradi, Djangohttp://api.example.uzni kutadi, brauzer esahttps://...yuboradi. Yechim —SECURE_PROXY_SSL_HEADER, lekin faqat proxy bu header'ni har doim o'zi qo'yadigan yoki ustidan yozadigan bo'lsa. Host ham o'zgartirilsa,USE_X_FORWARDED_HOSTkerak bo'lishi mumkin. CORS_ALLOW_ALL_ORIGINS = TruevaCORS_ALLOW_CREDENTIALS = Truebirga. Credentials bilan*mumkin emasligi uchun django-cors-headers bu holatda so'rovdagi origin'ni qaytaradi. Natijada yuqoridagi "hammaga ruxsat" middleware'ning aynan o'zi hosil bo'ladi.- Anchor'siz regex.
CORS_ALLOWED_ORIGIN_REGEXESdagir"https://.*example\.uz"https://example.uz.evil.comvahttps://notexample.uzga ham mos keladi.^va$bilan yozing, nuqtalarni escape qiling. nullorigin. Sandbox iframe,file://sahifalar va ba'zi redirect'larOrigin: nullyuboradi. Uni hech qachon ruxsat etilganlar ro'yxatiga qo'shmang.- Middleware tartibi.
CorsMiddlewareCommonMiddlewaredan pastda tursa, undan yuqoridagi middleware'lar yaratgan javoblar (masalan,APPEND_SLASHredirect'i) CORS header'larisiz qaytadi. Preflight esa redirect'ga umuman ergashmaydi. - "CORS error" asl xatoni yashiradi. 500 yoki 404 javobida CORS header'lari bo'lmasa, konsolda faqat CORS xatosi ko'rinadi. Asl status kodni Network tab'dan qidiring.
- Kesh va
Vary: Origin.Access-Control-Allow-Originorigin'ga qarab qaytarilsa-yu, CDN yoki proxy javobniVary: Originsiz keshlasa, bir origin uchun header boshqasiga berilib yuborilishi mumkin. - Webhook'lar. Click, Payme kabi to'lov tizimlarining callback'lari server-server so'rovlar, ularda cookie yo'q, shuning uchun bu yerda
@csrf_exemptto'g'ri. Lekin uning o'rniga imzo yoki secret tekshiruvi albatta bo'lishi kerak. CSRF_COOKIE_HTTPONLY = True. Django hujjatlarida aytilganidek, bu amalda deyarli foyda bermaydi: token baribir sahifada bo'ladi, faqat JavaScript uni cookie'dan emas, DOM'dan olishiga to'g'ri keladi.- Login CSRF. Login formasi ham himoyalangan bo'lishi kerak. Aks holda hujumchi foydalanuvchini o'zining akkauntiga kiritib qo'yadi va foydalanuvchi kiritgan karta ma'lumotlari hujumchi akkauntida qoladi. Django'ning
LoginViewi bu himoyaga standart holatda ega.
Tekshiruv ro'yxati
- Holatni o'zgartiradigan hamma narsa faqat POST/PUT/PATCH/DELETE orqali; GET hech narsani o'zgartirmaydi.
CsrfViewMiddlewareyoqilgan,@csrf_exemptfaqat imzosi tekshiriladigan webhook'larda.- Session va CSRF cookie'lari
SecurevaSameSite=Lax(yokiStrict). CSRF_TRUSTED_ORIGINSda sxemasi bilan yozilgan aniq origin'lar.CORS_ALLOWED_ORIGINSaniq ro'yxat; credentials bilan hech qachonCORS_ALLOW_ALL_ORIGINSemas.CorsMiddlewarero'yxatda iloji boricha yuqorida,CORS_URLS_REGEXfaqat API'ni qamraydi.- Proxy ortida
SECURE_PROXY_SSL_HEADERto'g'ri sozlangan. - Bearer token'li API'ga CSRF kerak emas, cookie'li API'ga kerak.
- Sinab ko'ring: boshqa domendagi oddiy HTML forma bilan endpoint'ga POST yuboring va 403 qaytishiga ishonch hosil qiling.
Xulosa
CSRF va CORS bir-birining o'rnini bosmaydi. CSRF himoyasi serverni foydalanuvchi nomidan yuborilgan begona so'rovlardan himoya qiladi, CORS esa brauzerga javobingizni qaysi saytlar o'qishi mumkinligini aytadi. 403'dan qutulish uchun CSRF'ni o'chirish yoki har qanday origin'ga ruxsat berish xatoni tuzatish emas, teshik ochishdir. To'g'ri yo'l — aniq origin'lar ro'yxati, SameSite cookie'lar va Django middleware'ini o'z holicha qoldirish.
// izohlar
Izohlar yuklanmoqda...