Autorisatie (gates en policies) - Knowledge of Laravel

Het verschil tussen authenticatie en autorisatie

Authenticatie controleert “wie” een gebruiker is. Het inlogproces is daar het bekendste voorbeeld van. Autorisatie bepaalt “wat” die gebruiker mag doen. Denk aan controles zoals: je mag alleen je eigen posts bewerken, of alleen beheerders mogen instellingen wijzigen. Heb je met authenticatie een inlogfunctie geïmplementeerd, dan is autorisatie de volgende stap.

De autorisatiefunctionaliteit van Laravel biedt twee benaderingen: gates en policies. Welke je gebruikt hangt af van de use case.

Richtlijnen voor de keuze

Scenario	Aanbevolen
Eenvoudige controles die niet aan een specifiek model gekoppeld zijn	Gate
Rechtenbeheer voor CRUD-bewerkingen op een model	Policy
Toegangscontrole voor een beheerdersdashboard	Gate
Rechten voor het aanmaken, bewerken en verwijderen van blogposts	Policy

Gates

Gates zijn eenvoudige, closure-gebaseerde autorisatiechecks. Ze zijn geschikt voor rechtencontroles die niet aan een specifiek model gekoppeld zijn.

Autorisatieflow met gates

Een gate definiëren

Gates definieer je met Gate::define() in de boot-methode van App\Providers\AppServiceProvider.

// app/Providers/AppServiceProvider.php

use App\Models\Post;
use App\Models\User;
use Illuminate\Support\Facades\Gate;

public function boot(): void
{
    Gate::define('update-post', function (User $user, Post $post) {
        return $user->id === $post->user_id;
    });
}

De closure van een gate ontvangt altijd de momenteel geauthenticeerde gebruiker als eerste argument. Vanaf het tweede argument kun je extra informatie doorgeven, zoals het betreffende model.

Rechten controleren met een gate

Om in een controller rechten te controleren met een gate gebruik je Gate::allows() of Gate::denies().

use Illuminate\Support\Facades\Gate;

public function update(Request $request, Post $post): RedirectResponse
{
    if (! Gate::allows('update-post', $post)) {
        abort(403);
    }

    // Verwerking om de post bij te werken...

    return redirect('/posts');
}

Een exceptie gooien met Gate::authorize()

Om automatisch een 403-response terug te geven wanneer de gebruiker geen rechten heeft, gebruik je Gate::authorize(). Zo hoef je geen abort(403) te schrijven.

public function update(Request $request, Post $post): RedirectResponse
{
    Gate::authorize('update-post', $post);

    // Met de juiste rechten kom je hier
    // Verwerking om de post bij te werken...

    return redirect('/posts');
}

Gate::authorize() gooit een Illuminate\Auth\Access\AuthorizationException als de gebruiker geen rechten heeft. Laravel zet die automatisch om in een 403 HTTP-response.

Beheerdersbypass (de before-methode)

Wil je beheerders alle rechten geven, gebruik dan Gate::before().

use App\Models\User;
use Illuminate\Support\Facades\Gate;

public function boot(): void
{
    // $ability bevat de naam van de gate die wordt uitgevoerd ('update-post', enz.)
    Gate::before(function (User $user, string $ability) {
        if ($user->isAdministrator()) {
            return true;
        }
    });

    Gate::define('update-post', function (User $user, Post $post) {
        return $user->id === $post->user_id;
    });
}

Geeft de closure van before een andere waarde dan null terug, dan wordt dat resultaat het eindoordeel van de rechtencheck. Geeft de closure null of niets terug, dan gaat de normale gate-check verder.

@can / @cannot in Blade-templates

Voor gate-checks in templates zijn de directives @can en @cannot handig.

@can('update-post', $post)
    <a href="{{ route('posts.edit', $post) }}">Bewerken</a>
@endcan

@cannot('update-post', $post)
    <p>Je hebt geen rechten om deze post te bewerken.</p>
@endcannot

Policies

Een policy bundelt de autorisatielogica voor een specifiek model in een klasse. Voor het rechtenbeheer van aanmaken, bekijken, bewerken en verwijderen op het Post-model is een policy geschikter dan een gate.

Autorisatieflow met policies

Een policy genereren

Met het Artisan-commando make:policy genereer je een policy-klasse.

php artisan make:policy PostPolicy

Om een sjabloon te genereren met alle CRUD-methoden voor een model gebruik je de optie --model.

php artisan make:policy PostPolicy --model=Post

Er wordt een bestand app/Policies/PostPolicy.php gegenereerd.

Automatische detectie van modellen en policies

Laravel detecteert policies standaard automatisch op basis van naamgevingsconventies.

Model: app/Models/Post.php
Policy: app/Policies/PostPolicy.php

Volg je deze naamgevingsconventie, dan hoef je de policy niet te registreren.

Als je de naamgevingsconventie niet volgt of handmatig wilt registreren, gebruik je Gate::policy() in de boot-methode van de AppServiceProvider.

use App\Models\Post;
use App\Policies\PostPolicy;
use Illuminate\Support\Facades\Gate;

Gate::policy(Post::class, PostPolicy::class);

In Laravel 13 kun je een policy ook declaratief registreren door het #[UsePolicy]-attribuut aan het model toe te voegen.

use App\Policies\PostPolicy;
use Illuminate\Database\Eloquent\Attributes\UsePolicy;

#[UsePolicy(PostPolicy::class)]
class Post extends Model {}

Policy-methoden implementeren

Een policy die je met de optie --model genereert, bevat methoden voor de standaard CRUD-acties.

<?php

namespace App\Policies;

use App\Models\Post;
use App\Models\User;

class PostPolicy
{
    /**
     * Mag de gebruiker de lijst met posts bekijken?
     */
    public function viewAny(User $user): bool
    {
        return true; // Elke geauthenticeerde gebruiker mag kijken
    }

    /**
     * Mag de gebruiker een specifieke post bekijken?
     */
    public function view(User $user, Post $post): bool
    {
        return true; // Elke geauthenticeerde gebruiker mag kijken
    }

    /**
     * Mag de gebruiker een post aanmaken?
     */
    public function create(User $user): bool
    {
        return true; // Elke geauthenticeerde gebruiker mag posten
    }

    /**
     * Mag de gebruiker een post bijwerken?
     */
    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id; // Alleen eigen posts bewerken
    }

    /**
     * Mag de gebruiker een post verwijderen?
     */
    public function delete(User $user, Post $post): bool
    {
        return $user->id === $post->user_id; // Alleen eigen posts verwijderen
    }
}

Beheerdersbypass (de before-methode)

Ook in een policy kun je een before-methode definiëren om beheerders alle rechten te geven.

/**
 * Voorafgaande check die vóór de andere policy-methoden wordt uitgevoerd
 * $ability bevat de naam van de policy-methode ('update', 'delete', enz.)
 */
public function before(User $user, string $ability): bool|null
{
    if ($user->isAdministrator()) {
        return true; // Beheerders mogen alle acties uitvoeren
    }

    return null; // Bij null gaat het door naar de normale policy-methode
}

De before-methode wordt alleen aangeroepen als de policy-klasse een methode heeft die overeenkomt met de actie. Bestaat de update-methode bijvoorbeeld niet, dan wordt before ook niet aangeroepen.

Uitvoervolgorde van de before-callback

Policies gebruiken in controllers

De authorize()-methode

Controllers van Laravel hebben een authorize()-helpermethode (gebruik je de basiscontroller niet, dan gebruik je Gate::authorize()).

Gate::authorize()
User::can() / cannot()

<?php

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Gate;

class PostController extends Controller
{
    public function update(Request $request, Post $post): RedirectResponse
    {
        Gate::authorize('update', $post);

        // Verwerking om de post bij te werken...

        return redirect()->route('posts.index');
    }

    public function store(Request $request): RedirectResponse
    {
        Gate::authorize('create', Post::class);

        // Verwerking om de post aan te maken...

        return redirect()->route('posts.index');
    }

    public function destroy(Post $post): RedirectResponse
    {
        Gate::authorize('delete', $post);

        $post->delete();

        return redirect()->route('posts.index');
    }
}

<?php

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function update(Request $request, Post $post): RedirectResponse
    {
        if ($request->user()->cannot('update', $post)) {
            abort(403);
        }

        // Verwerking om de post bij te werken...

        return redirect()->route('posts.index');
    }
}

RESTful-policies in één keer registreren met authorizeResource()

Roep je authorizeResource() aan in de constructor, dan worden de policy-methoden automatisch gekoppeld aan de bijbehorende acties van de controller.

<?php

namespace App\Http\Controllers;

use App\Models\Post;

class PostController extends Controller
{
    public function __construct()
    {
        $this->authorizeResource(Post::class, 'post');
    }

    // De bijbehorende policy-methoden worden automatisch toegepast op
    // index(), show(), create(), store(), edit(), update() en destroy()
}

De koppeling tussen controlleracties en policy-methoden:

Controlleractie	Policy-methode
`index`	`viewAny`
`show`	`view`
`create` / `store`	`create`
`edit` / `update`	`update`
`destroy`	`delete`

Met authorizeResource() hoef je niet in elke actie afzonderlijk authorize() te schrijven. Vooral in combinatie met RESTful resource controllers is dit handig.

Autorisatie via middleware

Voor autorisatiechecks op routeniveau gebruik je de can-middleware.

use App\Models\Post;

// Alleen toegankelijk voor gebruikers die de post mogen bijwerken
Route::put('/posts/{post}', [PostController::class, 'update'])
    ->middleware('can:update,post');

// Alleen toegankelijk voor gebruikers die posts mogen aanmaken
Route::post('/posts', [PostController::class, 'store'])
    ->middleware('can:create,App\Models\Post');

Een beknoptere notatie met de can-methode:

Route::put('/posts/{post}', [PostController::class, 'update'])
    ->can('update', 'post');

Policies gebruiken in Blade-templates

Zodra een policy is geregistreerd, wordt die ook automatisch gebruikt door de Blade-directives @can / @cannot.

{{-- De bewerkknop van de post alleen tonen aan gebruikers met rechten --}}
@can('update', $post)
    <a href="{{ route('posts.edit', $post) }}" class="btn">Bewerken</a>
@endcan

{{-- Hetzelfde voor de verwijderknop --}}
@can('delete', $post)
    <form method="POST" action="{{ route('posts.destroy', $post) }}">
        @csrf
        @method('DELETE')
        <button type="submit">Verwijderen</button>
    </form>
@endcan

{{-- Knop voor een nieuwe post --}}
@can('create', App\Models\Post::class)
    <a href="{{ route('posts.create') }}">Nieuwe post</a>
@endcan

Praktijkvoorbeeld: rechtenbeheer voor blogposts

Een voorbeeld waarin we in een blogapp de rechten “alleen de auteur mag zijn eigen artikelen bewerken en verwijderen” implementeren.

Genereer een policy

php artisan make:policy PostPolicy --model=Post

Implementeer de policy-methoden

<?php

namespace App\Policies;

use App\Models\Post;
use App\Models\User;

class PostPolicy
{
    /**
     * Beheerders alle rechten geven
     */
    public function before(User $user, string $ability): bool|null
    {
        if ($user->is_admin) {
            return true;
        }

        return null;
    }

    public function viewAny(User $user): bool
    {
        return true;
    }

    public function view(User $user, Post $post): bool
    {
        return true;
    }

    public function create(User $user): bool
    {
        return true;
    }

    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }

    public function delete(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }
}

Voeg authorizeResource() toe aan de controller

<?php

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;

class PostController extends Controller
{
    public function __construct()
    {
        $this->authorizeResource(Post::class, 'post');
    }

    public function index(): View
    {
        $posts = Post::latest()->paginate(10);
        return view('posts.index', compact('posts'));
    }

    public function store(Request $request): RedirectResponse
    {
        $post = $request->user()->posts()->create(
            $request->validate([
                'title' => ['required', 'string', 'max:255'],
                'body'  => ['required', 'string'],
            ])
        );

        return redirect()->route('posts.show', $post);
    }

    public function update(Request $request, Post $post): RedirectResponse
    {
        $post->update(
            $request->validate([
                'title' => ['required', 'string', 'max:255'],
                'body'  => ['required', 'string'],
            ])
        );

        return redirect()->route('posts.show', $post);
    }

    public function destroy(Post $post): RedirectResponse
    {
        $post->delete();

        return redirect()->route('posts.index');
    }
}

Voeg rechtenchecks toe aan het Blade-template

{{-- resources/views/posts/show.blade.php --}}
<h1>{{ $post->title }}</h1>
<p>{{ $post->body }}</p>
<p>Auteur: {{ $post->user->name }}</p>

@can('update', $post)
    <a href="{{ route('posts.edit', $post) }}">Bewerken</a>
@endcan

@can('delete', $post)
    <form method="POST" action="{{ route('posts.destroy', $post) }}">
        @csrf
        @method('DELETE')
        <button type="submit">Verwijderen</button>
    </form>
@endcan

Samenvatting

Wanneer gebruik je gates en wanneer policies?

Gates: eenvoudige rechtenchecks die niet aan een specifiek model gekoppeld zijn. Bijvoorbeeld toegang tot een beheerdersdashboard of rechten om globale instellingen te wijzigen.
Policies: rechtenbeheer voor CRUD-bewerkingen op modellen. Maak per resource zoals Post, Order en Comment een policy-klasse.

Overzicht van veelgebruikte API's

// Controleren met een gate
Gate::allows('update-post', $post);      // true/false
Gate::denies('update-post', $post);      // true/false
Gate::authorize('update-post', $post);   // exceptie bij falen

// Controleren via het user-model
$user->can('update', $post);     // true/false
$user->cannot('update', $post);  // true/false

// Controleren in de controller
Gate::authorize('update', $post);        // 403 bij falen

// Controleren in Blade
@can('update', $post) ... @endcan
@cannot('update', $post) ... @endcannot

Veelgebruikte Artisan-commando's

# Een lege policy genereren
php artisan make:policy PostPolicy

# Genereren met CRUD-methoden voor een model
php artisan make:policy PostPolicy --model=Post

​Het verschil tussen authenticatie en autorisatie

​Gates

​Autorisatieflow met gates

​Een gate definiëren

​Rechten controleren met een gate

​Een exceptie gooien met Gate::authorize()

​Beheerdersbypass (de before-methode)

​@can / @cannot in Blade-templates

​Policies

​Autorisatieflow met policies

​Een policy genereren

​Automatische detectie van modellen en policies

​Policy-methoden implementeren

​Beheerdersbypass (de before-methode)

​Uitvoervolgorde van de before-callback

​Policies gebruiken in controllers

​De authorize()-methode

​RESTful-policies in één keer registreren met authorizeResource()

​Autorisatie via middleware

​Policies gebruiken in Blade-templates

​Praktijkvoorbeeld: rechtenbeheer voor blogposts

​Samenvatting

Het verschil tussen authenticatie en autorisatie

Gates

Autorisatieflow met gates

Een gate definiëren

Rechten controleren met een gate

Een exceptie gooien met Gate::authorize()

Beheerdersbypass (de before-methode)

@can / @cannot in Blade-templates

Policies

Autorisatieflow met policies

Een policy genereren

Automatische detectie van modellen en policies

Policy-methoden implementeren

Beheerdersbypass (de before-methode)

Uitvoervolgorde van de before-callback

Policies gebruiken in controllers

De authorize()-methode

RESTful-policies in één keer registreren met authorizeResource()

Autorisatie via middleware

Policies gebruiken in Blade-templates

Praktijkvoorbeeld: rechtenbeheer voor blogposts

Samenvatting