Все заметки
Программирование

403 исчез, дыра осталась: чем CSRF отличается от CORS и зачем нужны оба

CORS не останавливает запрос, он лишь прячет ответ от скрипта. Как работают SameSite, CSRF-токен, проверка Origin и preflight и как настроить CSRF_TRUSTED_ORIGINS и django-cors-headers в Django, не открыв дыру.

Одна форма, пять миллионов сумов

Представьте: пользователь залогинен в интернет-банке, в браузере лежит cookie sessionid. Потом он открывает ссылку «вы выиграли приз» из Telegram. Страница выглядит пустой, но внутри вот такая форма:

<!-- 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>

Браузер отправляет форму на bank.example.uz и сам прикладывает cookie. С точки зрения сервера это обычный аутентифицированный POST: сессия правильная, пользователь правильный. Это и есть CSRF (Cross-Site Request Forgery, межсайтовая подделка запроса). Атакующий даже не видит ответа, и ему это не нужно: деньги уже ушли.

Теперь вторая ситуация. Фронтенд на app.example.uz, API на api.example.uz. Разработчик пишет fetch, в консоли красное: «blocked by CORS policy». Когда это починили, POST начинает отдавать 403: «CSRF verification failed». Самое быстрое «решение» всегда одно и то же: CORS_ALLOW_ALL_ORIGINS = True и @csrf_exempt над view. Фронтенд заработал. А атака выше теперь полностью открыта.

Эти две темы постоянно путают: в обеих есть слово «cross-origin», и обе проявляются как ошибка в браузере. На деле они решают задачи, направленные в противоположные стороны. В этой статье разведём их и посмотрим, как правильно настроить обе в Django.

Почему наивный подход ломается

Типичные заблуждения:

  • «У нас настроен CORS, чужой сайт не может отправить запрос». Может. CORS ограничивает чтение ответа, а не отправку запроса. HTML-форма выше вообще не подчиняется CORS: формы отправлялись на чужие сайты задолго до появления CORS.
  • «API принимает только JSON, значит, безопасно». Только если сервер действительно требует Content-Type: application/json и отвергает всё остальное. Если view читает и request.POST или парсит тело независимо от content-type, хватит обычной формы.
  • «Мы используем POST, а не GET». Хорошо, но во многих проектах «для удобства» принимается и request.GET.
  • «Эндпоинт требует логина». Именно поэтому CSRF и работает: атака использует уже залогиненную сессию пользователя.

Все ошибки в одном view:

# 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: что браузер отправляет сам

У CSRF один корень: браузер прикладывает cookie, ориентируясь на домен, куда идёт запрос, а не на страницу, откуда он начат (по крайней мере исторически было так, SameSite это частично изменил). Если сервер по одной лишь cookie делает вывод «это нажал сам пользователь», его обманывают. Все механизмы защиты отвечают на один вопрос: действительно ли этот запрос отправила наша страница?

Атрибут SameSite говорит браузеру, отправлять ли cookie в межсайтовых запросах:

Значение Cookie в межсайтовом запросе Комментарий
Strict Не отправляется Даже при переходе по ссылке с другого сайта пользователь выглядит «незалогиненным»
Lax Только при навигации верхнего уровня методом GET (клик по ссылке) Значение по умолчанию в Django; для POST-формы, fetch, <img> не отправляется
None Всегда Обязателен Secure, иначе браузер отвергнет cookie

Если атрибут не указан, браузеры на Chromium считают cookie Lax, но полагаться на это во всех браузерах нельзя. Django по умолчанию выставляет SESSION_COOKIE_SAMESITE и CSRF_COOKIE_SAMESITE в "Lax".

Здесь две тонкости. Первая: Lax пропускает GET-навигацию, поэтому GET-эндпоинт, меняющий состояние, остаётся беззащитным. Вторая: «site» и «origin» — не одно и то же. Site — это схема плюс регистрируемый домен (example.uz), так что blog.example.uz и api.example.uz — один и тот же site. Если на каком-то поддомене есть XSS или контент, который контролирует кто-то другой, SameSite запросы оттуда не остановит.

SameSite — хороший дополнительный слой, но не единственная защита. Проверка CSRF в Django должна работать поверх него.

CSRF-токен

Классическая защита: сервер кладёт на страницу непредсказуемый токен и требует его в каждом POST. Чужой сайт может отправить cookie, но не может её прочитать (same-origin policy), а значит, не может вставить токен в свою форму.

В Django это работает по схеме «double submit». В cookie csrftoken хранится секрет, а на страницу (через {% csrf_token %} или get_token()) выводится каждый раз по-новому замаскированная (masked) версия этого секрета. Маскирование защищает от атак класса BREACH: токен выглядит по-разному в каждом ответе. Когда приходит запрос, middleware берёт поле csrfmiddlewaretoken из формы или заголовок X-CSRFToken, снимает маску и сравнивает с секретом из cookie.

Проверка Origin

Начиная с Django 4.0 CsrfViewMiddleware сначала проверяет заголовок Origin. Браузер не даёт JavaScript на странице его подменить, поэтому это надёжный ответ на вопрос «откуда пришёл запрос». Упрощённая логика:

# 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

Обратите внимание: Origin сравнивается в виде scheme://host. Если страница на https://app.example.uz, а API на https://api.example.uz, origin не совпадёт с host, и понадобится CSRF_TRUSTED_ORIGINS.

Исправленный view не требует никакого специального кода: middleware включён по умолчанию, мы просто не выключаем его и закрываем GET:

# 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 на самом деле

Теперь обратное направление. В браузере действует same-origin policy: скрипт на evil.example может отправить запрос на api.example.uz, но не может прочитать ответ. CORS (Cross-Origin Resource Sharing) — механизм, которым сервер говорит браузеру «этому origin можно читать мои ответы». То есть CORS — не ограничение, а ослабление уже существующего ограничения.

Отсюда главный вывод: CORS — это политика браузера, а не защита сервера. Он защищает пользователя от чужих сайтов, но ваш сервер не защищает ни от кого. Для curl, Postman или другого бэкенда никакого CORS не существует:

# 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 и preflight

Браузер делит cross-origin запросы на два вида. «Simple» запрос — это GET, HEAD или POST только с простыми заголовками и Content-Type одним из application/x-www-form-urlencoded, multipart/form-data или text/plain. Такой запрос отправляется сразу, сервер его выполняет, и только потом, если в ответе нет Access-Control-Allow-Origin, браузер прячет ответ от скрипта. Перевод денег к этому моменту уже выполнен.

Для всего остального (PUT, DELETE, application/json, собственные заголовки вроде X-CSRFToken) браузер сначала отправляет OPTIONS preflight и шлёт настоящий запрос, только если сервер разрешил:

// 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 выглядит примерно так (ответ django-cors-headers):

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 говорит браузеру, сколько кешировать результат preflight. У браузеров есть собственный верхний предел, поэтому очень большое значение может быть урезано.

CORS с credentials

По умолчанию cross-origin fetch не отправляет cookie. С credentials: "include" отправляет, но чтобы скрипт смог прочитать ответ, сервер должен выполнить два условия: Access-Control-Allow-Credentials: true и конкретный origin в Access-Control-Allow-Origin, а не *. С credentials * в Allow-Headers и Allow-Methods тоже не работает как wildcard.

Именно здесь рождается самая опасная ошибка: раз * не работает, разработчик просто отражает пришедший Origin:

# 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

Это может быть хуже CSRF. При CSRF атакующий шлёт запрос «вслепую», а здесь он может читать данные пользователя, включая CSRF-токен из ответа. То есть неправильно настроенный CORS заодно обнуляет и CSRF-защиту.

Правильная настройка в Django

Типичная архитектура: SPA на app.example.uz, Django API на api.example.uz, аутентификация через session cookie. Здесь нужны оба механизма: CORS — чтобы SPA могло читать ответы, CSRF — чтобы никто другой не мог слать запросы от имени пользователя.

# 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")

С Django 4.0 CSRF_TRUSTED_ORIGINS требует схему (https://...), поддерживается и вид https://*.example.uz для поддоменов. CSRF_COOKIE_DOMAIN нужен потому, что cookie, выставленную api.example.uz, JavaScript на app.example.uz прочитать не сможет.

Чтобы SPA при старте получило CSRF-cookie, достаточно одного эндпоинта:

# 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"})

Сторона фронтенда:

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, SessionAuthentication сам проверяет CSRF для залогиненного пользователя. Аутентификации токеном или JWT через заголовок Authorization: Bearer CSRF не нужен: браузер сам этот заголовок не добавляет. Но если хранить JWT в cookie, проблема CSRF возвращается.

# 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",
    ],
}

Подводные камни в продакшене

  • «Origin checking failed» за прокси. Nginx терминирует TLS и проксирует запрос в Django по HTTP. request.is_secure() возвращает False, Django ждёт http://api.example.uz, а браузер шлёт https://.... Решение — SECURE_PROXY_SSL_HEADER, но только если прокси всегда сам выставляет или перезаписывает этот заголовок. Если подменяется и Host, может понадобиться USE_X_FORWARDED_HOST.
  • CORS_ALLOW_ALL_ORIGINS = True вместе с CORS_ALLOW_CREDENTIALS = True. Поскольку * с credentials нельзя, django-cors-headers в этом случае отражает origin из запроса. Получается ровно тот «разрешить всем» middleware, что выше.
  • Regex без якорей. r"https://.*example\.uz" в CORS_ALLOWED_ORIGIN_REGEXES совпадёт и с https://example.uz.evil.com, и с https://notexample.uz. Пишите с ^ и $, экранируйте точки.
  • Origin null. Sandbox-iframe, страницы file:// и некоторые редиректы отправляют Origin: null. Никогда не добавляйте его в список разрешённых.
  • Порядок middleware. Если CorsMiddleware стоит ниже CommonMiddleware, ответы, созданные middleware выше него (например, редирект APPEND_SLASH), уйдут без CORS-заголовков. А preflight по редиректам вообще не ходит.
  • «CORS error» прячет настоящую ошибку. Если в ответе 500 или 404 нет CORS-заголовков, в консоли видна только ошибка CORS. Настоящий статус ищите во вкладке Network.
  • Кеш и Vary: Origin. Если Access-Control-Allow-Origin зависит от origin, а CDN или прокси кеширует ответ без Vary: Origin, заголовок для одного origin может достаться другому.
  • Вебхуки. Callback'и платёжных систем вроде Click и Payme — это запросы сервер-сервер без cookie, поэтому @csrf_exempt здесь уместен. Но вместо него обязательно должна быть проверка подписи или секрета.
  • CSRF_COOKIE_HTTPONLY = True. Как сказано в документации Django, практической пользы от этого почти нет: токен всё равно будет на странице, просто JavaScript придётся брать его из DOM, а не из cookie.
  • Login CSRF. Форма логина тоже должна быть защищена. Иначе атакующий залогинит пользователя в свой аккаунт, и введённые пользователем данные карты останутся у атакующего. LoginView в Django защищён по умолчанию.

Чеклист

  • Всё, что меняет состояние, — только через POST/PUT/PATCH/DELETE; GET ничего не меняет.
  • CsrfViewMiddleware включён, @csrf_exempt — только на вебхуках с проверкой подписи.
  • Session- и CSRF-cookie с Secure и SameSite=Lax (или Strict).
  • В CSRF_TRUSTED_ORIGINS — конкретные origin'ы со схемой.
  • CORS_ALLOWED_ORIGINS — явный список; с credentials никогда не CORS_ALLOW_ALL_ORIGINS.
  • CorsMiddleware как можно выше в списке, CORS_URLS_REGEX покрывает только API.
  • За прокси правильно настроен SECURE_PROXY_SSL_HEADER.
  • API с Bearer-токеном CSRF не нужен, API на cookie — нужен.
  • Проверьте руками: отправьте POST на эндпоинт обычной HTML-формой с другого домена и убедитесь, что получаете 403.

Итог

CSRF и CORS не заменяют друг друга. Защита от CSRF оберегает сервер от чужих запросов, отправленных от имени пользователя, а CORS сообщает браузеру, каким сайтам можно читать ваши ответы. Выключить CSRF или разрешить любой origin, чтобы избавиться от 403, — это не исправление ошибки, а открытая дыра. Правильный путь — явный список origin'ов, SameSite-cookie и middleware Django, оставленный в покое.

// комментарии

Загружаем комментарии...

    // следующий шаг

    Давайте построим что-нибудь вместе.

    Написать в Telegram
    aslbek@asldev: ~
    ❯