CRYPT(3)								 1								  CRYPT(3)

crypt - One-way string hashing

SYNOPSIS

       string crypt (string  $str, [string  $salt])

DESCRIPTION

       crypt(3)  will  return  a  hashed string using the standard Unix DES-based algorithm or alternative algorithms that may be available on the
       system.

	The $salt parameter is optional. However, crypt(3) creates a weak password without the $salt. PHP 5.6 or later	raise  an  E_NOTICE  error
       without it. Make sure to specify a strong enough salt for better security.

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

	Some operating systems support more than one type of hash. In fact, sometimes the standard DES-based algorithm is replaced by an MD5-based
       algorithm.  The	hash  type  is	triggered by the salt argument. Prior to 5.3, PHP would determine the available algorithms at install-time
       based on the system's crypt(). If no salt is provided, PHP will auto-generate either a standard two character (DES) salt, or a twelve char-
       acter  (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(3) returns the salt as the first two characters of the output. It also only uses the first  eight	characters
       of $str, so longer strings that start with the same eight characters will generate the same result (when the same salt is used).

	On  systems  where  the  crypt() function supports multiple hash types, the following constants are set to 0 or 1 depending on whether the
       given type is available:

	      o 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.

	      o 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.

	      o CRYPT_MD5 - MD5 hashing with a twelve character salt starting with $1$

	      o CRYPT_BLOWFISH	- Blowfish hashing with a salt as follows: "$2a$", "$2x$" or "$2y$", a two digit cost parameter, "$", and 22 char-
		acters 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 hash-
		ing algorithmeter and must be in range 04-31, values outside this range will cause crypt() to fail. Versions of PHP  before  5.3.7
		only support "$2a$" as the salt prefix: PHP 5.3.7 introduced the new prefixes to fix a security weakness in the Blowfish implemen-
		tation. Please refer to this document for full details of the security fix, but to summarise, developers targeting only PHP  5.3.7
		and later should use "$2y$" in preference to "$2a$".

	      o 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  Blow-
		fish.  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.

	      o 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 Blow-
		fish. 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

	       As  of PHP 5.3.0, PHP contains its own implementation and will use that if the system lacks of support for one or more of the algo-
	      rithms.

PARAMETERS

	      o $str
		- The string to be hashed.

	      Caution

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

	      o $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 out-
	      put of crypt(3) to the previously known hash. PHP 5.6 onwards provides hash_equals(3) for this purpose.

CHANGELOG

       +--------+---------------------------------------------------+
       |Version |						    |
       |	|						    |
       |	|		     Description		    |
       |	|						    |
       +--------+---------------------------------------------------+
       | 5.6.5	|						    |
       |	|						    |
       |	|  When the failure string "*0"  is  given  as	the |
       |	| $salt,  "*1" will now be returned for consistency |
       |	| with other crypt implementations. Prior  to  this |
       |	| version,  PHP  5.6 would incorrectly return a DES |
       |	| hash. 					    |
       |	|						    |
       | 5.6.0	|						    |
       |	|						    |
       |	|  Raise E_NOTICE  security  warning  if  $salt  is |
       |	| omitted.					    |
       |	|						    |
       |5.5.21	|						    |
       |	|						    |
       |	|  When  the  failure  string  "*0" is given as the |
       |	| $salt, "*1" will now be returned for	consistency |
       |	| with	other  crypt implementations. Prior to this |
       |	| version, PHP 5.5  (and  earlier  branches)  would |
       |	| incorrectly return a DES hash.		    |
       |	|						    |
       | 5.3.7	|						    |
       |	|						    |
       |	|  Added  $2x$ and $2y$ Blowfish modes to deal with |
       |	| potential high-bit attacks.			    |
       |	|						    |
       | 5.3.2	|						    |
       |	|						    |
       |	|  Added SHA-256 and SHA-512 crypt based on  Ulrich |
       |	| Drepper's implementation.			    |
       |	|						    |
       | 5.3.2	|						    |
       |	|						    |
       |	|  Fixed  Blowfish  behaviour  on invalid rounds to |
       |	| return "failure" string ("*0" or  "*1"),  instead |
       |	| of falling back to DES.			    |
       |	|						    |
       | 5.3.0	|						    |
       |	|						    |
       |	|  PHP	now contains its own implementation for the |
       |	| MD5 crypt, Standard DES,  Extended  DES  and	the |
       |	| Blowfish algorithms and will use that if the sys- |
       |	| tem lacks of support for one or more of the algo- |
       |	| rithms.					    |
       |	|						    |
       +--------+---------------------------------------------------+
EXAMPLES

       Example #1

	      crypt(3) examples

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

	      /* 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_password, crypt($user_input, $hashed_password))) {
		 echo "Password verified!";
	      }
	      ?>

       Example #2

	      Using crypt(3) with htpasswd

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

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

       Example #3

	      Using crypt(3) 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.
	      */
	      if (CRYPT_STD_DES == 1) {
		  echo 'Standard DES: ' . crypt('rasmuslerdorf', 'rl') . "
";
	      }

	      if (CRYPT_EXT_DES == 1) {
		  echo 'Extended DES: ' . crypt('rasmuslerdorf', '_J9..rasm') . "
";
	      }

	      if (CRYPT_MD5 == 1) {
		  echo 'MD5:	      ' . crypt('rasmuslerdorf', '$1$rasmusle$') . "
";
	      }

	      if (CRYPT_BLOWFISH == 1) {
		  echo 'Blowfish:     ' . crypt('rasmuslerdorf', '$2a$07$usesomesillystringforsalt$') . "
";
	      }

	      if (CRYPT_SHA256 == 1) {
		  echo 'SHA-256:      ' . crypt('rasmuslerdorf', '$5$rounds=5000$usesomesillystringforsalt$') . "
";
	      }

	      if (CRYPT_SHA512 == 1) {
		  echo 'SHA-512:      ' . crypt('rasmuslerdorf', '$6$rounds=5000$usesomesillystringforsalt$') . "
";
	      }
	      ?>

	      The above example will output something similar to:

	      Standard DES: rl.3StKT.4T8M
	      Extended DES: _J9..rasmBYk8r9AiWNc
	      MD5:	    $1$rasmusle$rISCgZzpwk3UhDidwXvin0
	      Blowfish:     $2a$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(3) uses a one-way algorithm.

SEE ALSO

       hash_equals(3), password_hash(3), md5(3), The Mcrypt extension, The Unix man page for your crypt function for more information.

PHP Documentation Group 														  CRYPT(3)