De temps en temps, j'entends le conseil "Utiliser bcrypt pour stocker des mots de passe en PHP, règles bcrypt".

Mais c'est quoi bcrypt? PHP n'offre pas de telles fonctions, Wikipedia babille sur un utilitaire de cryptage de fichiers et les recherches sur le Web révèlent simplement quelques implémentations de Blowfish dans différentes langues. Maintenant Blowfish est également disponible en PHP via mcrypt, mais comment cela aide-t-il à stocker les mots de passe? Blowfish est un chiffrement à usage général, il fonctionne de deux manières. S'il peut être chiffré, il peut être déchiffré. Les mots de passe ont besoin d'une fonction de hachage unidirectionnelle.

Quelle est l'explication?

bcryptest un algorithme de hachage qui est évolutif avec du matériel (via un nombre configurable de tours). Sa lenteur et ses multiples tours garantissent qu'un attaquant doit déployer des fonds et du matériel massifs pour pouvoir casser vos mots de passe. Ajoutez à cela des sels par mot de passe ( bcryptnécessite des sels) et vous pouvez être sûr qu'une attaque est pratiquement impossible sans une somme ridicule de fonds ou de matériel.

bcryptutilise l' algorithme Eksblowfish pour hacher les mots de passe. Alors que la phase de chiffrement d' Eksblowfish et Blowfish sont exactement les mêmes, la phase de planification des clés d' Eksblowfish garantit que tout état ultérieur dépend à la fois du sel et de la clé (mot de passe utilisateur), et aucun état ne peut être précalculé à l'insu des deux. En raison de cette différence clé, il bcrypts'agit d'un algorithme de hachage unidirectionnel. Vous ne pouvez pas récupérer le mot de passe en texte brut sans connaître le sel, les tours et la clé (mot de passe). [ Source ]

Comment utiliser bcrypt:

En utilisant PHP> = 5.5-DEV

Les fonctions de hachage de mot de passe ont maintenant été intégrées directement dans PHP> = 5.5 . Vous pouvez maintenant utiliser password_hash()pour créer un bcrypthachage de n'importe quel mot de passe:

<?php
// Usage 1:
echo password_hash('rasmuslerdorf', PASSWORD_DEFAULT)."\n";
// $2y$10$xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// For example:
// $2y$10$.vGA1O9wmRjrwAVXD98HNOgsNpDczlqm3Jq7KnEd1rVAGv3Fykk1a

// Usage 2:
$options = [
  'cost' => 11
];
echo password_hash('rasmuslerdorf', PASSWORD_BCRYPT, $options)."\n";
// $2y$11$6DP.V0nO7YI3iSki4qog6OQI5eiO6Jnjsqg7vdnb.JgGIsxniOn4C

Pour vérifier un mot de passe fourni par l'utilisateur par rapport à un hachage existant, vous pouvez utiliser le password_verify()comme tel:

<?php
// See the password_hash() example to see where this came from.
$hash = '$2y$07$BCryptRequires22Chrcte/VlQH0piJtjXl.0t1XkA8pw9dMXTpOq';

if (password_verify('rasmuslerdorf', $hash)) {
    echo 'Password is valid!';
} else {
    echo 'Invalid password.';
}

En utilisant PHP> = 5.3.7, <5.5-DEV (également RedHat PHP> = 5.3.3)

Il existe une bibliothèque de compatibilité sur GitHub créée sur la base du code source des fonctions ci-dessus écrites à l'origine en C, qui fournit les mêmes fonctionnalités. Une fois la bibliothèque de compatibilité installée, l'utilisation est la même que ci-dessus (moins la notation du tableau abrégé si vous êtes toujours sur la branche 5.3.x).

Utilisation de PHP <5.3.7 (obsolète)

Vous pouvez utiliser la crypt()fonction pour générer des hachages bcrypt de chaînes d'entrée. Cette classe peut générer automatiquement des sels et vérifier les hachages existants par rapport à une entrée. Si vous utilisez une version de PHP supérieure ou égale à 5.3.7, il est fortement recommandé d'utiliser la fonction intégrée ou la bibliothèque compat . Cette alternative n'est fournie qu'à des fins historiques.

class Bcrypt{
  private $rounds;

  public function __construct($rounds = 12) {
    if (CRYPT_BLOWFISH != 1) {
      throw new Exception("bcrypt not supported in this installation. See http://php.net/crypt");
    }

    $this->rounds = $rounds;
  }

  public function hash($input){
    $hash = crypt($input, $this->getSalt());

    if (strlen($hash) > 13)
      return $hash;

    return false;
  }

  public function verify($input, $existingHash){
    $hash = crypt($input, $existingHash);

    return $hash === $existingHash;
  }

  private function getSalt(){
    $salt = sprintf('$2a$%02d$', $this->rounds);

    $bytes = $this->getRandomBytes(16);

    $salt .= $this->encodeBytes($bytes);

    return $salt;
  }

  private $randomState;
  private function getRandomBytes($count){
    $bytes = '';

    if (function_exists('openssl_random_pseudo_bytes') &&
        (strtoupper(substr(PHP_OS, 0, 3)) !== 'WIN')) { // OpenSSL is slow on Windows
      $bytes = openssl_random_pseudo_bytes($count);
    }

    if ($bytes === '' && is_readable('/dev/urandom') &&
       ($hRand = @fopen('/dev/urandom', 'rb')) !== FALSE) {
      $bytes = fread($hRand, $count);
      fclose($hRand);
    }

    if (strlen($bytes) < $count) {
      $bytes = '';

      if ($this->randomState === null) {
        $this->randomState = microtime();
        if (function_exists('getmypid')) {
          $this->randomState .= getmypid();
        }
      }

      for ($i = 0; $i < $count; $i += 16) {
        $this->randomState = md5(microtime() . $this->randomState);

        if (PHP_VERSION >= '5') {
          $bytes .= md5($this->randomState, true);
        } else {
          $bytes .= pack('H*', md5($this->randomState));
        }
      }

      $bytes = substr($bytes, 0, $count);
    }

    return $bytes;
  }

  private function encodeBytes($input){
    // The following is code from the PHP Password Hashing Framework
    $itoa64 = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

    $output = '';
    $i = 0;
    do {
      $c1 = ord($input[$i++]);
      $output .= $itoa64[$c1 >> 2];
      $c1 = ($c1 & 0x03) << 4;
      if ($i >= 16) {
        $output .= $itoa64[$c1];
        break;
      }

      $c2 = ord($input[$i++]);
      $c1 |= $c2 >> 4;
      $output .= $itoa64[$c1];
      $c1 = ($c2 & 0x0f) << 2;

      $c2 = ord($input[$i++]);
      $c1 |= $c2 >> 6;
      $output .= $itoa64[$c1];
      $output .= $itoa64[$c2 & 0x3f];
    } while (true);

    return $output;
  }
}

Vous pouvez utiliser ce code comme ceci:

$bcrypt = new Bcrypt(15);

$hash = $bcrypt->hash('password');
$isGood = $bcrypt->verify('password', $hash);

Alternativement, vous pouvez également utiliser le framework de hachage PHP portable .

Alors, vous voulez utiliser bcrypt? Impressionnant! Cependant, comme dans d'autres domaines de la cryptographie, vous ne devriez pas le faire vous-même. Si vous devez vous soucier de gérer des clés, de stocker des sels ou de générer des nombres aléatoires, vous vous trompez.

La raison est simple: il est si facile de visser bcrypt . En fait, si vous regardez presque chaque morceau de code sur cette page, vous remarquerez qu'il viole au moins un de ces problèmes courants.

Avouons-le, la cryptographie est difficile.

Laissez-le aux experts. Laissez-le aux personnes dont le travail consiste à entretenir ces bibliothèques. Si vous devez prendre une décision, vous vous trompez.

Utilisez plutôt une bibliothèque. Plusieurs existent selon vos besoins.

Bibliothèques

Voici une ventilation de certaines des API les plus courantes.

API PHP 5.5 - (Disponible pour 5.3.7+)

Depuis PHP 5.5, une nouvelle API de hachage des mots de passe est en cours d'introduction. Il existe également une bibliothèque de compatibilité de shim maintenue (par moi) pour 5.3.7+. Cela a l'avantage d'être une implémentation évaluée par les pairs et simple à utiliser.

function register($username, $password) {
    $hash = password_hash($password, PASSWORD_BCRYPT);
    save($username, $hash);
}

function login($username, $password) {
    $hash = loadHashByUsername($username);
    if (password_verify($password, $hash)) {
        //login
    } else {
        // failure
    }
}

Vraiment, il vise à être extrêmement simple.

Ressources:

• Documentation: sur PHP.net
• Bibliothèque de compatibilité: sur GitHub
• RFC de PHP: sur wiki.php.net

Zend \ Crypt \ Password \ Bcrypt (5.3.2+)

Il s'agit d'une autre API similaire à celle de PHP 5.5 et remplit une fonction similaire.

function register($username, $password) {
    $bcrypt = new Zend\Crypt\Password\Bcrypt();
    $hash = $bcrypt->create($password);
    save($user, $hash);
}

function login($username, $password) {
    $hash = loadHashByUsername($username);
    $bcrypt = new Zend\Crypt\Password\Bcrypt();
    if ($bcrypt->verify($password, $hash)) {
        //login
    } else {
        // failure
    }
}

Ressources:

• Documentation: sur Zend
• Article de blog: hachage de mot de passe avec Zend Crypt

PasswordLib

Il s'agit d'une approche légèrement différente du hachage de mot de passe. Plutôt que de simplement prendre en charge bcrypt, PasswordLib prend en charge un grand nombre d'algorithmes de hachage. Il est principalement utile dans les contextes où vous devez prendre en charge la compatibilité avec les systèmes hérités et disparates qui peuvent être hors de votre contrôle. Il prend en charge un grand nombre d'algorithmes de hachage. Et est pris en charge 5.3.2+

function register($username, $password) {
    $lib = new PasswordLib\PasswordLib();
    $hash = $lib->createPasswordHash($password, '$2y$', array('cost' => 12));
    save($user, $hash);
}

function login($username, $password) {
    $hash = loadHashByUsername($username);
    $lib = new PasswordLib\PasswordLib();
    if ($lib->verifyPasswordHash($password, $hash)) {
        //login
    } else {
        // failure
    }
}

Références:

• Code source / documentation: GitHub

PHPASS

C'est une couche qui prend en charge bcrypt, mais prend également en charge un algorithme assez puissant qui est utile si vous n'avez pas accès à PHP> = 5.3.2 ... Il prend en charge PHP 3.0+ (mais pas avec bcrypt).

function register($username, $password) {
    $phpass = new PasswordHash(12, false);
    $hash = $phpass->HashPassword($password);
    save($user, $hash);
}

function login($username, $password) {
    $hash = loadHashByUsername($username);
    $phpass = new PasswordHash(12, false);
    if ($phpass->CheckPassword($password, $hash)) {
        //login
    } else {
        // failure
    }
}

Ressources

• Code: cvsweb
• Site du projet: sur OpenWall
• Un examen de l'algorithme <5.3.0: sur StackOverflow

Remarque: N'utilisez pas les alternatives PHPASS qui ne sont pas hébergées sur openwall, ce sont des projets différents !!!

À propos de BCrypt

Si vous remarquez, chacune de ces bibliothèques renvoie une seule chaîne. C'est à cause de la façon dont BCrypt fonctionne en interne. Et il y a des tonnes de réponses à ce sujet. Voici une sélection que j'ai écrite, que je ne copierai / collerai pas ici, mais un lien vers:

• Différence fondamentale entre les algorithmes de hachage et de chiffrement - Explication de la terminologie et de quelques informations de base à leur sujet.
• À propos de l'inversion des hachages sans tables arc-en-ciel - Fondamentalement, pourquoi nous devrions utiliser bcrypt en premier lieu ...
• Stockage des hachages bcrypt - pourquoi le sel et l'algorithme sont-ils inclus dans le résultat du hachage?
• Comment mettre à jour le coût des hachages bcrypt - essentiellement comment choisir puis maintenir le coût du hachage bcrypt.
• Comment hacher des mots de passe longs avec bcrypt - expliquant la limite de mot de passe de 72 caractères de bcrypt.
• Comment bcrypt utilise des sels
• Meilleures pratiques pour saler et poivrer les mots de passe - Fondamentalement, n'utilisez pas de "poivre"
• Migration d'anciens md5mots de passe vers bcrypt

Emballer

Il existe de nombreux choix différents. Le choix vous appartient. Cependant, je vous recommande fortement d'utiliser l'une des bibliothèques ci-dessus pour gérer cela pour vous.

Encore une fois, si vous utilisez crypt()directement, vous faites probablement quelque chose de mal. Si votre code utilise directement hash()(ou md5()ou sha1()), vous faites certainement quelque chose de mal.

Utilisez simplement une bibliothèque ...

Vous obtiendrez beaucoup d'informations dans Enough With The Rainbow Tables: Ce que vous devez savoir sur les schémas de mot de passe sécurisés ou le framework de hachage de mot de passe PHP portable .

Le but est de hacher le mot de passe avec quelque chose de lent, donc quelqu'un qui obtient votre base de données de mots de passe mourra en essayant de le forcer brutalement (un délai de 10 ms pour vérifier un mot de passe n'est rien pour vous, beaucoup pour quelqu'un qui essaie de le forcer brutalement). Bcrypt est lent et peut être utilisé avec un paramètre pour choisir sa lenteur.

Vous pouvez créer un hachage unidirectionnel avec bcrypt en utilisant la crypt()fonction PHP et en passant un sel Blowfish approprié. Le plus important de toute l'équation est que A) l'algorithme n'a pas été compromis et B) vous salez correctement chaque mot de passe . N'utilisez pas de sel pour toute l'application; qui ouvre toute votre application pour attaquer à partir d'un seul ensemble de tables Rainbow.

PHP - Fonction Crypt

Edit: 2013.01.15 - Si votre serveur le supporte, utilisez plutôt la solution de martinstoeckli .

Tout le monde veut rendre cela plus compliqué qu'il ne l'est. La fonction crypt () fait la plupart du travail.

function blowfishCrypt($password,$cost)
{
    $chars='./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    $salt=sprintf('$2y$%02d$',$cost);
//For PHP < PHP 5.3.7 use this instead
//    $salt=sprintf('$2a$%02d$',$cost);
    //Create a 22 character salt -edit- 2013.01.15 - replaced rand with mt_rand
    mt_srand();
    for($i=0;$i<22;$i++) $salt.=$chars[mt_rand(0,63)];
    return crypt($password,$salt);
}

Exemple:

$hash=blowfishCrypt('password',10); //This creates the hash
$hash=blowfishCrypt('password',12); //This creates a more secure hash
if(crypt('password',$hash)==$hash){ /*ok*/ } //This checks a password

Je sais que cela devrait être évident, mais veuillez ne pas utiliser le mot de passe comme mot de passe.

La version 5.5 de PHP aura un support intégré pour BCrypt, les fonctions password_hash()et password_verify(). En fait, ce ne sont que des wrappers autour de la fonction crypt(), et il sera plus facile de l'utiliser correctement. Il prend en charge la génération d'un sel aléatoire sûr et fournit de bonnes valeurs par défaut.

La façon la plus simple d'utiliser ces fonctions sera:

$hashToStoreInDb = password_hash($password, PASSWORD_BCRYPT);
$isPasswordCorrect = password_verify($password, $existingHashFromDb);

Ce code hachera le mot de passe avec BCrypt (algorithme 2y), génère un sel aléatoire à partir de la source aléatoire du système d'exploitation et utilise le paramètre de coût par défaut (actuellement 10). La deuxième ligne vérifie si le mot de passe saisi par l'utilisateur correspond à une valeur de hachage déjà stockée.

Si vous souhaitez modifier le paramètre de coût, vous pouvez le faire comme ceci, en augmentant le paramètre de coût de 1, double le temps nécessaire pour calculer la valeur de hachage:

$hash = password_hash($password, PASSWORD_BCRYPT, array("cost" => 11));

Contrairement au "cost"paramètre, il est préférable d'omettre le "salt"paramètre, car la fonction fait déjà de son mieux pour créer un sel cryptographiquement sûr.

Pour PHP version 5.3.7 et versions ultérieures, il existe un pack de compatibilité , du même auteur qui a créé la password_hash()fonction. Pour les versions PHP antérieures à 5.3.7, il n'y a pas de support pour crypt()with 2y, l'algorithme BCrypt sécurisé unicode. On pourrait le remplacer à la place par 2a, ce qui est la meilleure alternative pour les versions PHP antérieures.

Pensée actuelle: les hachages devraient être les plus lents disponibles, et non les plus rapides possibles. Cela supprime les attaques de table arc-en-ciel .

Également lié, mais par précaution: un attaquant ne devrait jamais avoir un accès illimité à votre écran de connexion. Pour éviter cela: configurez une table de suivi des adresses IP qui enregistre chaque occurrence avec l'URI. Si plus de 5 tentatives de connexion proviennent de la même adresse IP au cours d'une période de cinq minutes, bloquez avec explication. Une approche secondaire consiste à avoir un système de mot de passe à deux niveaux, comme les banques. Mettre un verrouillage pour les échecs sur la deuxième passe renforce la sécurité.

Résumé: ralentissez l'attaquant en utilisant des fonctions de hachage chronophages. De plus, bloquez trop d'accès à votre connexion et ajoutez un deuxième niveau de mot de passe.

Voici une réponse mise à jour à cette vieille question!

La bonne façon de hacher les mots de passe en PHP depuis 5.5 est avec password_hash(), et la bonne façon de les vérifier est avec password_verify(), et cela est toujours vrai en PHP 8.0. Ces fonctions utilisent des hachages bcrypt par défaut, mais d'autres algorithmes plus puissants ont été ajoutés. Vous pouvez modifier le facteur de travail (en fait, la force du cryptage) via les password_hashparamètres.

Cependant, bien qu'il soit encore assez fort, bcrypt n'est plus considéré comme à la pointe de la technologie ; un meilleur ensemble d'algorithmes de hachage de mot de passe est arrivé appelé Argon2 , avec les variantes Argon2i, Argon2d et Argon2id. La différence entre eux (comme décrit ici ):

Argon2 a une variante principale: Argon2id et deux variantes supplémentaires: Argon2d et Argon2i. Argon2d utilise un accès à la mémoire dépendant des données, ce qui le rend approprié pour les crypto-monnaies et les applications de preuve de travail sans menaces d'attaques de synchronisation du canal latéral. Argon2i utilise un accès à la mémoire indépendant des données, ce qui est préférable pour le hachage de mot de passe et la dérivation de clé basée sur un mot de passe. Argon2id fonctionne comme Argon2i pour la première moitié de la première itération sur la mémoire, et comme Argon2d pour le reste, offrant ainsi à la fois une protection contre les attaques par canal latéral et des économies de force brute en raison des compromis de temps-mémoire.

Le support Argon2i a été ajouté en PHP 7.2, et vous le demandez comme ceci:

$hash = password_hash('mypassword', PASSWORD_ARGON2I);

et le support Argon2id a été ajouté en PHP 7.3:

$hash = password_hash('mypassword', PASSWORD_ARGON2ID);

Aucune modification n'est requise pour vérifier les mots de passe car la chaîne de hachage résultante contient des informations sur l'algorithme, le sel et les facteurs de travail utilisés lors de sa création.

Tout à fait séparément (et quelque peu redondant), libsodium (ajouté en PHP 7.2) fournit également le hachage Argon2 via les fonctions sodium_crypto_pwhash_str ()et sodium_crypto_pwhash_str_verify(), qui fonctionnent à peu près de la même manière que les fonctions intégrées de PHP. Une des raisons possibles de leur utilisation est que PHP peut parfois être compilé sans libargon2, ce qui rend les algorithmes Argon2 indisponibles pour la fonction password_hash; PHP 7.2 et supérieur devraient toujours avoir libsodium activé, mais ce n'est peut-être pas le cas - mais au moins il y a deux façons d'obtenir cet algorithme. Voici comment vous pouvez créer un hachage Argon2id avec libsodium (même en PHP 7.2, qui, autrement, ne prend pas en charge Argon2id)):

$hash = sodium_crypto_pwhash_str(
    'mypassword',
    SODIUM_CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE,
    SODIUM_CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE
);

Notez qu'il ne vous permet pas de spécifier un sel manuellement; cela fait partie de la philosophie de libsodium - ne permettez pas aux utilisateurs de définir des paramètres qui pourraient compromettre la sécurité - par exemple, rien ne vous empêche de passer une chaîne de sel vide à la password_hashfonction PHP ; libsodium ne vous laisse rien faire de si bête!

Pour les mots de passe OAuth 2 :

$bcrypt = new \Zend\Crypt\Password\Bcrypt;
$bcrypt->create("youpasswordhere", 10)

Comme nous le savons tous, le stockage du mot de passe en texte clair dans la base de données n'est pas sécurisé. le bcrypt est une technique de hachage de mot de passe. l'une des fonctions étonnantes de bcrypt est qu'il nous protège des pirates informatiques, il est utilisé pour protéger le mot de passe contre les attaques de piratage, car le mot de passe est stocké sous forme bcryptée.

la fonction password_hash () est utilisée pour créer un nouveau hachage de mot de passe. Il utilise un algorithme de hachage fort et robuste. La fonction password_hash () est très compatible avec la fonction crypt (). Par conséquent, les hachages de mot de passe créés par crypt () peuvent être utilisés avec password_hash () et vice-versa. Les fonctions password_verify () et password_hash () se limitent aux wrappers autour de la fonction crypt () et facilitent son utilisation avec précision.

SYNTAXE

string password_hash($password , $algo , $options)

Les algorithmes suivants sont actuellement pris en charge par la fonction password_hash ():

PASSWORD_DEFAULT PASSWORD_BCRYPT PASSWORD_ARGON2I PASSWORD_ARGON2ID

Paramètres: Cette fonction accepte trois paramètres tels que mentionnés ci-dessus et décrits ci-dessous:

mot de passe : il stocke le mot de passe de l'utilisateur. algo : C'est la constante de l'algorithme de mot de passe qui est utilisée en continu tout en désignant l'algorithme à utiliser lors du hachage du mot de passe. options : Il s'agit d'un tableau associatif, qui contient les options. Si cela est supprimé et ne comprend pas, un sel aléatoire sera utilisé et l'utilisation d'un coût par défaut se produira. Valeur de retour : il renvoie le mot de passe haché en cas de succès ou False en cas d'échec.

Exemple :

Input : echo password_hash("GFG@123", PASSWORD_DEFAULT); Output : $2y$10$.vGA19Jh8YrwSJFDodbfoHJIOFH)DfhuofGv3Fykk1a

Les programmes ci-dessous illustrent la fonction password_hash () en PHP:

<?php echo password_hash("GFG@123", PASSWORD_DEFAULT); ?>

PRODUCTION

$2y$10$Z166W1fBdsLcXPVQVfPw/uRq1ueWMA6sLt9bmdUFz9AmOGLdM393G