PHP 5.4.33 Released

hash_pbkdf2

(PHP 5 >= 5.5.0)

hash_pbkdf2Génère une clé PBKDF2 dérivée du mot de passe fourni

Description

string hash_pbkdf2 ( string $algo , string $password , string $salt , int $iterations [, int $length = 0 [, bool $raw_output = false ]] )

Liste de paramètres

algo

Nom de l'algorithme de hashage sélectionné (i.e. md5, sha256, haval160,4, etc..). Voir la fonction hash_algos() pour une liste des algorithmes supportés.

password

Le mot de passe à utiliser pour la dérivation.

salt

Le salt à utiliser pour la dérivation. Cette valeur doit être générée aléatoirement.

iterations

Le nombre d'itérations internes pour effectuer la dérivation.

length

La longueur de la chaîne de sortie. Si le paramètre raw_output vaut TRUE, ce paramètre correspondra à la longueur, en octets, de la clé dérivée ; si le paramètre raw_output vaut FALSE, il correspondra à deux fois la longueur, en octets, de la clé dérivée (vu que chaque octet de la clé est retournée sur deux hexits).

Si 0 est passé, la sortie complète de l'algorithme choisi sera utilisée.

raw_output

Lorsque définit à TRUE, la fonction affichera les données binaires brutes. Si vaut FALSE, l'affichage se fera en minuscule.

Valeurs de retour

Retourne une chaîne contenant la clé dérivée en minuscule, à moins que le paramètre raw_output ne soit positionné à TRUE auquel cas, la représentation binaire brute de la clé dérivée sera retournée.

Erreurs / Exceptions

Une alerte de type E_WARNING sera émise si l'algorithme n'est pas connu, si le paramètre iterations est inférieur ou égal à 0, si la longueur length est inférieure ou égale à 0 ou si le salt est trop long (plus grand que INT_MAX - 4).

Exemples

Exemple #1 Exemple avec hash_pbkdf2()

<?php
$password 
"password";
$iterations 1000;

// Génère un IV aléatoire en utilisant la fonction mcrypt_create_iv(),
// openssl_random_pseudo_bytes() ou tout autre source aléatoire correspondante
$salt mcrypt_create_iv(16MCRYPT_DEV_URANDOM);

$hash hash_pbkdf2("sha256"$password$salt$iterations20);
echo 
$hash;
?>

L'exemple ci-dessus va afficher quelque chose de similaire à :

120fb6cffcf8b32c43e7

Notes

Attention

La méthode PBKDF2 peut être utilisée pour hasher des mots de passe pour le stockage. Cependant, vous devez garder à l'esprit que la fonction password_hash() ou la fonction crypt() avec la constante CRYPT_BLOWFISH est meilleur pour cet usage.

Voir aussi

  • crypt() - Hachage à sens unique (indéchiffrable)
  • password_hash() - Crée une clé de hachage pour un mot de passe
  • hash() - Génère une valeur de hachage (empreinte numérique)
  • hash_algos() - Retourne une liste des algorithmes de hachage enregistrés
  • hash_init() - Initialise un contexte de hachage incrémental
  • hash_hmac() - Génère une valeur de clé de hachage en utilisant la méthode HMAC
  • hash_hmac_file() - Génère une valeur de clé de hachage en utilisant la méthode HMAC et le contenu d'un fichier donné

add a note add a note

User Contributed Notes 4 notes

up
7
Anonymous
1 year ago
Sadly this function was added in PHP 5.5 but many webservers just provide PHP 5.3. But there exists a pure PHP implementation (found here: https://defuse.ca/php-pbkdf2.htm).
I took this implementation, put it into a class with comments for PHPDoc and added a switch so that the native PHP function is used if available.

Feel free to use it!
http://pastebin.com/f5PDq735
(Posted on pastebin.com since the text would have been too long)
up
3
does dot not at matter dot org
10 months ago
this snippet was posted over a year ago on a dutch PHP community: (reference/source: http://www.phphulp.nl/php/script/beveiliging/pbkdf2-een-veilige-manier-om-wachtwoorden-op-te-slaan/1956/pbkdf2php/1757/)

<?php

/**
* @author Chris Horeweg
* @package Security_Tools
*/

function pbkdf2($password, $salt, $algorithm = 'sha512', $count = 20000, $key_length = 128, $raw_output = false)
{
    if(!
in_array($algorithm, hash_algos(), true)) {
        exit(
'pbkdf2: Hash algoritme is niet geinstalleerd op het systeem.');
    }
   
    if(
$count <= 0 || $key_length <= 0) {
       
$count = 20000;
       
$key_length = 128;
    }

   
$hash_length = strlen(hash($algorithm, "", true));
   
$block_count = ceil($key_length / $hash_length);

   
$output = "";
    for(
$i = 1; $i <= $block_count; $i++) {
       
$last = $salt . pack("N", $i);
       
$last = $xorsum = hash_hmac($algorithm, $last, $password, true);
        for (
$j = 1; $j < $count; $j++) {
           
$xorsum ^= ($last = hash_hmac($algorithm, $last, $password, true));
        }
       
$output .= $xorsum;
    }

    if(
$raw_output) {
        return
substr($output, 0, $key_length);
    }
    else {
        return
base64_encode(substr($output, 0, $key_length));
    }
}
up
1
Binod Kumar Luitel
11 months ago
People who wants pure PHP implementation of the function, i.e. who don't have PHP 5.5 installed within their server, can use the following implementation. Nothing has been modified so far as from reference https://defuse.ca/php-pbkdf2.htm but the OOP lovers might like this.
For more information about PBKDF2 see: http://en.wikipedia.org/wiki/PBKDF2

<?php
/**
* PBKDF2 key derivation function as defined by RSA's PKCS #5: https://www.ietf.org/rfc/rfc2898.txt
* $algorithm - The hash algorithm to use. Recommended: SHA256
* $password - The password.
* $salt - A salt that is unique to the password.
* $count - Iteration count. Higher is better, but slower. Recommended: At least 1000.
* $key_length - The length of the derived key in bytes.
* $raw_output - If true, the key is returned in raw binary format. Hex encoded otherwise.
* Returns: A $key_length-byte key derived from the password and salt.
*/
if (!function_exists("hash_pbkdf2")) {
    function
hash_pbkdf2($algorithm, $password, $salt, $count, $key_length, $raw_output = false) {

        class
pbkdf2 {
            public
$algorithm;
            public
$password;
            public
$salt;
            public
$count;
            public
$key_length;
            public
$raw_output;

            private
$hash_length;
            private
$output         = "";

            public function
__construct($data = null)
            {
                if (
$data != null) {
                   
$this->init($data);
                }
            }

            public function
init($data)
            {
               
$this->algorithm  = $data["algorithm"];
               
$this->password   = $data["password"];
               
$this->salt       = $data["salt"];
               
$this->count      = $data["count"];
               
$this->key_length = $data["key_length"];
               
$this->raw_output = $data["raw_output"];
            }

            public function
hash()
            {
               
$this->algorithm = strtolower($this->algorithm);
                if(!
in_array($this->algorithm, hash_algos(), true))
                    throw new
Exception('PBKDF2 ERROR: Invalid hash algorithm.');

                if(
$this->count <= 0 || $this->key_length <= 0)
                    throw new
Exception('PBKDF2 ERROR: Invalid parameters.');

               
$this->hash_length = strlen(hash($this->algorithm, "", true));
               
$block_count = ceil($this->key_length / $this->hash_length);
                for (
$i = 1; $i <= $block_count; $i++) {
                   
// $i encoded as 4 bytes, big endian.
                   
$last = $this->salt . pack("N", $i);
                   
// first iteration
                   
$last = $xorsum = hash_hmac($this->algorithm, $last, $this->password, true);
                   
// perform the other $this->count - 1 iterations
                   
for ($j = 1; $j < $this->count; $j++) {
                       
$xorsum ^= ($last = hash_hmac($this->algorithm, $last, $this->password, true));
                    }
                   
$this->output .= $xorsum;
                    if(
$this->raw_output)
                        return
substr($this->output, 0, $this->key_length);
                    else
                        return
bin2hex(substr($this->output, 0, $this->key_length));
                }
            }
        }

       
$data = array('algorithm' => $algorithm, 'password' => $password, 'salt' => $salt, 'count' => $count, 'key_length' => $key_length, 'raw_output' => $raw_output);
        try {
           
$pbkdf2 = new pbkdf2($data);
            return
$pbkdf2->hash();
        } catch (
Exception $e) {
            throw
$e;
        }
    }
}
up
-1
Peter
10 months ago
See also https://github.com/rchouinard/hash_pbkdf2-compat for a compatibility function
To Top