Passer au contenu principal

Qu’est-ce que le hachage

Le hachage (hashing) est le processus qui transforme des données en clair, comme un mot de passe, en une chaîne de longueur fixe via une conversion à sens unique. La même entrée produit toujours le même hachage, mais il est impossible de reconstituer le texte clair à partir d’un hachage. La façade Hash de Laravel prend en charge les algorithmes bcrypt et Argon2 pour stocker les mots de passe en toute sécurité.

Comparaison des algorithmes

AlgorithmeCaractéristiquesUsage recommandé
bcryptCoût de calcul ajustable via le work factor (rounds). Par défautApplications web classiques
argon2iMémoire, temps et threads ajustables. Résistant aux attaques par canaux auxiliairesContextes à haute sécurité
argon2idHybride argon2i/argon2d. Recommandé par PHCUtilisation d’Argon2 dans un nouveau projet
Le « work factor » de bcrypt contrôle le temps de calcul du hachage. Plus le hachage est lent, plus il résiste aux attaques par force brute. À mesure que le matériel s’améliore, augmentez le work factor pour maintenir la sécurité.

Flux de hachage et vérification


Configuration

Par défaut, Laravel utilise le driver bcrypt. Modifiez-le via la variable d’environnement HASH_DRIVER.
# .env
HASH_DRIVER=bcrypt  # bcrypt / argon / argon2id
Pour personnaliser la configuration de hachage, publiez le fichier de configuration avec config:publish.
php artisan config:publish hashing
Après publication, modifiez le work factor par défaut et autres options dans config/hashing.php.

Utilisation de base

Hacher un mot de passe

Passez le mot de passe en clair à Hash::make() pour obtenir un hachage. Stockez cette valeur en base de données.
<?php

namespace App\Http\Controllers;

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

class PasswordController extends Controller
{
    public function update(Request $request): RedirectResponse
    {
        $request->validate([
            'password' => ['required', 'min:8', 'confirmed'],
        ]);

        $request->user()->fill([
            'password' => Hash::make($request->password),
        ])->save();

        return redirect('/profile');
    }
}
Stockez la valeur hachée en base, mais ne stockez jamais le mot de passe en clair.

Ajuster le work factor de bcrypt

L’option rounds ajuste le coût de calcul. Une valeur élevée est plus sûre, mais plus lente. La valeur par défaut (12) convient à la plupart des applications.
$hashed = Hash::make('plain-text-password', [
    'rounds' => 14,
]);

Ajuster le work factor d’Argon2

Avec Argon2, ajustez le coût via memory, time et threads.
$hashed = Hash::make('plain-text-password', [
    'memory'  => 65536, // en KiB
    'time'    => 4,
    'threads' => 2,
]);
OptionDescriptionDéfaut
memoryMémoire utilisée (KiB)65536
timeNombre d’itérations4
threadsNombre de threads1
Consultez la documentation officielle PHP pour le détail des options d’Argon2.

Vérification du mot de passe

Hash::check() permet de vérifier qu’un mot de passe en clair correspond à un hachage stocké. Exemple typique lors du processus de connexion.
use Illuminate\Support\Facades\Hash;

if (Hash::check($request->password, $user->password)) {
    // Le mot de passe correspond
} else {
    // Le mot de passe ne correspond pas
}
Lors de l’utilisation de Auth::attempt(), cette vérification est automatique et vous n’avez pas besoin de l’appeler directement. Hash::check() est utile lorsque vous devez vérifier manuellement le mot de passe courant.
// Exemple : vérification du mot de passe actuel dans un formulaire de changement
if (! Hash::check($request->current_password, $request->user()->password)) {
    return back()->withErrors(['current_password' => 'Le mot de passe actuel est incorrect.']);
}

Détermination du besoin de re-hachage

Hash::needsRehash() indique si le work factor utilisé lors de la génération du hachage diffère de la configuration actuelle. Cela sert à mettre à jour les hachages existants après un changement de work factor.
use Illuminate\Support\Facades\Hash;

if (Hash::needsRehash($user->password)) {
    $user->update([
        'password' => Hash::make($plainTextPassword),
    ]);
}
Exemple de re-hachage lors d’une connexion réussie.
// Re-hachage dans le traitement de connexion
if (Auth::attempt($credentials)) {
    if (Hash::needsRehash(Auth::user()->password)) {
        Auth::user()->update([
            'password' => Hash::make($credentials['password']),
        ]);
    }

    return redirect()->intended('/dashboard');
}
Réévaluez régulièrement le work factor pour suivre l’évolution du matériel et maintenir votre niveau de sécurité. Grâce à needsRehash(), vous pouvez profiter des connexions utilisateur pour mettre à jour naturellement les mots de passe.

Vérification de l’algorithme de hachage

Par défaut, Hash::check() vérifie que le hachage a été généré avec l’algorithme actuellement configuré. Si l’algorithme diffère, une RuntimeException est lancée. Cela protège contre des attaques par altération de l’algorithme. Si vous devez prendre en charge plusieurs algorithmes simultanément (migration en cours), vous pouvez désactiver cette vérification en réglant HASH_VERIFY sur false.
# .env
HASH_VERIFY=false
Régler HASH_VERIFY=false désactive la vérification d’algorithme. Ne l’utilisez que durant la période de migration et remettez true (valeur par défaut) une fois la migration terminée.

Récapitulatif

ObjectifMéthode
Hacher un mot de passeHash::make($password)
Vérifier un hachageHash::check($plain, $hash)
Vérifier si un re-hachage est nécessaireHash::needsRehash($hash)
Changer le driver de hachageVariable d’environnement HASH_DRIVER
Désactiver la vérification d’algorithmeHASH_VERIFY=false

Prochaines étapes

Introduction à l'authentification

Découvrez la vue d’ensemble de l’authentification, notamment l’implémentation de la connexion avec Hash::check().
Dernière modification le 13 juillet 2026