Gérer la sécurité | Med Learning

Leçon 1

Ce que Laravel protège, et ce qui reste à faire

Risque (module M108)	Protection de Laravel	Ce que tu dois faire
injection SQL	requêtes préparées (Eloquent, Query Builder)	ne jamais concaténer une saisie dans `DB::select`, `whereRaw`, `orderBy`
XSS (script injecté)	`{{ }}` échappe tout	ne jamais utiliser `{!! !!}` avec une saisie
CSRF	jeton + `PreventRequestForgery`	`@csrf` dans chaque formulaire, pas de modification en GET
mots de passe	hachage bcrypt ou Argon2	ne jamais stocker ni afficher un mot de passe en clair
vol / fixation de session	cookies chiffrés, `HttpOnly`, `SameSite`	régénérer la session à la connexion, HTTPS en production
contrôle d'accès défaillant (n° 1 de l'OWASP)	middlewares `auth`, Gates, Policies	vérifier chaque action sur chaque ressource
affectation de masse	`$fillable` / `$guarded`	ne jamais mettre `role` ou `est_admin` dans `$fillable`
force brute	`throttle`, `RateLimiter`	limiter les tentatives de connexion
fuite d'informations	page d'erreur détaillée seulement si `APP_DEBUG=true`	`APP_DEBUG=false` en production, `.env` jamais versionné
fichiers malveillants	validation `mimes`, `image`, noms générés	valider le type et la taille, stocker hors de `public/` si privé

Leçon 2

L'authentification : les notions

Leçon 3

Les kits de démarrage

Leçon 4

L'authentification à la main

Instruction	Rôle
`Auth::attempt(['email' => …, 'password' => …], $remember)`	cherche l'utilisateur par e-mail, compare le mot de passe avec le hachage, ouvre la session si c'est bon ; renvoie `true` / `false`
`$request->session()->regenerate()`	change l'identifiant de session après la connexion (contre la fixation de session)
`redirect()->intended(...)`	renvoie vers la page que l'utilisateur voulait voir avant d'être redirigé vers la connexion
`onlyInput('email')`	réaffiche l'e-mail, jamais le mot de passe

Leçon 5

Le hachage des mots de passe

Hachage (`Hash`)	Chiffrement (`Crypt`)
à sens unique : impossible de retrouver la valeur	réversible avec la clé
pour les mots de passe	pour des données à relire : numéro de téléphone, jeton d'un service externe
bcrypt, Argon2id	AES-256 avec la clé `APP_KEY`
on compare (`Hash::check`)	on déchiffre (`Crypt::decryptString`)

Leçon 6

Le chiffrement

Leçon 7

Les autorisations

Où	Écriture
dans un contrôleur	`Gate::authorize('update', $commande);` (403 si refusé)
avec l'utilisateur	`if ($request->user()->cannot('view', $commande)) { abort(403); }`
action sans modèle (créer)	`Gate::authorize('create', Commande::class);`
sur une route	`->middleware('can:update,commande')` ou `->can('update', 'commande')`
dans une vue	`@can('update', $commande) … @endcan`, `@cannot`, `@canany`

Leçon 8

Les autres protections

Réglage (`.env` de production)	Pourquoi
`APP_ENV=production`	active les comportements de production
`APP_DEBUG=false`	une erreur n'affiche plus le code, les requêtes ni les variables d'environnement
`APP_URL=https://kitab.ma`	les URL générées sont en HTTPS
`SESSION_SECURE_COOKIE=true`	le cookie de session n'est envoyé qu'en HTTPS
`APP_KEY` unique et secrète	une clé différente du développement

Leçon 9

Protéger une API avec Sanctum

Leçon 10

Les vidéos du chapitre

Vidéo · À regarder

30 Days to Learn Laravel - Complete 8 Hour Course

Laracasts (Jeffrey Way) · YouTube

Regarde de 4:42:29 à 5:24:0941 min 40 s

Ouvrir sur YouTube à 4:42:29

Vidéo · À regarder

30 Days to Learn Laravel - Complete 8 Hour Course

Laracasts (Jeffrey Way) · YouTube

Regarde de 5:24:09 à 5:47:02

Travaux pratiques

TP fil rouge · Les comptes de Kitab

Exercices

Exercice 12.1

Choisis la bonne réponse

1« Qui es-tu ? » relève de…
2Auth::attempt() compare le mot de passe saisi…
3Après une connexion réussie, on appelle…
4Un mot de passe doit être…
5La route vers laquelle auth redirige un visiteur s'appelle…
6La policy du modèle Livre s'appelle par convention…
7En Laravel 13, dans un contrôleur, on vérifie une policy avec…
8Une API Sanctum attend le jeton dans l'en-tête…

0/8 répondues

Exercice 12.2

Hacher ou chiffrer ?

Exercice 12.3

Trouve les failles

L'essentiel du chapitre

À retenir

Authentification (qui es-tu ?) ≠ autorisation (as-tu le droit ?). config/auth.php : guard web (session), provider users (Eloquent). Auth::user(), Auth::id(), Auth::check(), $request->user(), @auth, @guest.
Kits Laravel 13 : React, Vue, Svelte, Livewire (Fortify : inscription, connexion, mot de passe oublié, vérification, 2FA). Breeze : plus mis à jour depuis Laravel 12.
À la main : routes guest (inscription, connexion nommée login) et auth (déconnexion en POST) ; User::create($valide) (cast hashed) + Auth::login ; Auth::attempt($identifiants, $remember) + session()->regenerate() + redirect()->intended() ; échec : back()->withErrors()->onlyInput('email') ; déconnexion : Auth::logout(), invalidate(), regenerateToken(). Password::defaults().
Hachage (sens unique, mots de passe) : Hash::make, Hash::check, bcrypt/Argon2id ; jamais md5/sha1, jamais Crypt pour un mot de passe. Chiffrement (réversible, APP_KEY, AES-256) : Crypt::encryptString / decryptString, cast encrypted.
Gates : Gate::define('nom', fn (User $user) => …) dans AppServiceProvider ; Gate::allows, denies, authorize, can:nom. Policies : make:policy XPolicy --model=X, méthodes viewAny, view, create, update, delete, before() ; découverte automatique ; Gate::authorize('update', $x), $user->can(), ->can('update', 'x'), @can. Vérifier chaque ressource (IDOR).

Lire l'utilisateur connecté

php

use Illuminate\Support\Facades\Auth;

$user = Auth::user();          // le modèle User connecté, ou null
$id   = Auth::id();            // son id, ou null
$ok   = Auth::check();         // true si quelqu'un est connecté

$user = auth()->user();        // assistant équivalent
$user = $request->user();      // depuis la requête (le plus courant dans un contrôleur)

routes/web.php (extrait)

php

use App\Http\Controllers\Auth\ConnexionController;
use App\Http\Controllers\Auth\InscriptionController;

Route::middleware('guest')->group(function () {
    Route::get('/inscription', [InscriptionController::class, 'create'])->name('register');
    Route::post('/inscription', [InscriptionController::class, 'store']);
    Route::get('/connexion', [ConnexionController::class, 'create'])->name('login');
    Route::post('/connexion', [ConnexionController::class, 'store'])->middleware('throttle:5,1');
});

Route::post('/deconnexion', [ConnexionController::class, 'destroy'])
    ->middleware('auth')
    ->name('logout');

app/Http/Controllers/Auth/InscriptionController.php

php

<?php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Models\User;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Validation\Rules\Password;
use Illuminate\View\View;

class InscriptionController extends Controller
{
    public function create(): View
    {
        return view('auth.inscription');
    }

    public function store(Request $request): RedirectResponse
    {
        $valide = $request->validate([
            'name' => ['required', 'string', 'max:80'],
            'email' => ['required', 'string', 'lowercase', 'email', 'max:255', 'unique:users,email'],
            'password' => ['required', 'confirmed', Password::defaults()],
        ]);

        $user = User::create($valide);    // le mot de passe est haché par le cast 'hashed' du modèle

        Auth::login($user);               // connecte immédiatement le nouvel utilisateur
        $request->session()->regenerate();

        return redirect()->route('accueil')->with('status', 'Bienvenue sur Kitab !');
    }
}

app/Http/Controllers/Auth/ConnexionController.php

php

<?php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\View\View;

class ConnexionController extends Controller
{
    public function create(): View
    {
        return view('auth.connexion');
    }

    public function store(Request $request): RedirectResponse
    {
        $identifiants = $request->validate([
            'email' => ['required', 'email'],
            'password' => ['required'],
        ]);

        if (Auth::attempt($identifiants, $request->boolean('remember'))) {
            $request->session()->regenerate();          // contre la fixation de session

            return redirect()->intended(route('accueil'));   // la page demandée avant la connexion
        }

        return back()
            ->withErrors(['email' => 'Ces identifiants ne correspondent à aucun compte.'])
            ->onlyInput('email');
    }

    public function destroy(Request $request): RedirectResponse
    {
        Auth::logout();
        $request->session()->invalidate();      // vide la session
        $request->session()->regenerateToken(); // nouveau jeton CSRF

        return redirect('/');
    }
}

php

use Illuminate\Support\Facades\Hash;

$empreinte = Hash::make('Kitab-2026!');
// "$2y$12$Qm...": bcrypt, coût 12, sel inclus ; deux appels donnent deux empreintes différentes

Hash::check('Kitab-2026!', $empreinte);     // true
Hash::check('kitab-2026!', $empreinte);     // false
Hash::needsRehash($empreinte);              // true si l'algorithme ou le coût a changé depuis

php

use Illuminate\Contracts\Encryption\DecryptException;
use Illuminate\Support\Facades\Crypt;

$chiffre = Crypt::encryptString('0612345678');     // "eyJpdiI6Ik..." (différent à chaque appel)

try {
    $clair = Crypt::decryptString($chiffre);       // "0612345678"
} catch (DecryptException $e) {
    // valeur modifiée ou clé différente
}

app/Models/User.php (extrait)

php

public function estAdmin(): bool
{
    return $this->role === 'admin';
}

public function estLibraire(): bool
{
    return in_array($this->role, ['admin', 'libraire'], true);
}

app/Providers/AppServiceProvider.php (extrait)

php

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

public function boot(): void
{
    Gate::define('acceder-admin', fn (User $user) => $user->estLibraire());
    Gate::define('gerer-utilisateurs', fn (User $user) => $user->estAdmin());
}

Utiliser une Gate

php

use Illuminate\Support\Facades\Gate;

if (Gate::allows('gerer-utilisateurs')) { /* ... */ }
if (Gate::denies('acceder-admin')) { abort(403); }
Gate::authorize('gerer-utilisateurs');      // lève une erreur 403 si refusé

Route::get('/admin/utilisateurs', fn () => 'Comptes')->middleware('can:gerer-utilisateurs');

app/Policies/CommandePolicy.php

php

<?php

namespace App\Policies;

use App\Models\Commande;
use App\Models\User;

class CommandePolicy
{
    /** Les administrateurs ont tous les droits (vérifié avant chaque méthode). */
    public function before(User $user, string $ability): ?bool
    {
        return $user->estAdmin() ? true : null;     // null : on laisse décider la méthode
    }

    public function viewAny(User $user): bool
    {
        return true;                                 // chacun voit la liste de SES commandes
    }

    public function view(User $user, Commande $commande): bool
    {
        return $user->id === $commande->user_id;     // seulement le propriétaire
    }

    public function create(User $user): bool
    {
        return $user->hasVerifiedEmail();
    }

    public function update(User $user, Commande $commande): bool
    {
        return $user->id === $commande->user_id && $commande->statut === 'en_attente';
    }

    public function delete(User $user, Commande $commande): bool
    {
        return false;                                // seul l'admin (via before) peut supprimer
    }
}

app/Providers/AppServiceProvider.php (extrait)

php

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;

public function boot(): void
{
    RateLimiter::for('connexion', function (Request $request) {
        return Limit::perMinute(5)->by($request->input('email') . '|' . $request->ip());
    });
}

php

use Illuminate\Support\Facades\URL;

$lien = URL::temporarySignedRoute('factures.telecharger', now()->addHours(24), ['commande' => $commande->id]);

Route::get('/factures/{commande}', [FactureController::class, 'telecharger'])
    ->name('factures.telecharger')
    ->middleware('signed');           // 403 si la signature est absente, fausse ou expirée

routes/api.php (extrait)

php

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

Route::post('/jetons', function (Request $request) {
    $request->validate(['email' => 'required|email', 'password' => 'required', 'appareil' => 'required']);

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

    if (! $user || ! Hash::check($request->password, $user->password)) {
        throw ValidationException::withMessages(['email' => ['Identifiants incorrects.']]);
    }

    return ['jeton' => $user->createToken($request->appareil)->plainTextToken];
})->middleware('throttle:5,1');

Route::middleware('auth:sanctum')->group(function () {
    Route::get('/moi', fn (Request $request) => $request->user());
    Route::get('/mes-commandes', fn (Request $request) => $request->user()->commandes()->latest()->get());
});

resources/views/auth/connexion.blade.php

blade

<x-layout titre="Connexion">
    <h1>Connexion</h1>
    <form method="POST" action="{{ route('login') }}">
        @csrf
        <label for="email">Adresse e-mail</label>
        <input id="email" type="email" name="email" value="{{ old('email') }}" required autofocus autocomplete="username">
        @error('email') <p class="message-erreur">{{ $message }}</p> @enderror

        <label for="password">Mot de passe</label>
        <input id="password" type="password" name="password" required autocomplete="current-password">

        <label><input type="checkbox" name="remember"> Se souvenir de moi</label>

        <button type="submit">Se connecter</button>
        <p>Pas de compte ? <a href="{{ route('register') }}">Inscris-toi</a></p>
    </form>
</x-layout>

Le bouton de déconnexion (dans le menu)

blade

@auth
    <form method="POST" action="{{ route('logout') }}">
        @csrf
        <button type="submit">Se déconnecter ({{ auth()->user()->name }})</button>
    </form>
@endauth

app/Http/Controllers/CommandeController.php (extrait)

php

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

public function index(Request $request): View
{
    $commandes = $request->user()->commandes()->latest()->paginate(10);   // seulement les siennes
    return view('commandes.index', compact('commandes'));
}

public function show(Commande $commande): View
{
    Gate::authorize('view', $commande);         // 403 si ce n'est pas sa commande
    return view('commandes.show', ['commande' => $commande->load('livres')]);
}

php

Route::get('/inscription', function (Request $request) {
    $user = User::create($request->all());
    $user->password = md5($request->password);
    $user->save();
    Auth::login($user);
    return redirect($request->input('retour'));
});