crypt

(PHP 4, PHP 5, PHP 7)

crypt단방향 문자열 암호화(해시)

설명

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

crypt()는 표준 유닉스 DES 기반 암호화 알고리즘이나 시스템에서 사용할 수 있는 다양한 알고리즘을 사용하여 암호화한 문자열을 반환합니다.

몇몇 운영체제는 한가지 이상의 암호화 방식을 제공합니다. 사실, 종종 표준 DES 기반 암호화는 MD5 기반 암호화 알고리즘으로 대체되기도 합니다. 암호화 타입은 slat 인수에 의해 변경됩니다. 설치시에, PHP는 사용할 수 있는 암호화 함수를 판단하고, 다른 암호화 방식을 위한 salt를 받아들입니다. salt를 지정하지 않으면, PHP는 기본값으로 두 문자 salt를 자동 생성합니다. 단, 시스템의 기본 암호화 방식이 MD5라면, 무작위의 MD5 호환 salt를 생성합니다. PHP는 CRYPT_SALT_LENGTH 상수를 설정하여, 시스템에서 일반적인 두 문자 salt가 적용되는지, 혹은 12 문자 salt를 받아들일 수 있는지 알려줍니다.

표준 DES 기반 암호화 crypt()는 처음 두 문자가 salt 인 문자열을 출력합니다. 또한 str의 처음 8 문자만 사용하기에, 같은 8문자로 시작하는 긴 문자열은 (같은 salt를 사용하는 한) 같은 결과를 생성합니다.

crypt() 함수가 다양한 암호화 방식을 지원하는 시스템에서, 주어진 방식의 사용 가능 여부에 따라 다음 상수들이 0이나 1로 설정됩니다:

  • CRYPT_STD_DES - 2문자 salt를 가지는 표준 DES 기반 암호화
  • CRYPT_EXT_DES - 9문자 salt를 가지는 확장 DES 기반 암호화
  • CRYPT_MD5 - $1$로 시작하는 12문자 salt를 가지는 MD5 암호화
  • CRYPT_BLOWFISH - $2$나 $2a$로 시작하는 16문자 salt를 가지는 Blowfish 암호화

Note:

PHP 5.3.0부터, 시스템에서 지원하지 않는 알고리즘에 대해서 PHP의 구현을 가집니다.

인수

str

암호화할 문자열.

salt

암호화에 사용할 선택적인 salt 문자열. 주어지지 않으면, 이 함수를 호출할 때마다 PHP가 임의로 생성합니다.

salt를 제공하여 사용하면, salt가 한번 생성되어진 점에 주의해야 합니다. 이 함수를 반복적으로 호출하면, 표현과 보안에 모두 영향을 줍니다.

반환값

암호화된 문자열을 반환합니다.

변경점

버전 설명
5.3.0 시스템에서 지원하지 않는 MD5 암호화, 표준 DES, 확장 DES, Blowfish 알고리즘에 대해서 PHP의 구현을 가집니다.

예제

Example #1 crypt() 예제

<?php
$password 
crypt('mypassword'); // salt 자동 생성

/* 패스워드를 비교할 때, 다른 해싱 알고리즘을 사용하는 문제를
   피하기 위해서, crypt()가 생성한 전체 결과를 salt로 주어야
   합니다. (위에서 밝혔듯이, 표준 DES 기반 암호 해싱은 2 문자
   salt를 사용하지만, MD5 기반 해싱은 12 문자를 사용합니다) */
if (crypt($user_input$password) == $password) {
   echo 
"패스워드 확인!";
}
?>

Example #2 htpasswd와 crypt() 사용하기

<?php
// password 설정
$password 'mypassword';

// salt 자동 생성으로 해시 획득
$hash crype($password);

Example #3 다양한 암호화 형식으로 crypt() 사용하기

<?php
if (CRYPT_STD_DES == 1) {
    echo 
'표준 DES: ' crypt('rasmuslerdorf''rl') . "\n";
}

if (
CRYPT_EXT_DES == 1) {
    echo 
'확장 DES: ' crypt('rasmuslerdorf''J9..rasm') . "\n";
}

if (
CRYPT_MY5 == 1) {
    echo 
'MD5:      ' crypt('rasmuslerdorf''$1$rasmusle$') . "\n";
}

if (
CRYPT_STD_DES == 1) {
    echo 
'Blowfish: ' crypt('rasmuslerdorf''$2a$07$rasmuslerd...........$') . "\n";
}
?>

위 예제의 출력 예시:

표준 DES: rl.3StKT.4T8M
확장 DES: _J9..rasmBYk8r9AiWNc
MD5     : $1$rasmusle$rISCgZzpwk3UhDidwXvin0
Blowfish:
$2a$07$rasmuslerd............nIdrcHdxcUxWomQX9j6kvERCFjTg7Ra

주의

Note: crypt()는 단방향 알고리즘을 사용하기 때문에, 복호화 함수는 없습니다.

참고

  • md5() - 문자열의 md5 해시를 계산
  • Mcrypt 확장
  • 자세한 정보를 위해 crypt 함수에 관한 유닉스 man 페이지

add a note add a note

User Contributed Notes 8 notes

up
54
bob dot orr at mailinator dot com
4 years ago
The #2 comment on this comments page (as of Feb 2015) is 9 years old and recommends phpass.  I have independently security audited this product and, while it continues to be recommended for password security, it is actually insecure and should NOT be used.  It hasn't seen any updates in years (still at v0.3) and there are more recent alternatives such as using the newer built-in PHP password_hash() function that are much better.  Everyone, please take a few moments to confirm what I'm saying is accurate (i.e. review the phpass code for yourself) and then click the down arrow to sink the phpass comment to the bottom.  You'll be increasing security across the Internet by doing so.

For those who want details:  md5() with microtime() are a fallback position within the source code of phpass.  Instead of terminating, it continues to execute code.  The author's intentions of trying to work everywhere are admirable but, when it comes to application security, that stance actually backfires.  The only correct answer in a security context is to terminate the application rather than fallback to a weak position that can potentially be exploited (usually by forcing that weaker position to happen).
up
11
steve at tobtu dot com
6 years ago
To generate salt use mcrypt_create_iv() not mt_rand() because no matter how many times you call mt_rand() it will only have at most 32 bits of entropy. Which you will start seeing salt collisions after about 2^16 users. mt_rand() is seeded poorly so it should happen sooner.

For bcrypt this will actually generate a 128 bit salt:
<?php $salt = strtr(base64_encode(mcrypt_create_iv(16, MCRYPT_DEV_URANDOM)), '+', '.'); ?>

*** Bike shed ***
The last character in the 22 character salt is 2 bits.
base64_encode() will have these four character "AQgw"
bcrypt will have these four character ".Oeu"

You don't need to do a full translate because they "round" to different characters:
echo crypt('', '$2y$05$.....................A') . "\n";
echo crypt('', '$2y$05$.....................Q') . "\n";
echo crypt('', '$2y$05$.....................g') . "\n";
echo crypt('', '$2y$05$.....................w') . "\n";

$2y$05$......................J2ihDv8vVf7QZ9BsaRrKyqs2tkn55Yq
$2y$05$.....................O/jw2XygQa2.LrIT7CFCBQowLowDP6Y.
$2y$05$.....................eDOx4wMcy7WU.kE21W6nJfdMimsBE3V6
$2y$05$.....................uMMcgjnOELIa6oydRivPkiMrBG8.aFp.
up
11
Marten Jacobs
5 years ago
As I understand it, blowfish is generally seen a secure hashing algorithm, even for enterprise use (correct me if I'm wrong). Because of this, I created functions to create and check secure password hashes using this algorithm, and using the (also deemed cryptographically secure) openssl_random_pseudo_bytes function to generate the salt.

<?php
/*
* Generate a secure hash for a given password. The cost is passed
* to the blowfish algorithm. Check the PHP manual page for crypt to
* find more information about this setting.
*/
function generate_hash($password, $cost=11){
       
/* To generate the salt, first generate enough random bytes. Because
         * base64 returns one character for each 6 bits, the we should generate
         * at least 22*6/8=16.5 bytes, so we generate 17. Then we get the first
         * 22 base64 characters
         */
       
$salt=substr(base64_encode(openssl_random_pseudo_bytes(17)),0,22);
       
/* As blowfish takes a salt with the alphabet ./A-Za-z0-9 we have to
         * replace any '+' in the base64 string with '.'. We don't have to do
         * anything about the '=', as this only occurs when the b64 string is
         * padded, which is always after the first 22 characters.
         */
       
$salt=str_replace("+",".",$salt);
       
/* Next, create a string that will be passed to crypt, containing all
         * of the settings, separated by dollar signs
         */
       
$param='$'.implode('$',array(
               
"2y", //select the most secure version of blowfish (>=PHP 5.3.7)
               
str_pad($cost,2,"0",STR_PAD_LEFT), //add the cost in two digits
               
$salt //add the salt
       
));
      
       
//now do the actual hashing
       
return crypt($password,$param);
}

/*
* Check the password against a hash generated by the generate_hash
* function.
*/
function validate_pw($password, $hash){
       
/* Regenerating the with an available hash as the options parameter should
         * produce the same hash if the same password is passed.
         */
       
return crypt($password, $hash)==$hash;
}
?>
up
2
kaminski at istori dot com
8 years ago
Here is an expression to generate pseudorandom salt for the CRYPT_BLOWFISH hash type:

<?php $salt = substr(str_replace('+', '.', base64_encode(pack('N4', mt_rand(), mt_rand(), mt_rand(), mt_rand()))), 0, 22); ?>

It is intended for use on systems where mt_getrandmax() == 2147483647.

The salt created will be 128 bits in length, padded to 132 bits and then expressed in 22 base64 characters.  (CRYPT_BLOWFISH only uses 128 bits for the salt, even though there are 132 bits in 22 base64 characters.  If you examine the CRYPT_BLOWFISH input and output, you can see that it ignores the last four bits on input, and sets them to zero on output.)

Note that the high-order bits of the four 32-bit dwords returned by mt_rand() will always be zero (since mt_getrandmax == 2^31), so only 124 of the 128 bits will be pseudorandom.  I found that acceptable for my application.
up
1
jette at nerdgirl dot dk
6 years ago
The crypt() function cant handle plus signs correctly. So if for example you are using crypt in a login function, use urlencode on the password first to make sure that the login procedure can handle any character:

<?php
$user_input
'12+#æ345';
$pass = urlencode($user_input));
$pass_crypt = crypt($pass);

if (
$pass_crypt == crypt($pass, $pass_crypt)) {
  echo
"Success! Valid password";
} else {
  echo
"Invalid password";
}
?>
up
-8
Anonymous
1 year ago
steve at tobtu dot com was right 4 years ago, but now mcrypt_create_iv()  (and bcrypt in general) is deprecated!

Use random_bytes() instead:

<?php
$salt
= base64_encode(random_bytes(16));
up
-16
ian+php dot net at eiloart dot ocm
5 years ago
If you're stuck with CRYPT_EXT_DES, then you'll want to pick a number of iterations: the 2nd-5th characters of the "salt".

My experimentation suggests that the 5th character is the most significant. A '.' is a zero and 'Z' is the highest value. Using all dots will create an error: all passwords will be encrypted to the same value.

Here are some encryption timings (in seconds) that I obtained, with five different iteration counts over the same salt, and the same password, on a quad core 2.66GHz Intel Xeon machine.

_1111 time: 0.15666794776917
_J9.Z time: 1.8860530853271
_J9.. time: 0.00015401840209961
_...Z time: 1.9095730781555
_ZZZZ time: 1.9124970436096
_...A time: 0.61211705207825

I think a half a second is reasonable for an application, but for the back end authentication? I'm not so sure: there's a significant risk of overloading the back end if we're getting lots of authentication requests.
up
-5
Joey
1 year ago
While the documentation says that crypt will fail for DES if the salt is invalid, this turns out to not be the case.

The crypt function will accept any string of two characters or more for DES as long as it doesn't match the pattern for any other hashing schema. The remaining characters will be ignored.
To Top