PHP password_hash() et password_verify() : mots de passe

Stockez les mots de passe avec password_hash($password, PASSWORD_DEFAULT) et vérifiez une connexion avec password_verify($password, $hash), qui renvoie true ou false. Ne stockez jamais le mot de passe lui-même, et n'utilisez jamais md5() ou sha1() pour cela.

<?php
$hash = password_hash('correct horse battery staple', PASSWORD_DEFAULT);
echo $hash, "\n";

var_dump(password_verify('correct horse battery staple', $hash));
var_dump(password_verify('Correct horse battery staple', $hash));

Exécutez-le deux fois : le hash est différent à chaque fois, et les deux versions sont validées. C'est pareil pour chaque hash de cette page, donc votre sortie ne correspondra à celle de personne d'autre.

Se connecter avec password_verify

Une connexion compare le mot de passe envoyé au hash enregistré à la création du compte. Ce bloc « inscrit » un utilisateur puis affiche un formulaire de connexion ; essayez le bon mot de passe (hunter2), puis un mauvais.

<?php
// The users table: one row, hashed when the account was created
$users = ['ada@example.com' => password_hash('hunter2', PASSWORD_DEFAULT)];

$email = trim((string) ($_POST['email'] ?? 'ada@example.com'));
$message = '';

if (($_SERVER['REQUEST_METHOD'] ?? 'GET') === 'POST') {
    $hash = $users[$email] ?? null;
    if ($hash !== null && password_verify((string) ($_POST['password'] ?? ''), $hash)) {
        $message = 'Welcome back, ' . htmlspecialchars($email) . '.';
    } else {
        $message = 'Wrong email or password.';
    }
}
?>
<form method="post">
  <input name="email" value="<?= htmlspecialchars($email) ?>">
  <input name="password" type="password" placeholder="Password">
  <button>Log in</button>
</form>
<p><?= $message ?></p>

Le message d'erreur est le même pour un email inconnu et un mauvais mot de passe. Dire lequel était faux indique à un attaquant quels emails ont un compte. Après une connexion réussie, un vrai site stocke l'identifiant de l'utilisateur dans la session, comme le montre la page sur les sessions.

Ce que contient le hash

Un hash bcrypt est une chaîne qui contient tout ce dont password_verify() a besoin : l'algorithme, le coût et le sel, suivis du hash lui-même. password_get_info() relit les premières parties.

<?php
$hash = password_hash('secret', PASSWORD_DEFAULT);
echo $hash, "\n";
echo strlen($hash), " characters\n\n";

[, $algo, $cost, $rest] = explode('$', $hash);
echo "algorithm: $algo (bcrypt)\n";
echo "cost:      $cost\n";
echo 'salt:      ', substr($rest, 0, 22), "\n";
echo 'hash:      ', substr($rest, 22), "\n\n";

print_r(password_get_info($hash));

Comme le sel est stocké dans le hash, une seule colonne de base de données suffit, et deux utilisateurs avec le même mot de passe obtiennent quand même des hashs différents. Faites de cette colonne un VARCHAR(255) : bcrypt fait 60 caractères, mais PASSWORD_DEFAULT a le droit de passer à un algorithme dont la sortie est plus longue.

Choisir le coût

Le coût est la lenteur volontaire de chaque hash, et chaque cran supplémentaire double le travail. PHP 8.3 utilise le coût 10 pour bcrypt (PHP 8.4 a relevé la valeur par défaut à 12). Une connexion devrait prendre environ 100 à 300 ms de hachage ; mesurez-le sur votre propre serveur :

<?php
foreach ([10, 11, 12] as $cost) {
    $start = hrtime(true);
    password_hash('secret', PASSWORD_BCRYPT, ['cost' => $cost]);
    printf("cost %d: %.0f ms\n", $cost, (hrtime(true) - $start) / 1e6);
}

Les chiffres dépendent de la machine, mais chaque ligne devrait valoir environ le double de la précédente. Plus haut est plus sûr contre le cassage et plus lent pour chaque connexion, choisissez donc le coût le plus élevé que votre page de connexion peut se permettre.

Mettre à jour les anciens hashs avec password_needs_rehash

Quand vous relevez le coût ou que PHP change PASSWORD_DEFAULT, les hashs existants continuent de fonctionner, et password_needs_rehash() vous dit lesquels sont dépassés. Le seul moment où vous avez le mot de passe en clair est la connexion, c'est donc là que vous faites la mise à jour :

<?php
$options = ['cost' => 12];

// A hash created years ago with cost 10
$stored = password_hash('hunter2', PASSWORD_DEFAULT, ['cost' => 10]);
echo 'stored: ', substr($stored, 0, 7), "...\n";

$input = 'hunter2';
if (password_verify($input, $stored)) {
    if (password_needs_rehash($stored, PASSWORD_DEFAULT, $options)) {
        $stored = password_hash($input, PASSWORD_DEFAULT, $options);
        echo "Rehashed and saved: ", substr($stored, 0, 7), "...\n";
    }
    echo "Logged in.\n";
}

var_dump(password_needs_rehash($stored, PASSWORD_DEFAULT, $options));

Le préfixe $2y$10$ devient $2y$12$, et à la connexion suivante password_needs_rehash() renvoie false.

N'utilisez jamais md5 ni sha1 pour les mots de passe

md5() et sha1() sont des fonctions de hachage génériques rapides et sans sel. La rapidité est exactement ce qu'il ne faut pas pour les mots de passe : un attaquant qui a récupéré une table peut essayer des milliards de tentatives par seconde sur un GPU, et le hash sans sel d'un mot de passe courant se trouve déjà dans des tables de correspondance publiques. Comparez la vitesse :

<?php
echo md5('password'), "\n";       // the same on every server, forever

$start = hrtime(true);
for ($i = 0; $i < 100000; $i++) {
    md5("password$i");
}
printf("100,000 md5 hashes: %.0f ms\n", (hrtime(true) - $start) / 1e6);

$start = hrtime(true);
password_hash('password', PASSWORD_DEFAULT);
printf("1 password_hash:    %.0f ms\n", (hrtime(true) - $start) / 1e6);

Dans le temps où password_hash() produit un hash, md5 en produit des centaines de milliers, donc chaque tentative d'un casseur coûte autant de fois moins cher. Cherchez 5f4dcc3b5aa765d61d8327deb882cf99 et vous trouverez immédiatement le mot « password ».

Si vous héritez d'une table de hashs md5, vous ne pouvez pas les convertir directement. Enveloppez-les plutôt : stockez password_hash($oldMd5) et vérifiez avec password_verify(md5($input), $stored), puis remplacez chacun par un hash normal à la prochaine connexion de cet utilisateur.

Argon2id et la limite de 72 octets

PASSWORD_ARGON2ID utilise plus de mémoire par hash, ce qui rend le cassage par GPU bien plus coûteux. Il est disponible quand PHP est compilé avec libargon2 (c'est le cas de la plupart des paquets Linux) ; vérifiez avec defined('PASSWORD_ARGON2ID').

<?php
if (defined('PASSWORD_ARGON2ID')) {
    $hash = password_hash('secret', PASSWORD_ARGON2ID);
    echo $hash, "\n";
    var_dump(password_verify('secret', $hash));
}

// bcrypt only looks at the first 72 bytes of the password
$a = str_repeat('a', 72) . 'X';
$b = str_repeat('a', 72) . 'Y';
var_dump(password_verify($b, password_hash($a, PASSWORD_BCRYPT)));

La dernière ligne affiche bool(true) : deux mots de passe différents correspondent, car bcrypt ignore tout ce qui suit l'octet 72. Les vrais mots de passe atteignent rarement cette taille, mais des phrases de passe en japonais ou dans d'autres écritures multioctets atteignent 72 octets vers 24 caractères. Si vous autorisez des mots de passe très longs, utilisez Argon2id, qui n'a pas cette limite. password_verify() fonctionne avec les deux algorithmes, vous pouvez donc changer avec password_needs_rehash() comme ci-dessus.