Laravel Sanctum i Passport służą różnym potrzebom uwierzytelniania API, a wybór niewłaściwego pakietu prowadzi do niepotrzebnej złożoności lub luk bezpieczeństwa. Ten przewodnik szczegółowo omawia oba pakiety z praktycznymi przykładami kodu i rzeczywistymi pytaniami rekrutacyjnymi.

Szybka Decyzja

Sanctum obsługuje uwierzytelnianie SPA i proste tokeny API. Passport implementuje pełny OAuth2 z kodami autoryzacji, poświadczeniami klienta i tokenami odświeżania. Większość aplikacji potrzebuje Sanctum.

Laravel Sanctum vs Passport: Podstawowe Różnice

Sanctum zapewnia lekkie uwierzytelnianie oparte na tokenach, zaprojektowane dla aplikacji pierwszej strony. Pakiet wykorzystuje uwierzytelnianie oparte na ciasteczkach sesji dla SPA oraz osobiste tokeny dostępu dla aplikacji mobilnych i prostych API.

Passport implementuje pełną specyfikację OAuth2, włączając serwery autoryzacji, granty poświadczeń klienta i uwierzytelnianie maszyna-do-maszyny. Ta złożoność ma sens dla aplikacji, które muszą autoryzować dostęp stron trzecich.

| Funkcja | Sanctum | Passport | |---------|---------|----------| | Główne Zastosowanie | SPA, Aplikacje Mobilne, Proste API | OAuth2 Stron Trzecich, Maszyna-do-Maszyny | | Typ Tokena | Proste hashowane tokeny | JWT z zakresami OAuth2 | | Uwierzytelnianie Sesyjne | Tak (oparte na ciasteczkach) | Nie | | Granty OAuth2 | Brak | Pełna specyfikacja | | Rozmiar Pakietu | Minimalny | Znaczący | | Konfiguracja | Prosta | Złożona |

Implementacja Sanctum dla Uwierzytelniania SPA

Uwierzytelnianie SPA w Sanctum opiera się na ciasteczkach sesji Laravel, a nie na tokenach API. Frontend i backend muszą współdzielić tę samą domenę najwyższego poziomu, aby to działało.

config/sanctum.phpphp

return [
    'stateful' => explode(',', env('SANCTUM_STATEFUL_DOMAINS', sprintf(
        '%s%s',
        'localhost,localhost:3000,127.0.0.1,127.0.0.1:8000,::1',
        env('APP_URL') ? ','.parse_url(env('APP_URL'), PHP_URL_HOST) : ''
    ))),

    'expiration' => null, // Tokeny domyślnie nie wygasają

    'middleware' => [
        'verify_csrf_token' => App\Http\Middleware\VerifyCsrfToken::class,
        'encrypt_cookies' => App\Http\Middleware\EncryptCookies::class,
    ],
];

SPA musi wywołać endpoint ciasteczka CSRF przed wykonaniem uwierzytelnionych żądań. To ustanawia sesję i ustawia ciasteczko XSRF-TOKEN.

javascript

// Frontend: Inicjalizacja ochrony CSRF przed logowaniem
async function initializeAuth() {
    await fetch('/sanctum/csrf-cookie', {
        credentials: 'include'
    });
}

async function login(email, password) {
    await initializeAuth();
    
    const response = await fetch('/api/login', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'X-XSRF-TOKEN': getCookie('XSRF-TOKEN'),
            'Accept': 'application/json'
        },
        credentials: 'include',
        body: JSON.stringify({ email, password })
    });
    
    return response.json();
}

Uwierzytelnianie API za pomocą Tokenów Sanctum

Aplikacje mobilne i integracje stron trzecich używają osobistych tokenów dostępu zamiast ciasteczek sesji. Sanctum przechowuje te tokeny jako hashe SHA-256 w bazie danych.

app/Http/Controllers/AuthController.phpphp

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\ValidationException;

class AuthController extends Controller
{
    public function createToken(Request $request)
    {
        $request->validate([
            'email' => 'required|email',
            'password' => 'required',
            'device_name' => 'required',
        ]);

        $user = User::where('email', $request->email)->first();

        if (! $user || ! Hash::check($request->password, $user->password)) {
            throw ValidationException::withMessages([
                'email' => ['Podane dane uwierzytelniające są nieprawidłowe.'],
            ]);
        }

        // Token z uprawnieniami (zakresami)
        $token = $user->createToken(
            $request->device_name,
            ['read', 'write'] // Opcjonalne uprawnienia
        );

        return response()->json([
            'token' => $token->plainTextToken,
            'expires_at' => null // Konfiguracja w sanctum.php
        ]);
    }

    public function revokeToken(Request $request)
    {
        // Unieważnienie bieżącego tokena
        $request->user()->currentAccessToken()->delete();

        return response()->json(['message' => 'Token unieważniony']);
    }
}

Trasy chronione są middleware auth:sanctum. Sprawdzanie uprawnień tokena odbywa się za pomocą metody tokenCan.

routes/api.phpphp

use Illuminate\Support\Facades\Route;

Route::middleware('auth:sanctum')->group(function () {
    Route::get('/user', function (Request $request) {
        return $request->user();
    });

    Route::post('/posts', function (Request $request) {
        // Sprawdzenie czy token ma uprawnienie do zapisu
        if (! $request->user()->tokenCan('write')) {
            abort(403, 'Token nie ma uprawnień do zapisu');
        }

        // Logika tworzenia posta
    });
});

Gotowy na rozmowy o Laravel?

Ćwicz z naszymi interaktywnymi symulatorami, flashcards i testami technicznymi.

Odkryj Laravel

Kiedy Używać Laravel Passport

Passport staje się niezbędny, gdy aplikacja działa jako serwer autoryzacji OAuth2. Typowe scenariusze obejmują:

Zewnętrzni deweloperzy budujący integracje z API
Uwierzytelnianie maszyna-do-maszyny między mikroserwisami
Aplikacje wymagające zgodności z OAuth2 dla klientów korporacyjnych
Systemy potrzebujące rotacji tokenów odświeżania i walidacji JWT

app/Http/Controllers/Api/PassportController.phpphp

namespace App\Http\Controllers\Api;

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;

class PassportController extends Controller
{
    public function issueToken(Request $request)
    {
        $request->validate([
            'email' => 'required|email',
            'password' => 'required',
        ]);

        $user = User::where('email', $request->email)->first();

        if (! $user || ! Hash::check($request->password, $user->password)) {
            return response()->json([
                'error' => 'invalid_credentials'
            ], 401);
        }

        // Tworzenie tokena OAuth2 z zakresami
        $token = $user->createToken('API Token', ['read-posts', 'write-posts']);

        return response()->json([
            'access_token' => $token->accessToken,
            'token_type' => 'Bearer',
            'expires_at' => $token->token->expires_at
        ]);
    }
}

Passport wspiera również grant poświadczeń klienta dla uwierzytelniania serwer-do-serwera bez kontekstu użytkownika.

php

// Uwierzytelnianie maszyna-do-maszyny
// config/auth.php
'guards' => [
    'api' => [
        'driver' => 'passport',
        'provider' => 'users',
    ],
],

// routes/api.php - Trasa chroniona poświadczeniami klienta
Route::middleware('client')->group(function () {
    Route::get('/machine-data', function () {
        return response()->json(['data' => 'Dostępne dla maszyn']);
    });
});

Najlepsze Praktyki Bezpieczeństwa dla Uwierzytelniania API Laravel

Oba pakiety wymagają dodatkowych środków bezpieczeństwa wykraczających poza podstawową konfigurację. Wygasanie tokenów, limitowanie żądań i właściwa walidacja zakresów zapobiegają typowym podatnościom.

app/Providers/AuthServiceProvider.phpphp

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Laravel\Sanctum\Sanctum;
use Laravel\Sanctum\PersonalAccessToken;

class AuthServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        // Ustawienie wygasania tokenów (Sanctum)
        Sanctum::authenticateAccessTokensUsing(function ($token, $isValid) {
            // Tokeny wygasają po 24 godzinach
            $expiration = config('sanctum.expiration');
            
            if ($expiration === null) {
                return $isValid;
            }

            return $isValid && $token->created_at->gt(now()->subMinutes($expiration));
        });
    }
}

Implementacja limitowania żądań na endpointach uwierzytelniania zapobiega atakom brute force. Laravel 12 zapewnia elastyczną konfigurację limitera żądań poprzez fasadę RateLimiting.

app/Providers/AppServiceProvider.phpphp

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Support\Facades\RateLimiting;

public function boot(): void
{
    RateLimiting::for('login', function ($request) {
        return Limit::perMinute(5)->by($request->ip());
    });

    RateLimiting::for('api', function ($request) {
        return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip());
    });
}

Pytania Rekrutacyjne dotyczące Uwierzytelniania Laravel

Rozmowy techniczne często testują zrozumienie wzorców uwierzytelniania API. Te pytania pojawiają się na rozmowach dla programistów Laravel na wszystkich poziomach.

P: Jaka jest różnica między uwierzytelnianiem SPA a uwierzytelnianiem tokenowym w Sanctum?

Uwierzytelnianie SPA wykorzystuje ciasteczka sesji Laravel z ochroną CSRF. Frontend wywołuje /sanctum/csrf-cookie aby ustanowić sesję, a następne żądania automatycznie zawierają ciasteczko sesji. Uwierzytelnianie tokenowe używa tokenów Bearer w nagłówku Authorization, odpowiednie dla aplikacji mobilnych i integracji stron trzecich, gdzie ciasteczka są niepraktyczne.

P: Kiedy wybrać Passport zamiast Sanctum?

Passport implementuje pełny OAuth2, wymagany gdy zewnętrzni deweloperzy muszą integrować się z API używając przepływu kodu autoryzacji, lub gdy uwierzytelnianie maszyna-do-maszyny wymaga grantów poświadczeń klienta. Sanctum obsługuje aplikacje pierwszej strony w prostszy sposób.

P: Jak Sanctum przechowuje tokeny API?

Sanctum przechowuje hash SHA-256 każdego tokena w tabeli personal_access_tokens. Tekst jawny tokena jest zwracany tylko raz podczas tworzenia. To podejście oznacza, że skompromitowane dane z bazy nie mogą ujawnić ważnych tokenów.

P: Jak zaimplementować uprawnienia/zakresy tokenów w Sanctum?

php

// Tworzenie tokena z uprawnieniami
$token = $user->createToken('api-token', ['posts:read', 'posts:write']);

// Sprawdzanie uprawnień w kontrolerze
if ($request->user()->tokenCan('posts:write')) {
    // Autoryzacja do operacji zapisu
}

// Sprawdzanie uprawnień oparte na middleware
Route::middleware(['auth:sanctum', 'ability:posts:write'])
    ->post('/posts', [PostController::class, 'store']);

P: Jak unieważnić wszystkie tokeny użytkownika w Sanctum?

php

// Unieważnienie wszystkich tokenów
$user->tokens()->delete();

// Unieważnienie konkretnego tokena po ID
$user->tokens()->where('id', $tokenId)->delete();

// Unieważnienie tylko bieżącego tokena
$request->user()->currentAccessToken()->delete();

Migracja z Passport do Sanctum

Aplikacje, które rozpoczęły z Passport, ale używają tylko prostego uwierzytelniania tokenowego, mogą migrować do Sanctum dla zmniejszenia złożoności. Migracja wymaga aktualizacji tworzenia tokenów, konfiguracji middleware i wszelkich sprawdzeń zakresów.

php

// Helper migracji: Konwersja tokenów Passport do Sanctum
use App\Models\User;
use Laravel\Passport\Token;

// To jest migracja jednokierunkowa - uruchom raz, potem usuń Passport
User::chunk(100, function ($users) {
    foreach ($users as $user) {
        $passportTokens = Token::where('user_id', $user->id)
            ->where('revoked', false)
            ->get();

        foreach ($passportTokens as $token) {
            $user->createToken(
                $token->name ?? 'migrated-token',
                $token->scopes ?? []
            );
        }
    }
});

Zaktualizuj middleware tras z auth:api na auth:sanctum i zamień $request->user()->token()->scopes na $request->user()->currentAccessToken()->abilities.

Podsumowanie

Sanctum pasuje do SPA, aplikacji mobilnych i API pierwszej strony z minimalną konfiguracją
Passport obsługuje serwery autoryzacji OAuth2 i integracje stron trzecich
Uwierzytelnianie SPA używa ciasteczek sesji; uwierzytelnianie API używa tokenów Bearer
Uprawnienia tokenów zapewniają szczegółową kontrolę dostępu w Sanctum
Limitowanie żądań i wygasanie tokenów to niezbędne środki bezpieczeństwa niezależnie od wyboru pakietu
Większość aplikacji Laravel powinna zacząć od Sanctum i dodać Passport tylko gdy zgodność z OAuth2 stanie się wymaganiem

Zacznij ćwiczyć!

Sprawdź swoją wiedzę z naszymi symulatorami rozmów i testami technicznymi.

Utwórz darmowe konto

Laravel Sanctum vs Passport w 2026: Uwierzytelnianie API i Pytania Rekrutacyjne