crypt

(PHP 4, PHP 5, PHP 7, PHP 8)

cryptOne-way string hashing

Warning

This function is not (yet) binary safe!

Description

crypt(string $string, string $salt): string

crypt() will return a hashed string using the standard Unix DES-based algorithm or alternative algorithms.

The salt parameter is optional. However, crypt() creates a weak hash without the salt, and raises an E_NOTICE error without it. Make sure to specify a strong enough salt for better security.

password_hash() uses a strong hash, generates a strong salt, and applies proper rounds automatically. password_hash() is a simple crypt() wrapper and compatible with existing password hashes. Use of password_hash() is encouraged.

The hash type is triggered by the salt argument. If no salt is provided, PHP will auto-generate either a standard two character (DES) salt, or a twelve character (MD5), depending on the availability of MD5 crypt(). PHP sets a constant named CRYPT_SALT_LENGTH which indicates the longest valid salt allowed by the available hashes.

The standard DES-based crypt() returns the salt as the first two characters of the output. It also only uses the first eight characters of string, so longer strings that start with the same eight characters will generate the same result (when the same salt is used).

The following hash types are supported:

  • CRYPT_STD_DES - Standard DES-based hash with a two character salt from the alphabet "./0-9A-Za-z". Using invalid characters in the salt will cause crypt() to fail.
  • CRYPT_EXT_DES - Extended DES-based hash. The "salt" is a 9-character string consisting of an underscore followed by 4 bytes of iteration count and 4 bytes of salt. These are encoded as printable characters, 6 bits per character, least significant character first. The values 0 to 63 are encoded as "./0-9A-Za-z". Using invalid characters in the salt will cause crypt() to fail.
  • CRYPT_MD5 - MD5 hashing with a twelve character salt starting with $1$
  • CRYPT_BLOWFISH - Blowfish hashing with a salt as follows: "$2a$", "$2x$" or "$2y$", a two digit cost parameter, "$", and 22 characters from the alphabet "./0-9A-Za-z". Using characters outside of this range in the salt will cause crypt() to return a zero-length string. The two digit cost parameter is the base-2 logarithm of the iteration count for the underlying Blowfish-based hashing algorithm and must be in range 04-31, values outside this range will cause crypt() to fail. "$2x$" hashes are potentially weak; "$2a$" hashes are compatible and mitigate this weakness. For new hashes, "$2y$" should be used. Please refer to » this document for full details of the related security fix.
  • CRYPT_SHA256 - SHA-256 hash with a sixteen character salt prefixed with $5$. If the salt string starts with 'rounds=<N>$', the numeric value of N is used to indicate how many times the hashing loop should be executed, much like the cost parameter on Blowfish. The default number of rounds is 5000, there is a minimum of 1000 and a maximum of 999,999,999. Any selection of N outside this range will be truncated to the nearest limit.
  • CRYPT_SHA512 - SHA-512 hash with a sixteen character salt prefixed with $6$. If the salt string starts with 'rounds=<N>$', the numeric value of N is used to indicate how many times the hashing loop should be executed, much like the cost parameter on Blowfish. The default number of rounds is 5000, there is a minimum of 1000 and a maximum of 999,999,999. Any selection of N outside this range will be truncated to the nearest limit.

Parameters

string

The string to be hashed.

Caution

Using the CRYPT_BLOWFISH algorithm, will result in the string parameter being truncated to a maximum length of 72 characters.

salt

An optional salt string to base the hashing on. If not provided, the behaviour is defined by the algorithm implementation and can lead to unexpected results.

Return Values

Returns the hashed string or a string that is shorter than 13 characters and is guaranteed to differ from the salt on failure.

Warning

When validating passwords, a string comparison function that isn't vulnerable to timing attacks should be used to compare the output of crypt() to the previously known hash. PHP provides hash_equals() for this purpose.

Changelog

Version Description
8.0.0 The salt is no longer optional.

Examples

Example #1 crypt() examples

<?php
 
// let the salt be automatically generated; not recommended
$hashed_password crypt('mypassword');

/* You should pass the entire results of crypt() as the salt for comparing a
   password, to avoid problems when different hashing algorithms are used. (As
   it says above, standard DES-based password hashing uses a 2-character salt,
   but MD5-based hashing uses 12.) */
if (hash_equals($hashed_passwordcrypt($user_input$hashed_password))) {
   echo 
"Password verified!";
}
?>

Example #2 Using crypt() with htpasswd

<?php
// Set the password
$password 'mypassword';

// Get the hash, letting the salt be automatically generated; not recommended
$hash crypt($password);
?>

Example #3 Using crypt() with different hash types

<?php
/* These salts are examples only, and should not be used verbatim in your code.
   You should generate a distinct, correctly-formatted salt for each password.
*/
echo 'Standard DES: ',
    
crypt('rasmuslerdorf''rl'),
    
"\n";
echo 
'Extended DES: ',
    
crypt('rasmuslerdorf''_J9..rasm'),
    
"\n";
echo 
'MD5:          ',
    
crypt('rasmuslerdorf''$1$rasmusle$'),
    
"\n";
echo 
'Blowfish:     ',
    
crypt('rasmuslerdorf''$2a$07$usesomesillystringforsalt$'),
    
"\n";
echo 
'SHA-256:      ',
    
crypt('rasmuslerdorf''$5$rounds=5000$usesomesillystringforsalt$'),
    
"\n";
echo 
'SHA-512:      ',
    
crypt('rasmuslerdorf''$6$rounds=5000$usesomesillystringforsalt$'),
    
"\n";
?>

The above example will output something similar to:

Standard DES: rl.3StKT.4T8M
Extended DES: _J9..rasmBYk8r9AiWNc
MD5:          $1$rasmusle$rISCgZzpwk3UhDidwXvin0
Blowfish:     $2y$07$usesomesillystringfore2uDLvp1Ii2e./U9C8sBjqp8I90dH6hi
SHA-256:      $5$rounds=5000$usesomesillystri$KqJWpanXZHKq2BOB43TSaYhEWsQ1Lr5QNyPCDH/Tp.6
SHA-512:      $6$rounds=5000$usesomesillystri$D4IrlXatmP7rx3P3InaxBeoomnAihCKRVQP22JZ6EY47Wc6BkroIuUUBOov1i.S5KPgErtP/EN5mcO.ChWQW21

Notes

Note: There is no decrypt function, since crypt() uses a one-way algorithm.

See Also

  • hash_equals() - Timing attack safe string comparison
  • password_hash() - Creates a password hash
  • md5() - Calculate the md5 hash of a string
  • The Unix man page for your crypt function for more information