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

# Einführung in die Authentifizierung

> Erläutert die Grundlagen der Laravel-Authentifizierung – von der Einführung eines Auth-Systems über ein Starter Kit bis zum Abrufen des angemeldeten Benutzers.

## Was ist Authentifizierung

Authentifizierung ist der Vorgang, mit dem festgestellt wird, wer der zugreifende Benutzer ist.
In Webanwendungen nimmt ein Login-Formular E-Mail und Passwort entgegen und speichert bei korrekten Angaben die Benutzerinformationen in der Session.
Bei nachfolgenden Anfragen wird der Benutzer über diese Session identifiziert.

Die Authentifizierung in Laravel basiert auf zwei Konzepten: „Guards" und „Providers".

* **Guards**: Definieren, wie Benutzer bei jeder Anfrage authentifiziert werden. Der Standard ist der `session`-Guard, der Zustand über Session und Cookies verwaltet.
* **Providers**: Definieren, wie Benutzer aus der Datenbank abgerufen werden. Der Standard nutzt Eloquent.

<Info>
  Die Konfigurationsdatei für die Authentifizierung ist `config/auth.php`. Für die meisten Webanwendungen reicht die Standardkonfiguration aus.
</Info>

```mermaid theme={null}
flowchart TD
    A["Login-Request"] --> B["Guard<br>(definiert Authentifizierungsmethode)"]
    B --> C["Provider<br>(holt Benutzer aus der DB)"]
    C --> D{"Authentifizierungsprüfung"}
    D -- "Erfolg" --> E["Benutzerinformationen<br>in Session speichern"]
    E --> F["Weiterleitung zu<br>authentifizierten Seiten"]
    D -- "Fehlschlag" --> G["Weiterleitung zur<br>Login-Seite"]
```

## Authentifizierung per Starter Kit

Wenn Sie eine Anwendung mit `laravel new` erstellen und ein Starter Kit auswählen, werden Login, Registrierung, Passwort-Reset und weitere Auth-Funktionen automatisch erzeugt. Das ist der empfohlene Weg.

<Steps>
  <Step title="Anwendung erstellen">
    Legen Sie die Anwendung mit dem Laravel Installer an. Unterwegs erscheint eine Auswahl für das Starter Kit.

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

    Als Starter Kit stehen **React**, **Vue**, **Livewire** und **Svelte** zur Auswahl.
    Wählen Sie es entsprechend Ihres Tech-Stacks aus.
  </Step>

  <Step title="Frontend-Abhängigkeiten installieren">
    ```shell theme={null}
    cd my-app
    npm install && npm run build
    ```
  </Step>

  <Step title="Datenbank vorbereiten">
    Prüfen Sie die Datenbank-Konfiguration in `.env` und führen Sie die Migrationen aus.

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

    Die initialen Migrationen einschließlich der Tabelle `users` werden angewendet.
  </Step>

  <Step title="Entwicklungsserver starten">
    ```shell theme={null}
    composer run dev
    ```

    Wenn Sie im Browser `http://localhost:8000` aufrufen, sehen Sie in der Navigation die Links „Register" und „Log in".
    Rufen Sie `/register` auf und registrieren Sie einen Benutzer.
  </Step>
</Steps>

Mit einem Starter Kit stehen Ihnen sofort die folgenden Funktionen zur Verfügung:

| Funktion              | URL                 |
| --------------------- | ------------------- |
| Benutzerregistrierung | `/register`         |
| Login                 | `/login`            |
| Passwort-Reset        | `/forgot-password`  |
| E-Mail-Bestätigung    | `/email/verify`     |
| Profil bearbeiten     | `/settings/profile` |

<Tip>
  Der vom Starter Kit erzeugte Code (Controller, Routen, Views) liegt vollständig in Ihrer eigenen Anwendung. Sie können ihn frei anpassen.
</Tip>

### Verfügbare Starter Kits

#### React

Baut eine moderne SPA mit React 19, TypeScript, Tailwind und [shadcn/ui](https://ui.shadcn.com).
Dank [Inertia](https://inertiajs.com) behalten Sie das serverseitige Routing bei und nutzen gleichzeitig ein React-Frontend.

#### Vue

Setzt auf die Vue Composition API, TypeScript, Tailwind und [shadcn-vue](https://www.shadcn-vue.com/).
Wie bei React wird Inertia zur Verbindung mit dem Server verwendet.

#### Livewire

Verwendet [Livewire](https://livewire.laravel.com), sodass Sie dynamische UIs allein mit PHP aufbauen.
Ideal für Teams, die auf Blade-Templates fokussiert sind oder ohne JavaScript-Framework auskommen möchten.
Enthält die Komponentenbibliothek [Flux UI](https://fluxui.dev).

#### Svelte

Verwendet Svelte 5, TypeScript, Tailwind und [shadcn-svelte](https://www.shadcn-svelte.com/).
In Kombination mit Inertia bauen Sie eine moderne SPA.

## Die Auth-Facade

Mit der Facade `Auth` rufen Sie Informationen des aktuell angemeldeten Benutzers ab und prüfen dessen Authentifizierungsstatus.

### Angemeldeten Benutzer abrufen

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

// Aktuellen Benutzer abrufen
$user = Auth::user();

// Nur die Benutzer-ID abrufen
$id = Auth::id();
```

In Controllern lässt sich der Benutzer auch über das `Request`-Objekt abrufen.

```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]);
    }
}
```

### Authentifizierungsstatus prüfen

`Auth::check()` liefert `true`/`false`, je nachdem ob ein Benutzer angemeldet ist.

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

if (Auth::check()) {
    // angemeldet
} else {
    // nicht angemeldet
}
```

In Blade-Templates sind die Direktiven `@auth` und `@guest` praktisch.

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

@guest
    <a href="/login">Login</a>
    <a href="/register">Registrieren</a>
@endguest
```

## Routen schützen

Um Routen ausschließlich für angemeldete Benutzer zugänglich zu machen, verwenden Sie die Middleware `auth`.

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

// Nur für angemeldete Benutzer erreichbar
Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware('auth');
```

Nicht angemeldete Nutzer werden automatisch zu `/login` weitergeleitet.

Um mehrere Routen gleichzeitig zu schützen, verwenden Sie eine Gruppe.

```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>
  Wenn Sie die Middleware `auth` vergessen, können nicht angemeldete Benutzer zugreifen. Wenden Sie sie unbedingt auf jede schützenswerte Route an.
</Warning>

### Routen nur für Gäste

Um bereits angemeldete Benutzer weiterzuleiten, verwenden Sie die Middleware `guest`.
Wenden Sie sie zum Beispiel auf Login- oder Register-Seiten an, damit bereits eingeloggte Benutzer ans Dashboard geleitet werden.

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

## Manuelle Authentifizierung

Wenn Sie ohne Starter Kit selbst einen Login umsetzen, nutzen Sie `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)) {
            // Authentifizierung erfolgreich – Session neu generieren, um CSRF vorzubeugen
            $request->session()->regenerate();

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

        // Authentifizierung fehlgeschlagen
        return back()->withErrors([
            'email' => 'E-Mail oder Passwort sind nicht korrekt.',
        ])->onlyInput('email');
    }
}
```

Übergeben Sie `Auth::attempt()` als erstes Argument ein Array mit Anmeldedaten.
Das Passwort wird automatisch gegen den Hash verglichen – übergeben Sie es also im Klartext.

Um „Angemeldet bleiben" zu unterstützen, übergeben Sie im zweiten Argument `true`.

```php theme={null}
// Wert der Checkbox „Angemeldet bleiben" verwenden
Auth::attempt($credentials, $request->boolean('remember'));
```

<Info>
  Auch bei manueller Umsetzung sollten Sie den Code aus dem Starter Kit als Referenz für eine sichere Implementierung nutzen.
</Info>

## Logout

Zum Ausloggen rufen Sie `Auth::logout()` auf.
Zusätzlich sollten Sie die Session invalidieren und das CSRF-Token neu generieren.

```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();

        // Session invalidieren
        $request->session()->invalidate();

        // CSRF-Token neu generieren
        $request->session()->regenerateToken();

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

Verwenden Sie für die Route die POST-Methode.

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

In Blade-Templates senden Sie den POST-Request per Formular.

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

## Zusammenfassung

| Aufgabe                            | Weg                                 |
| ---------------------------------- | ----------------------------------- |
| Auth-Funktionen schnell hinzufügen | Starter Kit (`laravel new`)         |
| Aktuellen Benutzer abrufen         | `Auth::user()` / `$request->user()` |
| Login-Status prüfen                | `Auth::check()`                     |
| Routen schützen                    | `->middleware('auth')`              |
| Manuell einloggen                  | `Auth::attempt($credentials)`       |
| Ausloggen                          | `Auth::logout()`                    |

## Nächste Schritte

<Card title="Middleware" icon="shield-halved" href="/de/middleware">
  Lernen Sie die Funktionsweise der `auth`-Middleware und wie Sie eigene Middleware schreiben.
</Card>


## Related topics

- [Hashing](/de/hashing.md)
- [Starter Kits](/de/starter-kits.md)
- [Einführung in Eloquent](/de/eloquent.md)
- [Laravel Fortify und Starter-Kits](/de/advanced/fortify.md)
- [E-Mail-Verifizierung (Email Verification)](/de/verification.md)