> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Introductie tot authenticatie

> Een uitleg van de basis van Laravels authenticatiefunctionaliteit. Van het opzetten van een authenticatiesysteem met een starter kit tot het ophalen van de geauthenticeerde gebruiker.

## Wat is authenticatie?

Authenticatie is het mechanisme waarmee je vaststelt "wie" de gebruiker is die toegang vraagt.
In een webapplicatie ontvang je via een inlogformulier een e-mailadres en wachtwoord, en als die kloppen sla je de gebruikersinformatie op in de sessie.
Bij volgende requests wordt die sessie geraadpleegd om de gebruiker te identificeren.

Laravels authenticatiefunctionaliteit is opgebouwd uit twee concepten: "guards" en "providers".

* **Guards**: bepalen hoe gebruikers bij elk request worden geauthenticeerd. De standaard is de `session` guard, die de status beheert met sessies en cookies.
* **Providers**: bepalen hoe gebruikers uit de database worden opgehaald. Standaard wordt Eloquent gebruikt.

<Info>
  Het configuratiebestand voor authenticatie is `config/auth.php`. De standaardconfiguratie volstaat voor de meeste webapplicaties.
</Info>

```mermaid theme={null}
flowchart TD
    A["Inlogrequest"] --> B["Guard<br>(bepaalt de authenticatiemethode)"]
    B --> C["Provider<br>(haalt de gebruiker uit de DB)"]
    C --> D{"Authenticatiecheck"}
    D -- "Geslaagd" --> E["Gebruikersinformatie<br>opslaan in de sessie"]
    E --> F["Redirect naar<br>geauthenticeerde pagina"]
    D -- "Mislukt" --> G["Redirect naar<br>inlogscherm"]
```

## Authenticatie met een starter kit

In Laravel hoef je bij het aanmaken van een applicatie met `laravel new` alleen een starter kit te kiezen, en dan worden authenticatiefuncties zoals inloggen, registreren en wachtwoordherstel automatisch opgezet. Dit is de meest aanbevolen aanpak.

<Steps>
  <Step title="Maak een applicatie aan">
    Maak een applicatie aan met de Laravel installer. Tijdens het proces verschijnt een prompt waarin je een starter kit kunt kiezen.

    ```shell theme={null}
    laravel new my-app
    ```

    Als starter kit kun je kiezen uit **React**, **Vue**, **Livewire** en **Svelte**.
    Kies wat past bij de tech stack van je team.
  </Step>

  <Step title="Installeer de frontend-dependencies">
    ```shell theme={null}
    cd my-app
    npm install && npm run build
    ```
  </Step>

  <Step title="Bereid de database voor">
    Controleer de databaseconfiguratie in het `.env`-bestand en voer daarna de migrations uit.

    ```shell theme={null}
    php artisan migrate
    ```

    De initiële migrations, inclusief de `users`-tabel, worden toegepast.
  </Step>

  <Step title="Start de ontwikkelserver">
    ```shell theme={null}
    composer run dev
    ```

    Als je in de browser naar `http://localhost:8000` gaat, zie je in de navigatie de links "Register" en "Log in".
    Ga naar `/register` en registreer een gebruiker.
  </Step>
</Steps>

Met een starter kit zijn de volgende functies direct beschikbaar.

| Functie               | URL                 |
| --------------------- | ------------------- |
| Gebruikersregistratie | `/register`         |
| Inloggen              | `/login`            |
| Wachtwoordherstel     | `/forgot-password`  |
| E-mailverificatie     | `/email/verify`     |
| Profiel bewerken      | `/settings/profile` |

<Tip>
  Alle code die de starter kit genereert (controllers, routes, views) staat in je eigen applicatie. Je kunt deze vrij aanpassen en naar wens customizen.
</Tip>

### Beschikbare starter kits

#### React

Hiermee bouw je een moderne SPA met React 19, TypeScript, Tailwind en [shadcn/ui](https://ui.shadcn.com).
Dankzij [Inertia](https://inertiajs.com) kun je een React-frontend gebruiken terwijl je server-side routing behoudt.

#### Vue

Gebruikt de Vue Composition API, TypeScript, Tailwind en [shadcn-vue](https://www.shadcn-vue.com/).
Net als bij React verloopt de koppeling met de server-side via Inertia.

#### Livewire

Gebruikt [Livewire](https://livewire.laravel.com), waarmee je dynamische UI's kunt bouwen met alleen PHP.
Ideaal voor teams die vooral met Blade-templates werken, of als je liever geen JavaScript-framework gebruikt.
De [Flux UI](https://fluxui.dev) componentenbibliotheek is inbegrepen.

#### Svelte

Gebruikt Svelte 5, TypeScript, Tailwind en [shadcn-svelte](https://www.shadcn-svelte.com/).
In combinatie met Inertia bouw je hiermee een moderne SPA.

## De Auth-facade

Met de `Auth`-facade kun je informatie over de momenteel geauthenticeerde gebruiker ophalen en de authenticatiestatus controleren.

### De geauthenticeerde gebruiker ophalen

```php theme={null}
use Illuminate\Support\Facades\Auth;

// De huidige gebruiker ophalen
$user = Auth::user();

// Alleen het gebruikers-ID ophalen
$id = Auth::id();
```

In een controller kun je de gebruiker ook via het `Request`-object ophalen.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class DashboardController extends Controller
{
    public function index(Request $request)
    {
        $user = $request->user();

        return view('dashboard', ['user' => $user]);
    }
}
```

### De authenticatiestatus controleren

`Auth::check()` geeft met `true` / `false` aan of de gebruiker is ingelogd.

```php theme={null}
use Illuminate\Support\Facades\Auth;

if (Auth::check()) {
    // Ingelogd
} else {
    // Niet ingelogd
}
```

In Blade-templates zijn de directives `@auth` en `@guest` handig.

```blade theme={null}
@auth
    <p>Hallo, {{ Auth::user()->name }}</p>
    <a href="/logout">Uitloggen</a>
@endauth

@guest
    <a href="/login">Inloggen</a>
    <a href="/register">Registreren</a>
@endguest
```

## Routes beveiligen

Om routes te maken die alleen toegankelijk zijn voor ingelogde gebruikers, gebruik je de `auth`-middleware.

```php theme={null}
// routes/web.php

// Alleen toegankelijk voor geauthenticeerde gebruikers
Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware('auth');
```

Wanneer een niet-geauthenticeerde gebruiker toegang probeert te krijgen, wordt deze automatisch doorgestuurd naar `/login`.

Om meerdere routes in één keer te beveiligen, gebruik je een groep.

```php theme={null}
Route::middleware('auth')->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index']);
    Route::get('/profile', [ProfileController::class, 'show']);
    Route::get('/settings', [SettingsController::class, 'index']);
});
```

<Warning>
  Als je de `auth`-middleware vergeet toe te voegen, kunnen niet-ingelogde gebruikers toegang krijgen. Pas deze altijd toe op routes die beveiliging nodig hebben.
</Warning>

### Routes alleen voor gasten

Om ingelogde gebruikers door te sturen, gebruik je de `guest`-middleware.
Door deze toe te passen op de inlog- en registratiepagina kun je gebruikers die al zijn ingelogd doorsturen naar het dashboard.

```php theme={null}
Route::middleware('guest')->group(function () {
    Route::get('/login', [AuthController::class, 'showLogin']);
    Route::get('/register', [AuthController::class, 'showRegister']);
});
```

## Handmatige authenticatie

Om zonder starter kit handmatig een inlogproces te implementeren, gebruik je `Auth::attempt()`.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\RedirectResponse;
use Illuminate\Support\Facades\Auth;

class LoginController extends Controller
{
    public function login(Request $request): RedirectResponse
    {
        $credentials = $request->validate([
            'email' => ['required', 'email'],
            'password' => ['required'],
        ]);

        if (Auth::attempt($credentials)) {
            // Authenticatie geslaagd — regenereer de sessie om CSRF-aanvallen te voorkomen
            $request->session()->regenerate();

            return redirect()->intended('/dashboard');
        }

        // Authenticatie mislukt
        return back()->withErrors([
            'email' => 'E-mailadres of wachtwoord is onjuist.',
        ])->onlyInput('email');
    }
}
```

Aan het eerste argument van `Auth::attempt()` geef je een array met inloggegevens door.
Het wachtwoord wordt automatisch vergeleken met de hash, dus geef het als platte tekst door.

Om een "ingelogd blijven"-functie te implementeren, geef je `true` door als tweede argument.

```php theme={null}
// De waarde van de "ingelogd blijven"-checkbox gebruiken
Auth::attempt($credentials, $request->boolean('remember'));
```

<Info>
  Ook als je handmatige authenticatie implementeert, is het aan te raden de code van de starter kit als referentie te gebruiken. Die dient als voorbeeld van een veilige implementatie.
</Info>

## Uitloggen

Om een gebruiker uit te loggen, roep je `Auth::logout()` aan.
Het is een best practice om daarbij ook de sessie ongeldig te maken en het CSRF-token opnieuw te genereren.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\RedirectResponse;
use Illuminate\Support\Facades\Auth;

class LogoutController extends Controller
{
    public function logout(Request $request): RedirectResponse
    {
        Auth::logout();

        // De sessie ongeldig maken
        $request->session()->invalidate();

        // Het CSRF-token opnieuw genereren
        $request->session()->regenerateToken();

        return redirect('/');
    }
}
```

Gebruik voor de route de POST-methode.

```php theme={null}
Route::post('/logout', [LogoutController::class, 'logout'])->middleware('auth');
```

In een Blade-template verstuur je het POST-request via een formulier.

```blade theme={null}
<form method="POST" action="/logout">
    @csrf
    <button type="submit">Uitloggen</button>
</form>
```

## Samenvatting

| Wat je wilt doen             | Hoe                                 |
| ---------------------------- | ----------------------------------- |
| Snel authenticatie toevoegen | Starter kit (`laravel new`)         |
| De huidige gebruiker ophalen | `Auth::user()` / `$request->user()` |
| De inlogstatus controleren   | `Auth::check()`                     |
| Routes beveiligen            | `->middleware('auth')`              |
| Handmatig inloggen           | `Auth::attempt($credentials)`       |
| Uitloggen                    | `Auth::logout()`                    |

## Volgende stap

<Card title="Middleware" icon="shield-halved" href="/nl/middleware">
  Leer in detail hoe de `auth`-middleware werkt en hoe je je eigen middleware maakt.
</Card>


## Related topics

- [Hashing](/nl/hashing.md)
- [Introductie tot Eloquent](/nl/eloquent.md)
- [Introductie tot Eloquent-relaties](/nl/eloquent-relationships.md)
- [Introductie tot Laravel Nightwatch](/nl/blog/nightwatch-introduction.md)
- [Frontend](/nl/frontend.md)