PHP crypt() Function

The PHP crypt() function returns a hashed string using the standard Unix DES-based algorithm or alternative algorithms.

The salt parameter is optional. However, this function 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.

The hash type is triggered by the salt argument. If no salt is provided, PHP auto-generates either a standard two character (DES) salt, or a twelve character (MD5), depending on the availability of MD5 crypt(). PHP sets CRYPT_SALT_LENGTH constant 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 this function 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 the function to fail.
CRYPT_MD5 - MD5 hashing with a 12 character salt starting with $1$
CRYPT_BLOWFISH - Blowfish hashing with a salt with "$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 this function 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 this function to fail. "$2x$" hashes are potentially weak; "$2a$" hashes are compatible and mitigate this weakness. For new hashes, "$2y$" should be used.
CRYPT_SHA256 - SHA-256 hash with a 16 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 16 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.

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

Note: 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.

Syntax

crypt(string, salt)

Parameters

`string`	`Required.` Specify the string to be hashed. Note: Using the CRYPT_BLOWFISH algorithm, will result in the string parameter being truncated to a maximum length of 72 characters.
`salt`	`Optional.` Specify the salt string to base the hashing on. If not provided, the behavior is defined by the algorithm implementation and can lead to unexpected results. Note: The parameter is no longer optional as of PHP 8.0.0.

Return Value

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

Example: using crypt() with different hash types

In the example below shows the usage of crypt() function.

<?php
//2 character salt
echo 'Standard DES: ',
    crypt('mypassword', 'ac'),
    "\n";

//4 character salt
echo 'Extended DES: ',
    crypt('mypassword', '_A4..acsm'),
    "\n";

//12 character salt starting with $1$
echo 'MD5:          ',
    crypt('mypassword', '$1$mypasswo$'),
    "\n";

//salt starting with $2a$. The two digit cost parameter: 09. 22 characters
echo 'Blowfish:     ',
    crypt('mypassword', '$2a$07$usesomesillystringforsalt$'),
    "\n";

//16 character salt starting with $5$. The default number of rounds is 5000.
echo 'SHA-256:      ',
    crypt('mypassword', '$5$rounds=5000$usesomesillystringforsalt$'),
    "\n";

//16 character salt starting with $6$. The default number of rounds is 5000.
echo 'SHA-512:      ',
    crypt('mypassword', '$6$rounds=5000$usesomesillystringforsalt$'),
    "\n";
?>

The output of the above code will be:

Standard DES: acxwGbTpy.Z22
Extended DES: _A4..acsm5imlfzZfEkY
MD5:          $1$mypasswo$gP5WtaHnASiKctngsVs2e.
Blowfish:     $2a$07$usesomesillystringforeP9DkYeBci44xgF1uJmwup2ZMGjpx/Z.
SHA-256:      $5$rounds=5000$usesomesillystri$36krcUEy2oAY5YFLl52aUa7fXbx6WMAH7llQCX/qk8A
SHA-512:      $6$rounds=5000$usesomesillystri$9sGqw8yRnx47zvLmqor/MmDMoRmQBC/fSLybwKnI3NHrscdA9hBOcTBeFEN6niDykgCe.0e3oUHZR53HdDneO/

Example: crypt() example

Consider one more example which illustrates on how to use this function to verify password.

<?php
//12 character salt starting with $1$
$hashed_password = crypt('mypassword', '$1$password$');

if (hash_equals($hashed_password, crypt($user_input, $hashed_password))) {
  echo "Password verified!";
}
?>

❮ PHP String Reference