Trung bình Bảo Mật

Chống CSRF cho đúng: synchronizer token, cookie SameSite, double-submit và SPA trong Laravel

CSRF khiến browser đã đăng nhập gửi request mà user không hề muốn. Cách tấn công, vì sao cần cả token lẫn SameSite, và cấu hình cho SPA trong Laravel.

19 Th11, 2026 13 phút Cập nhật 23 Th10, 2026 7 Khối code
Sơ đồ
sequenceDiagram participant U as Browser của user participant E as evil.example participant S as shop.example.com U->>S: Đăng nhập, nhận session cookie U->>E: Mở trang của kẻ tấn công E-->>U: Form ẩn tự submit U->>S: POST đổi email, cookie được gắn kèm S->>S: So CSRF token với session S-->>U: 419 thiếu token, không đổi gì hết

User đang đăng nhập shop của mình ở một tab. Qua tab khác, họ mở một link trên forum: một trang toàn hình mèo. Giấu trong trang đó là một form post tới https://shop.example.com/account/email, tự submit khi trang load xong. Browser ngoan ngoãn gắn session cookie của user vô, controller của mình thấy một request đã xác thực, và email tài khoản giờ là của kẻ tấn công. Thêm một lần "quên mật khẩu" là mất tài khoản. Không ai đánh cắp cookie hay mật khẩu gì hết. Kẻ tấn công chỉ khiến browser của nạn nhân gửi một request mà nó vốn đã được phép gửi.

Đó là Cross-Site Request Forgery. Nó cũ, được hiểu rất rõ, và mấy framework như Laravel chặn sẵn từ mặc định, mà chính vì vậy các team hay làm hỏng nó mà không hay: một route bị thêm vô danh sách except "tạm thời", một SPA dời qua subdomain khác, một endpoint GET mà lại đổi trạng thái. Bài này đi qua cách tấn công hoạt động, từng lớp phòng thủ thật sự làm gì, và cách giữ cho bảo vệ của Laravel còn nguyên trong mấy setup SPA.

Cách tấn công hoạt động

CSRF dựa trên ba sự thật:

  1. Browser gắn cookie vô request dựa theo nơi đến, không quan tâm site nào khởi tạo request (trừ khi có SameSite, nói ở dưới).
  2. Server xác thực request chỉ bằng cái cookie đó.
  3. Kẻ tấn công đoán được mọi tham số của request. Chẳng có gì bí mật trong "POST email=x tới /account/email".
<!-- https://evil.example/cute-cats.html -->
<form id="f" action="https://shop.example.com/account/email" method="POST">
  <input type="hidden" name="email" value="[email protected]">
</form>
<script>document.getElementById('f').submit();</script>

Để ý cái kẻ tấn công không làm được: đọc response. Same-origin policy chặn chuyện đó. CSRF là kiểu tấn công mù, chỉ ghi, nên nó nhắm vô mấy thao tác đổi trạng thái: đổi email, chuyển tiền, thêm admin, xóa dữ liệu. Điều đó cũng có nghĩa CORS không giúp gì: một form POST với content type của form là "simple request", được gửi đi mà không có preflight nào.

sequenceDiagram participant U as Browser của user participant E as evil.example participant S as shop.example.com U->>S: Đăng nhập, nhận session cookie U->>E: Mở trang của kẻ tấn công E-->>U: Form ẩn tự submit U->>S: POST đổi email, cookie được gắn kèm S->>S: So CSRF token với session S-->>U: 419 thiếu token, không đổi gì hết

Lớp 1: Synchronizer token

Cách sửa kinh điển phá sự thật số 3. Server lưu một token ngẫu nhiên trong session của user và nhúng nó vô mọi form. Mỗi request đổi trạng thái, server kiểm tra token gửi lên có khớp token trong session không. Trang của kẻ tấn công không đọc được HTML của mình (lại là same-origin policy), nên không biết token, nên request giả mạo fail.

Trong Laravel, nhóm middleware web chạy VerifyCsrfToken (từ Laravel 11 được expose dưới tên ValidateCsrfToken) cho mọi POST, PUT, PATCH và DELETE. Nó nhận token từ ba chỗ: field form _token, header X-CSRF-TOKEN, hoặc header X-XSRF-TOKEN (giá trị đã mã hóa của cookie XSRF-TOKEN). Directive @csrf của Blade render ra field ẩn:

<form method="POST" action="/account/email">
    @csrf
    <input type="email" name="email" required>
    <button type="submit">Save</button>
</form>
<!-- @csrf renders: <input type="hidden" name="_token" value="..."> -->

Thiếu token hoặc sai token thì ra response 419 Page Expired. Phép so sánh xài hash_equals(), và token được tạo lại khi login qua $request->session()->regenerate() cộng regenerateToken() khi logout, chặn luôn session fixation.

Loại route ra khỏi CSRF đôi khi là hợp lý, ví dụ webhook của cổng thanh toán không có session và được xác thực bằng chữ ký HMAC. Giữ danh sách ngắn và cụ thể:

// bootstrap/app.php
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(web: __DIR__.'/../routes/web.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // Only routes that are authenticated some other way, e.g. signed webhooks
        $middleware->validateCsrfTokens(except: [
            'webhooks/stripe',
        ]);
    })
    ->create();

SameSite phá sự thật số 1. Cookie SameSite=Strict không bao giờ được gửi theo request do site khác khởi tạo. SameSite=Lax được gửi khi điều hướng GET cấp cao nhất (bấm vô link) nhưng không gửi với POST cross-site, iframe hay fetch(). SameSite=None; Secure thì quay về kiểu cũ, gửi ở mọi nơi.

Chrome và Edge mặc định coi cookie không có thuộc tính SameSite là Lax, còn Laravel set same_site thành lax rõ ràng luôn:

// config/session.php (trimmed)
return [
    'driver' => env('SESSION_DRIVER', 'database'),
    'lifetime' => (int) env('SESSION_LIFETIME', 120),
    'domain' => env('SESSION_DOMAIN'),          // e.g. .example.com for SPA + API subdomains
    'secure' => env('SESSION_SECURE_COOKIE'),   // true in production
    'http_only' => env('SESSION_HTTP_ONLY', true),
    'same_site' => env('SESSION_SAME_SITE', 'lax'),
];

Lax chặn được form POST giả mạo ở trên. Nhưng nó là lớp thứ hai, không thay được token:

  • "Site" không phải "origin". blog.example.com và shop.example.com là cùng một site. Một subdomain có lỗ hổng hoặc chứa nội dung do user đăng có thể CSRF mấy subdomain anh em mà cookie SameSite vẫn được gắn.
  • GET vẫn được gửi. Route nào đổi trạng thái bằng GET (/logout, /cart/add?id=5, /newsletter/unsubscribe) vẫn bị giả mạo được chỉ bằng một link hay thẻ <img>.
  • Khác biệt giữa các browser. Browser cũ bỏ qua SameSite, và vài browser có trường hợp đặc biệt cho cookie vừa mới set.

Có những backend stateless không giữ token trong session phía server được. Pattern double-submit để một giá trị ngẫu nhiên trong cookie và bắt client gửi lại nó trong header hoặc field body; server chỉ kiểm tra hai cái khớp nhau. Kẻ tấn công không đọc được cookie khi cross-site, nên không copy được vô header.

Bản ngây thơ có lỗ: nếu kẻ tấn công kiểm soát được một subdomain bất kỳ, họ có thể ghi cookie cho domain cha (cookie tossing) rồi submit giá trị khớp. Cách sửa là double-submit cookie có ký: token là nonce.HMAC(secret, session id + nonce), nên cookie bị ném vô mà không có secret của server, không gắn với session của nạn nhân, sẽ bị từ chối. Đó chính là thứ challenge bên dưới yêu cầu mình viết. Cookie XSRF-TOKEN của Laravel là một biến thể của cách này: nó được mã hóa bằng APP_KEY và so với token trong session, nên cũng không giả được.

Setup SPA trong Laravel với Sanctum

Với SPA first-party ở app.example.com gọi api.example.com, Sanctum giữ cho session cookie và bảo vệ CSRF chạy được qua các subdomain. SPA gọi /sanctum/csrf-cookie trước, endpoint này set cookie XSRF-TOKEN; sau đó HTTP client đọc nó và gửi lại dưới dạng X-XSRF-TOKEN.

import axios from 'axios';

export const api = axios.create({
  baseURL: 'https://api.example.com',
  withCredentials: true, // send the session cookie
  withXSRFToken: true,   // axios >= 1.6 only adds X-XSRF-TOKEN cross-origin when this is set
});

export async function login(email, password) {
  await api.get('/sanctum/csrf-cookie'); // sets the XSRF-TOKEN cookie
  await api.post('/login', { email, password });
}

Checklist cho setup này: SANCTUM_STATEFUL_DOMAINS có domain của SPA, SESSION_DOMAIN=.example.com, config/cors.php có supports_credentials => true với origin cụ thể, và bật $middleware->statefulApi(). Nếu xài fetch() trần thì tự đọc cookie XSRF-TOKEN, decodeURIComponent() nó rồi gửi qua header X-XSRF-TOKEN.

Phòng thủ nhiều lớp: Fetch Metadata

Browser hiện đại gửi Sec-Fetch-Site theo mọi request: same-origin, same-site, cross-site hoặc none (gõ URL, bookmark). JavaScript không giả được header này. Từ chối request ghi cross-site là một lớp thêm rẻ tiền, che luôn mấy route lỡ bị loại khỏi CSRF:

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

final class RejectCrossSiteWrites
{
    public function handle(Request $request, Closure $next): Response
    {
        if ($request->isMethodSafe()) {
            return $next($request);
        }

        $site = $request->headers->get('Sec-Fetch-Site');

        // Old browsers and non-browser clients do not send it: the CSRF token still applies.
        if ($site !== null && ! in_array($site, ['same-origin', 'same-site', 'none'], true)) {
            abort(403, 'Cross-site request blocked.');
        }

        return $next($request);
    }
}

Nếu app không bao giờ cần request từ subdomain anh em thì bỏ same-site khỏi danh sách để chặn luôn kịch bản subdomain.

Kiểm thử bảo vệ CSRF (test)

Có một bất ngờ trước: middleware CSRF của Laravel bỏ qua việc kiểm tra khi đang chạy unit test, nên một feature test post mà không có token vẫn pass dù bảo vệ cấu hình đúng hay sai. Cho test bình thường thì tiện, nhưng nghĩa là mình phải test lớp phòng thủ theo cách khác: test trực tiếp mấy lớp mình tự thêm, và khẳng định các route đổi trạng thái không gọi được bằng GET.

use App\Http\Middleware\RejectCrossSiteWrites;
use Illuminate\Support\Facades\Route;

beforeEach(function () {
    Route::post('/_test/transfer', fn () => response()->noContent())
        ->middleware(RejectCrossSiteWrites::class);
});

it('blocks cross-site writes', function () {
    $this->withHeader('Sec-Fetch-Site', 'cross-site')
        ->post('/_test/transfer')
        ->assertForbidden();
});

it('allows same-origin writes and clients without fetch metadata', function () {
    $this->withHeader('Sec-Fetch-Site', 'same-origin')
        ->post('/_test/transfer')
        ->assertNoContent();

    $this->post('/_test/transfer')->assertNoContent();
});

it('never changes state over GET', function () {
    $this->get('/logout')->assertMethodNotAllowed();
    $this->get('/account/delete')->assertMethodNotAllowed();
});

Còn phần kiểm tra token, một test end-to-end (Playwright hoặc Dusk) submit form đã gỡ field _token và mong đợi 419 mới là bằng chứng chắc chắn.

Mấy lỗi hay gặp

  • Đổi trạng thái bằng GET. Link logout, link "thêm vô giỏ", URL hủy đăng ký một click đều vượt qua cả token lẫn SameSite=Lax. Xài POST/DELETE.
  • Danh sách except cứ dài ra. Mỗi dòng là một route không có bảo vệ CSRF. Chỉ loại ra mấy route được xác thực bằng thứ khác cookie.
  • Token nằm trên URL. Query string sẽ lọt vô log, lịch sử browser và header Referer. Gửi token qua field body hoặc header.
  • XSS đánh bại bảo vệ CSRF. Script chạy trên origin của mình đọc được token và gửi request gì cũng được. Mọi lớp chống CSRF đều giả định mình không có XSS.
  • Login CSRF. Kẻ tấn công có thể đăng nhập nạn nhân vô tài khoản của kẻ tấn công rồi thu lại những gì nạn nhân nhập. Laravel bảo vệ cả form login; đừng loại nó ra.
  • Cache trang có token. Full-page cache trả HTML (và token) của một user cho mọi người sẽ sinh ra lỗi 419 lung tung. Loại form ra khỏi cache hoặc lấy token riêng.
  • Nghĩ API JSON là miễn nhiễm. Endpoint nhận body text/plain hay body form rồi parse như JSON vẫn bị simple request tấn công được.

Khi nào xài cái nào (và khi nào không)

  • Web app xác thực bằng cookie (Blade, Livewire, Inertia): giữ kiểm tra token của Laravel, giữ same_site=lax, muốn thì thêm fetch metadata. Đây là mặc định và nó tốt.
  • SPA first-party với Sanctum: cùng các lớp bảo vệ đó, nối qua XSRF-TOKEN / X-XSRF-TOKEN.
  • Backend stateless có cookie nhưng không có session store: xài double-submit cookie có ký.
  • API thuần bearer token (app mobile, bên thứ ba gửi header Authorization): CSRF không áp dụng, vì browser không bao giờ tự gắn credential đó. Đừng lưu mấy token đó trong cookie, không thì lại phải chống CSRF.
  • Webhook: loại khỏi CSRF và verify chữ ký HMAC của nó.

CSRF trong Laravel đã được giải sẵn từ mặc định. Việc của mình chủ yếu là đừng làm nó hỏng: không đổi trạng thái bằng GET, danh sách except thật nhỏ, và cấu hình cookie với Sanctum cho đúng khi frontend dời qua subdomain khác.

Thử thách tương tác

Thử thách

Luyện tập ngay điều vừa học. Viết lời giải, mở gợi ý nếu bí.

Đề bài

Viết CsrfGuard (PHP và Python), bộ kiểm tra double-submit cookie có ký. Constructor nhận chuỗi secret và một callable random trả về chuỗi nonce. issue(sessionId) lấy một nonce từ random và trả về '<nonce>.<signature>', với signature là HMAC-SHA256 dạng hex chữ thường, key là secret, của message '<len(sessionId)>!<sessionId>!<len(nonce)>!<nonce>' (độ dài tính bằng byte, ví dụ '7!sess-42!5!n0nce'). validate(method, sessionId, cookieToken, submittedToken) trả true liền với GET, HEAD và OPTIONS (không phân biệt hoa thường). Với method khác thì trả false nếu một trong hai token là null/None, nếu hai token không bằng nhau (so sánh constant-time), nếu token gửi lên không tách theo '.' ra đúng hai phần hoặc phần nonce rỗng, hoặc nếu phần chữ ký không khớp HMAC tính lại cho sessionId và nonce đó (so sánh constant-time). Còn lại trả true.

Code khởi tạo

php
final class CsrfGuard
{
    public function __construct(private string $secret, private Closure $random) {}

    public function issue(string $sessionId): string
    {
        // TODO: nonce from $this->random, return "<nonce>.<hmac hex>"
        throw new LogicException('TODO');
    }

    public function validate(string $method, string $sessionId, ?string $cookieToken, ?string $submittedToken): bool
    {
        // TODO: GET/HEAD/OPTIONS are always allowed
        // TODO: both tokens present and equal (hash_equals)
        // TODO: split "<nonce>.<signature>" and verify the HMAC for this session
        throw new LogicException('TODO');
    }
}
python
import hashlib
import hmac
from typing import Callable

SAFE_METHODS = {"GET", "HEAD", "OPTIONS"}


class CsrfGuard:
    def __init__(self, secret: str, random: Callable[[], str]) -> None:
        self.secret = secret.encode()
        self.random = random

    def issue(self, session_id: str) -> str:
        # TODO: nonce from self.random(), return "<nonce>.<hmac hex>"
        raise NotImplementedError

    def validate(self, method: str, session_id: str, cookie_token: str | None, submitted_token: str | None) -> bool:
        # TODO: GET/HEAD/OPTIONS are always allowed
        # TODO: both tokens present and equal (hmac.compare_digest)
        # TODO: split "<nonce>.<signature>" and verify the HMAC for this session
        raise NotImplementedError

Lời giải của bạn

Gợi ý

Đã mở hết gợi ý
Gợi ý 1

Ghi độ dài trước session id và nonce để tránh nối chuỗi mơ hồ kiểu 'ab'+'c' với 'a'+'bc'

Gợi ý 2

Cookie với header phải khớp nhau VÀ chữ ký phải hợp lệ với session hiện tại; một bước kiểm tra là chưa đủ

Gợi ý 3

Xài hash_equals() / hmac.compare_digest() cho cả hai lần so sánh

Lời giải · php
final class CsrfGuard
{
    private const SAFE_METHODS = ['GET', 'HEAD', 'OPTIONS'];

    public function __construct(private string $secret, private Closure $random) {}

    public function issue(string $sessionId): string
    {
        $nonce = ($this->random)();

        return $nonce.'.'.$this->sign($sessionId, $nonce);
    }

    public function validate(string $method, string $sessionId, ?string $cookieToken, ?string $submittedToken): bool
    {
        if (in_array(strtoupper($method), self::SAFE_METHODS, true)) {
            return true;
        }

        if ($cookieToken === null || $submittedToken === null || ! hash_equals($cookieToken, $submittedToken)) {
            return false;
        }

        $parts = explode('.', $submittedToken);
        if (count($parts) !== 2 || $parts[0] === '') {
            return false;
        }

        return hash_equals($this->sign($sessionId, $parts[0]), $parts[1]);
    }

    private function sign(string $sessionId, string $nonce): string
    {
        $message = strlen($sessionId).'!'.$sessionId.'!'.strlen($nonce).'!'.$nonce;

        return hash_hmac('sha256', $message, $this->secret);
    }
}
Lời giải · python
import hashlib
import hmac
from typing import Callable

SAFE_METHODS = {"GET", "HEAD", "OPTIONS"}


class CsrfGuard:
    def __init__(self, secret: str, random: Callable[[], str]) -> None:
        self.secret = secret.encode()
        self.random = random

    def issue(self, session_id: str) -> str:
        nonce = self.random()
        return f"{nonce}.{self._sign(session_id, nonce)}"

    def validate(self, method: str, session_id: str, cookie_token: str | None, submitted_token: str | None) -> bool:
        if method.upper() in SAFE_METHODS:
            return True
        if cookie_token is None or submitted_token is None:
            return False
        if not hmac.compare_digest(cookie_token.encode(), submitted_token.encode()):
            return False
        parts = submitted_token.split(".")
        if len(parts) != 2 or parts[0] == "":
            return False
        return hmac.compare_digest(self._sign(session_id, parts[0]), parts[1])

    def _sign(self, session_id: str, nonce: str) -> str:
        message = f"{len(session_id)}!{session_id}!{len(nonce)}!{nonce}"
        return hmac.new(self.secret, message.encode(), hashlib.sha256).hexdigest()

Cùng chủ đề Bảo Mật