Comment utiliser password_hash
Récemment, j'ai essayé d'implémenter ma propre sécurité sur un script de connexion sur lequel je suis tombé par hasard sur Internet. Après avoir eu du mal à apprendre à créer mon propre script afin de générer un sel pour chaque utilisateur, je suis tombé sur password_hash.
D'après ce que j'ai compris (d'après la lecture de cette page: http://php.net/manual/fr/faq.passwords.php ), le sel est déjà généré dans la ligne lorsque vous utilisez password_hash. Est-ce vrai?
Une autre question que j'avais était, ne serait-il pas intelligent d'avoir 2 sels? Un directement dans le fichier et un dans la base de données? De cette façon, si quelqu'un compromet votre sel dans la base de données, vous avez toujours celui directement dans le fichier? J'ai lu que le stockage des sels n’est jamais une bonne idée, mais j’ai toujours confondu ce que les gens voulaient dire par là.
Utiliser password_hash est la méthode recommandée pour stocker les mots de passe. Ne les séparez pas de la base de données et des fichiers.
Disons que nous avons l'entrée suivante:
$password = $_POST['password'];
Je ne valide pas l'entrée uniquement pour comprendre le concept.
Vous commencez par hacher le mot de passe en procédant comme suit:
$hashed_password = password_hash($password, PASSWORD_DEFAULT);
Puis voir la sortie:
var_dump($hashed_password);
Comme vous pouvez le voir, c'est haché. (Je suppose que vous avez fait ces étapes).
Maintenant, vous stockez ce hashed_password dans votre base de données, et ensuite, disons quand un utilisateur demande à les connecter. Vous vérifiez le mot de passe saisi avec cette valeur de hachage dans la base de données en procédant comme suit:
// Query the database for username and password
// ...
if(password_verify($password, $hashed_password)) {
// If the password inputs matched the hashed password in the database
// Do something, you know... log them in.
}
// Else, Redirect them back to the login page.
Oui, vous avez bien compris, la fonction password_hash () va générer elle-même un sel, et l'inclut dans la valeur de hachage résultante. Stocker le sel dans la base de données est tout à fait correct, elle fait son travail même si elle est connue.
// Hash a new password for storing in the database.
// The function automatically generates a cryptographically safe salt.
$hashToStoreInDb = password_hash($_POST['password'], PASSWORD_DEFAULT);
// Check if the hash of the entered login password, matches the stored hash.
// The salt and the cost factor will be extracted from $existingHashFromDb.
$isPasswordCorrect = password_verify($_POST['password'], $existingHashFromDb);
Le deuxième sel que vous avez mentionné (celui stocké dans un fichier) est en fait une clé poivre ou une clé côté serveur. Si vous l'ajoutez avant le hachage (comme le sel), vous ajoutez alors un poivre. Il existe cependant un meilleur moyen: vous pouvez d’abord calculer le hachage, puis le chiffrer (dans les deux sens) avec une clé côté serveur. Cela vous donne la possibilité de changer la clé si nécessaire.
Contrairement au sel, cette clé doit rester secrète. Les gens mélangent souvent et essaient de cacher le sel, mais il est préférable de laisser le sel faire son travail et d'ajouter le secret avec une clé.
Oui c'est vrai. Pourquoi doutez-vous de la FAQ php sur la fonction? :)
Le résultat de l'exécution de password_hash() a se compose de quatre parties:
- l'algorithme utilisé
- paramètres
- sel
- mot de passe réel
Comme vous pouvez le constater, le hash en fait partie.
Bien sûr, vous pourriez avoir un sel supplémentaire pour une couche de sécurité supplémentaire, mais honnêtement, je pense que c'est exagéré dans une application PHP régulière. L’algorithme par défaut bcrypt est bon, et celui optionnel blowfish est encore meilleur.
Il existe un manque flagrant de discussion sur la compatibilité amont et aval intégrée aux fonctions de mot de passe de PHP. Notamment:
- Compatibilité avec les versions antérieures: Les fonctions de mot de passe constituent essentiellement un wrapper bien écrit autour de
crypt(), et sont intrinsèquement compatibles avec les hachages au formatcrypt()-, même s'ils utilisez des algorithmes de hachage obsolètes et/ou non sécurisés. - transmet la compatibilité: L'insertion de
password_needs_rehash()et un peu de logique dans votre processus d'authentification peuvent vous tenir au courant des algorithmes actuels et futurs avec un avenir potentiellement nul modifications du flux de travail. Remarque: Toute chaîne ne correspondant pas à l'algorithme spécifié sera signalée pour nécessiter un rehash, y compris les hachages non compatibles avec le cryptage.
Par exemple:
class FakeDB {
public function __call($name, $args) {
printf("%s::%s(%s)\n", __CLASS__, $name, json_encode($args));
return $this;
}
}
class MyAuth {
protected $dbh;
protected $fakeUsers = [
// old crypt-md5 format
1 => ['password' => '$1$AVbfJOzY$oIHHCHlD76Aw1xmjfTpm5.'],
// old salted md5 format
2 => ['password' => '3858f62230ac3c915f300c664312c63f', 'salt' => 'bar'],
// current bcrypt format
3 => ['password' => '$2y$10$3eUn9Rnf04DR.aj8R3WbHuBO9EdoceH9uKf6vMiD7tz766rMNOyTO']
];
public function __construct($dbh) {
$this->dbh = $dbh;
}
protected function getuser($id) {
// just pretend these are coming from the DB
return $this->fakeUsers[$id];
}
public function authUser($id, $password) {
$userInfo = $this->getUser($id);
// Do you have old, turbo-legacy, non-crypt hashes?
if( strpos( $userInfo['password'], '$' ) !== 0 ) {
printf("%s::legacy_hash\n", __METHOD__);
$res = $userInfo['password'] === md5($password . $userInfo['salt']);
} else {
printf("%s::password_verify\n", __METHOD__);
$res = password_verify($password, $userInfo['password']);
}
// once we've passed validation we can check if the hash needs updating.
if( $res && password_needs_rehash($userInfo['password'], PASSWORD_DEFAULT) ) {
printf("%s::rehash\n", __METHOD__);
$stmt = $this->dbh->prepare('UPDATE users SET pass = ? WHERE user_id = ?');
$stmt->execute([password_hash($password, PASSWORD_DEFAULT), $id]);
}
return $res;
}
}
$auth = new MyAuth(new FakeDB());
for( $i=1; $i<=3; $i++) {
var_dump($auth->authuser($i, 'foo'));
echo PHP_EOL;
}
Sortie:
MyAuth::authUser::password_verify
MyAuth::authUser::rehash
FakeDB::prepare(["UPDATE users SET pass = ? WHERE user_id = ?"])
FakeDB::execute([["$2y$10$zNjPwqQX\/RxjHiwkeUEzwOpkucNw49yN4jjiRY70viZpAx5x69kv.",1]])
bool(true)
MyAuth::authUser::legacy_hash
MyAuth::authUser::rehash
FakeDB::prepare(["UPDATE users SET pass = ? WHERE user_id = ?"])
FakeDB::execute([["$2y$10$VRTu4pgIkGUvilTDRTXYeOQSEYqe2GjsPoWvDUeYdV2x\/\/StjZYHu",2]])
bool(true)
MyAuth::authUser::password_verify
bool(true)
En guise de conclusion, étant donné que vous ne pouvez modifier le hachage du mot de passe d'un utilisateur qu'une fois connecté, vous devez envisager de "supprimer" les hachages hérités non sécurisés afin de protéger vos utilisateurs. J'entends par là qu'après une certaine période de grâce, vous supprimez tous les hachages non sécurisés [par exemple: MD5/SHA nu/sinon faible] et invitez vos utilisateurs à utiliser les mécanismes de réinitialisation du mot de passe de votre application.
N'utilisez jamais md5 () pour sécuriser votre mot de passe, même avec du sel, c'est toujours dangereux !!
Rendez votre mot de passe sécurisé avec les derniers algorithmes de hachage décrits ci-dessous.
<?php
// Your original Password
$password = '121@121';
//PASSWORD_BCRYPT or PASSWORD_DEFAULT use any in the 2nd parameter
/*
PASSWORD_BCRYPT always results 60 characters long string.
PASSWORD_DEFAULT capacity is beyond 60 characters
*/
$password_encrypted = password_hash($password, PASSWORD_BCRYPT);
?>
Pour faire correspondre le mot de passe crypté de la base de données et le mot de passe entré par l'utilisateur, utilisez la fonction ci-dessous.
<?php
if (password_verify($password_inputted_by_user, $password_encrypted)) {
// Success!
echo 'Password Matches';
}else {
// Invalid credentials
echo 'Password Mismatch';
}
?>
Si vous voulez utiliser votre propre sel, utilisez votre fonction générée personnalisée pour la même chose, suivez simplement la procédure ci-dessous, mais je ne le recommande pas, car elle est considérée comme obsolète dans les dernières versions de PHP.
lisez ceci http://php.net/manual/en/function.password-hash.php avant d'utiliser le code ci-dessous.
<?php
$options = [
'salt' => your_custom_function_for_salt(),
//write your own code to generate a suitable & secured salt
'cost' => 12 // the default cost is 10
];
$hash = password_hash($your_password, PASSWORD_DEFAULT, $options);
?>
J'espère que tout cela aide !!
Code complet du mot de passe de la classe:
Class Password {
public function __construct() {}
/**
* Hash the password using the specified algorithm
*
* @param string $password The password to hash
* @param int $algo The algorithm to use (Defined by PASSWORD_* constants)
* @param array $options The options for the algorithm to use
*
* @return string|false The hashed password, or false on error.
*/
function password_hash($password, $algo, array $options = array()) {
if (!function_exists('crypt')) {
trigger_error("Crypt must be loaded for password_hash to function", E_USER_WARNING);
return null;
}
if (!is_string($password)) {
trigger_error("password_hash(): Password must be a string", E_USER_WARNING);
return null;
}
if (!is_int($algo)) {
trigger_error("password_hash() expects parameter 2 to be long, " . gettype($algo) . " given", E_USER_WARNING);
return null;
}
switch ($algo) {
case PASSWORD_BCRYPT :
// Note that this is a C constant, but not exposed to PHP, so we don't define it here.
$cost = 10;
if (isset($options['cost'])) {
$cost = $options['cost'];
if ($cost < 4 || $cost > 31) {
trigger_error(sprintf("password_hash(): Invalid bcrypt cost parameter specified: %d", $cost), E_USER_WARNING);
return null;
}
}
// The length of salt to generate
$raw_salt_len = 16;
// The length required in the final serialization
$required_salt_len = 22;
$hash_format = sprintf("$2y$%02d$", $cost);
break;
default :
trigger_error(sprintf("password_hash(): Unknown password hashing algorithm: %s", $algo), E_USER_WARNING);
return null;
}
if (isset($options['salt'])) {
switch (gettype($options['salt'])) {
case 'NULL' :
case 'boolean' :
case 'integer' :
case 'double' :
case 'string' :
$salt = (string)$options['salt'];
break;
case 'object' :
if (method_exists($options['salt'], '__tostring')) {
$salt = (string)$options['salt'];
break;
}
case 'array' :
case 'resource' :
default :
trigger_error('password_hash(): Non-string salt parameter supplied', E_USER_WARNING);
return null;
}
if (strlen($salt) < $required_salt_len) {
trigger_error(sprintf("password_hash(): Provided salt is too short: %d expecting %d", strlen($salt), $required_salt_len), E_USER_WARNING);
return null;
} elseif (0 == preg_match('#^[a-zA-Z0-9./]+$#D', $salt)) {
$salt = str_replace('+', '.', base64_encode($salt));
}
} else {
$salt = str_replace('+', '.', base64_encode($this->generate_entropy($required_salt_len)));
}
$salt = substr($salt, 0, $required_salt_len);
$hash = $hash_format . $salt;
$ret = crypt($password, $hash);
if (!is_string($ret) || strlen($ret) <= 13) {
return false;
}
return $ret;
}
/**
* Generates Entropy using the safest available method, falling back to less preferred methods depending on support
*
* @param int $bytes
*
* @return string Returns raw bytes
*/
function generate_entropy($bytes){
$buffer = '';
$buffer_valid = false;
if (function_exists('mcrypt_create_iv') && !defined('PHALANGER')) {
$buffer = mcrypt_create_iv($bytes, MCRYPT_DEV_URANDOM);
if ($buffer) {
$buffer_valid = true;
}
}
if (!$buffer_valid && function_exists('openssl_random_pseudo_bytes')) {
$buffer = openssl_random_pseudo_bytes($bytes);
if ($buffer) {
$buffer_valid = true;
}
}
if (!$buffer_valid && is_readable('/dev/urandom')) {
$f = fopen('/dev/urandom', 'r');
$read = strlen($buffer);
while ($read < $bytes) {
$buffer .= fread($f, $bytes - $read);
$read = strlen($buffer);
}
fclose($f);
if ($read >= $bytes) {
$buffer_valid = true;
}
}
if (!$buffer_valid || strlen($buffer) < $bytes) {
$bl = strlen($buffer);
for ($i = 0; $i < $bytes; $i++) {
if ($i < $bl) {
$buffer[$i] = $buffer[$i] ^ chr(mt_Rand(0, 255));
} else {
$buffer .= chr(mt_Rand(0, 255));
}
}
}
return $buffer;
}
/**
* Get information about the password hash. Returns an array of the information
* that was used to generate the password hash.
*
* array(
* 'algo' => 1,
* 'algoName' => 'bcrypt',
* 'options' => array(
* 'cost' => 10,
* ),
* )
*
* @param string $hash The password hash to extract info from
*
* @return array The array of information about the hash.
*/
function password_get_info($hash) {
$return = array('algo' => 0, 'algoName' => 'unknown', 'options' => array(), );
if (substr($hash, 0, 4) == '$2y$' && strlen($hash) == 60) {
$return['algo'] = PASSWORD_BCRYPT;
$return['algoName'] = 'bcrypt';
list($cost) = sscanf($hash, "$2y$%d$");
$return['options']['cost'] = $cost;
}
return $return;
}
/**
* Determine if the password hash needs to be rehashed according to the options provided
*
* If the answer is true, after validating the password using password_verify, rehash it.
*
* @param string $hash The hash to test
* @param int $algo The algorithm used for new password hashes
* @param array $options The options array passed to password_hash
*
* @return boolean True if the password needs to be rehashed.
*/
function password_needs_rehash($hash, $algo, array $options = array()) {
$info = password_get_info($hash);
if ($info['algo'] != $algo) {
return true;
}
switch ($algo) {
case PASSWORD_BCRYPT :
$cost = isset($options['cost']) ? $options['cost'] : 10;
if ($cost != $info['options']['cost']) {
return true;
}
break;
}
return false;
}
/**
* Verify a password against a hash using a timing attack resistant approach
*
* @param string $password The password to verify
* @param string $hash The hash to verify against
*
* @return boolean If the password matches the hash
*/
public function password_verify($password, $hash) {
if (!function_exists('crypt')) {
trigger_error("Crypt must be loaded for password_verify to function", E_USER_WARNING);
return false;
}
$ret = crypt($password, $hash);
if (!is_string($ret) || strlen($ret) != strlen($hash) || strlen($ret) <= 13) {
return false;
}
$status = 0;
for ($i = 0; $i < strlen($ret); $i++) {
$status |= (ord($ret[$i]) ^ ord($hash[$i]));
}
return $status === 0;
}
}