[php] PHP의 password_hash를 사용하여 암호를 해시하고 확인하는 방법

최근 나는 인터넷에서 우연히 발견 한 로그인 스크립트에 내 자신의 보안을 구현하려고 노력하고 있습니다. 각 사용자를 위해 솔트를 생성하기 위해 내 스크립트를 만드는 방법을 배우려고 애쓰다가 password_hash.

내가 이해 한 바에 따르면 ( 이 페이지 의 읽기를 기반으로 )을 사용할 때 이미 솔트가 행에 생성됩니다 password_hash. 이것이 사실입니까?

내가 가진 또 다른 질문은, 소금 2 개를 갖는 것이 현명하지 않을까요? 하나는 파일에, 다른 하나는 DB에 있습니까? 이렇게하면 누군가가 DB에서 소금을 훼손하더라도 파일에 직접 소금을 가지고 있습니까? 나는 소금을 저장하는 것이 결코 현명한 생각이 아니라는 것을 읽었지만 사람들이 그 의미를 항상 혼란스럽게했습니다.



답변

사용 password_hash은 암호를 저장하는 데 권장되는 방법입니다. DB와 파일로 분리하지 마십시오.

다음 입력이 있다고 가정 해 보겠습니다.

$password = $_POST['password'];

먼저 다음을 수행하여 암호를 해시합니다.

$hashed_password = password_hash($password, PASSWORD_DEFAULT);

그런 다음 출력을 확인합니다.

var_dump($hashed_password);

보시다시피 해시되었습니다. (나는 당신이 그 단계를 수행했다고 가정합니다).

이제이 해시 된 비밀번호를 데이터베이스에 저장 하여 비밀번호 열이 해시 된 값 (최소 60 자 이상)을 보유 할만큼 충분히 큰지 확인합니다 . 사용자가 로그인을 요청하면 다음을 수행하여 데이터베이스에서이 해시 값으로 비밀번호 입력을 확인합니다.

// Query the database for username and password
// ...

if(password_verify($password, $hashed_password)) {
    // If the password inputs matched the hashed password in the database
    // Do something, you know... log them in.
}

// Else, Redirect them back to the login page.

공식 참조


답변

예, 올바르게 이해했습니다. password_hash () 함수는 자체적으로 솔트를 생성하고 결과 해시 값에 포함합니다. 데이터베이스에 솔트를 저장하는 것은 절대적으로 정확하며 알려진 경우에도 해당 작업을 수행합니다.

// Hash a new password for storing in the database.
// The function automatically generates a cryptographically safe salt.
$hashToStoreInDb = password_hash($_POST['password'], PASSWORD_DEFAULT);

// Check if the hash of the entered login password, matches the stored hash.
// The salt and the cost factor will be extracted from $existingHashFromDb.
$isPasswordCorrect = password_verify($_POST['password'], $existingHashFromDb);

두 번째 소금 (파일에 저장된 소금)은 실제로 후추 또는 서버 측 키입니다. 해싱하기 전에 (소금처럼) 추가하면 후추를 추가합니다. 하지만 더 좋은 방법이 있습니다. 먼저 해시를 계산 한 다음 서버 측 키로 해시를 암호화 (양방향) 할 수 있습니다. 이렇게하면 필요할 때 키를 변경할 수 있습니다.

소금과 달리이 키는 비밀로 유지해야합니다. 사람들은 종종 그것을 섞어 소금을 숨기려고하지만 소금이 제 역할을하도록하고 열쇠로 비밀을 추가하는 것이 좋습니다.


답변

그래 그건 사실이야. 함수에 대한 PHP FAQ를 의심하는 이유는 무엇입니까? 🙂

실행 결과 password_hash()는 네 부분으로 구성됩니다.

  1. 사용 된 알고리즘
  2. 매개 변수
  3. 소금
  4. 실제 비밀번호 해시

보시다시피 해시는 그 일부입니다.

물론, 추가 보안 계층을 위해 추가 솔트를 가질 수 있지만 솔직히 일반 PHP 응용 프로그램에서는 과잉이라고 생각합니다. 기본 bcrypt 알고리즘은 훌륭하고 선택적인 복어 알고리즘은 틀림없이 훨씬 더 좋습니다.


답변

절대로 md5 ()를 사용하여 암호를 보호하십시오. 솔트를 사용하더라도 항상 위험합니다 !!

아래와 같이 최신 해싱 알고리즘으로 비밀번호를 보호하세요.

<?php

// Your original Password
$password = '121@121';

//PASSWORD_BCRYPT or PASSWORD_DEFAULT use any in the 2nd parameter
/*
PASSWORD_BCRYPT always results 60 characters long string.
PASSWORD_DEFAULT capacity is beyond 60 characters
*/
$password_encrypted = password_hash($password, PASSWORD_BCRYPT);

데이터베이스의 암호화 된 비밀번호와 사용자가 입력 한 비밀번호를 일치 시키려면 아래 기능을 사용하십시오.

<?php

if (password_verify($password_inputted_by_user, $password_encrypted)) {
    // Success!
    echo 'Password Matches';
}else {
    // Invalid credentials
    echo 'Password Mismatch';
}

자신의 솔트를 사용하려면 사용자 정의 생성 함수를 동일하게 사용하십시오. 아래를 따르십시오. 그러나 최신 버전의 PHP에서 더 이상 사용되지 않기 때문에 권장하지 않습니다.

아래 코드를 사용하기 전에 password_hash () 에 대해 읽어보십시오 .

<?php

$options = [
    'salt' => your_custom_function_for_salt(),
    //write your own code to generate a suitable & secured salt
    'cost' => 12 // the default cost is 10
];

$hash = password_hash($your_password, PASSWORD_DEFAULT, $options);


답변

PHP의 암호 기능에 내장 된 역방향 및 순방향 호환성에 대한 논의가 뚜렷하지 않습니다. 특히 :

  1. 이전 버전과의 호환성 : 비밀번호 함수는 기본적으로 잘 작성된 래퍼 crypt()이며 crypt()더 이상 사용되지 않거나 안전하지 않은 해시 알고리즘을 사용하더라도 본질적으로 -format 해시 와 이전 버전과 호환됩니다 .
  2. 포워드 호환성 :password_needs_rehash() 인증 워크 플로에 약간의 논리를 삽입 하면 워크 플로에 대한 향후 변경 사항이 없을 가능성이있는 현재 및 미래의 알고리즘으로 해시를 최신 상태로 유지할 수 있습니다. 참고 : 지정된 알고리즘과 일치하지 않는 문자열은 비 암호화 호환 해시를 포함하여 재해시가 필요한 것으로 플래그가 지정됩니다.

예 :

class FakeDB {
    public function __call($name, $args) {
        printf("%s::%s(%s)\n", __CLASS__, $name, json_encode($args));
        return $this;
    }
}

class MyAuth {
    protected $dbh;
    protected $fakeUsers = [
        // old crypt-md5 format
        1 => ['password' => '$1$AVbfJOzY$oIHHCHlD76Aw1xmjfTpm5.'],
        // old salted md5 format
        2 => ['password' => '3858f62230ac3c915f300c664312c63f', 'salt' => 'bar'],
        // current bcrypt format
        3 => ['password' => '$2y$10$3eUn9Rnf04DR.aj8R3WbHuBO9EdoceH9uKf6vMiD7tz766rMNOyTO']
    ];

    public function __construct($dbh) {
        $this->dbh = $dbh;
    }

    protected function getuser($id) {
        // just pretend these are coming from the DB
        return $this->fakeUsers[$id];
    }

    public function authUser($id, $password) {
        $userInfo = $this->getUser($id);

        // Do you have old, turbo-legacy, non-crypt hashes?
        if( strpos( $userInfo['password'], '$' ) !== 0 ) {
            printf("%s::legacy_hash\n", __METHOD__);
            $res = $userInfo['password'] === md5($password . $userInfo['salt']);
        } else {
            printf("%s::password_verify\n", __METHOD__);
            $res = password_verify($password, $userInfo['password']);
        }

        // once we've passed validation we can check if the hash needs updating.
        if( $res && password_needs_rehash($userInfo['password'], PASSWORD_DEFAULT) ) {
            printf("%s::rehash\n", __METHOD__);
            $stmt = $this->dbh->prepare('UPDATE users SET pass = ? WHERE user_id = ?');
            $stmt->execute([password_hash($password, PASSWORD_DEFAULT), $id]);
        }

        return $res;
    }
}

$auth = new MyAuth(new FakeDB());

for( $i=1; $i<=3; $i++) {
    var_dump($auth->authuser($i, 'foo'));
    echo PHP_EOL;
}

산출:

MyAuth::authUser::password_verify
MyAuth::authUser::rehash
FakeDB::prepare(["UPDATE users SET pass = ? WHERE user_id = ?"])
FakeDB::execute([["$2y$10$zNjPwqQX\/RxjHiwkeUEzwOpkucNw49yN4jjiRY70viZpAx5x69kv.",1]])
bool(true)

MyAuth::authUser::legacy_hash
MyAuth::authUser::rehash
FakeDB::prepare(["UPDATE users SET pass = ? WHERE user_id = ?"])
FakeDB::execute([["$2y$10$VRTu4pgIkGUvilTDRTXYeOQSEYqe2GjsPoWvDUeYdV2x\/\/StjZYHu",2]])
bool(true)

MyAuth::authUser::password_verify
bool(true)

마지막으로, 로그인 할 때만 사용자의 암호를 다시 해시 할 수 있다는 점을 감안할 때 사용자를 보호하기 위해 안전하지 않은 레거시 해시를 “일몰 설정”하는 것을 고려해야합니다. 즉, 특정 유예 기간이 지나면 안전하지 않은 (예 : 베어 MD5 / SHA / 그렇지 않으면 약한) 해시를 모두 제거하고 사용자가 애플리케이션의 암호 재설정 메커니즘에 의존하도록합니다.


답변

클래스 비밀번호 전체 코드 :

Class Password {

    public function __construct() {}


    /**
     * Hash the password using the specified algorithm
     *
     * @param string $password The password to hash
     * @param int    $algo     The algorithm to use (Defined by PASSWORD_* constants)
     * @param array  $options  The options for the algorithm to use
     *
     * @return string|false The hashed password, or false on error.
     */
    function password_hash($password, $algo, array $options = array()) {
        if (!function_exists('crypt')) {
            trigger_error("Crypt must be loaded for password_hash to function", E_USER_WARNING);
            return null;
        }
        if (!is_string($password)) {
            trigger_error("password_hash(): Password must be a string", E_USER_WARNING);
            return null;
        }
        if (!is_int($algo)) {
            trigger_error("password_hash() expects parameter 2 to be long, " . gettype($algo) . " given", E_USER_WARNING);
            return null;
        }
        switch ($algo) {
            case PASSWORD_BCRYPT :
                // Note that this is a C constant, but not exposed to PHP, so we don't define it here.
                $cost = 10;
                if (isset($options['cost'])) {
                    $cost = $options['cost'];
                    if ($cost < 4 || $cost > 31) {
                        trigger_error(sprintf("password_hash(): Invalid bcrypt cost parameter specified: %d", $cost), E_USER_WARNING);
                        return null;
                    }
                }
                // The length of salt to generate
                $raw_salt_len = 16;
                // The length required in the final serialization
                $required_salt_len = 22;
                $hash_format = sprintf("$2y$%02d$", $cost);
                break;
            default :
                trigger_error(sprintf("password_hash(): Unknown password hashing algorithm: %s", $algo), E_USER_WARNING);
                return null;
        }
        if (isset($options['salt'])) {
            switch (gettype($options['salt'])) {
                case 'NULL' :
                case 'boolean' :
                case 'integer' :
                case 'double' :
                case 'string' :
                    $salt = (string)$options['salt'];
                    break;
                case 'object' :
                    if (method_exists($options['salt'], '__tostring')) {
                        $salt = (string)$options['salt'];
                        break;
                    }
                case 'array' :
                case 'resource' :
                default :
                    trigger_error('password_hash(): Non-string salt parameter supplied', E_USER_WARNING);
                    return null;
            }
            if (strlen($salt) < $required_salt_len) {
                trigger_error(sprintf("password_hash(): Provided salt is too short: %d expecting %d", strlen($salt), $required_salt_len), E_USER_WARNING);
                return null;
            } elseif (0 == preg_match('#^[a-zA-Z0-9./]+$#D', $salt)) {
                $salt = str_replace('+', '.', base64_encode($salt));
            }
        } else {
            $salt = str_replace('+', '.', base64_encode($this->generate_entropy($required_salt_len)));
        }
        $salt = substr($salt, 0, $required_salt_len);

        $hash = $hash_format . $salt;

        $ret = crypt($password, $hash);

        if (!is_string($ret) || strlen($ret) <= 13) {
            return false;
        }

        return $ret;
    }


    /**
     * Generates Entropy using the safest available method, falling back to less preferred methods depending on support
     *
     * @param int $bytes
     *
     * @return string Returns raw bytes
     */
    function generate_entropy($bytes){
        $buffer = '';
        $buffer_valid = false;
        if (function_exists('mcrypt_create_iv') && !defined('PHALANGER')) {
            $buffer = mcrypt_create_iv($bytes, MCRYPT_DEV_URANDOM);
            if ($buffer) {
                $buffer_valid = true;
            }
        }
        if (!$buffer_valid && function_exists('openssl_random_pseudo_bytes')) {
            $buffer = openssl_random_pseudo_bytes($bytes);
            if ($buffer) {
                $buffer_valid = true;
            }
        }
        if (!$buffer_valid && is_readable('/dev/urandom')) {
            $f = fopen('/dev/urandom', 'r');
            $read = strlen($buffer);
            while ($read < $bytes) {
                $buffer .= fread($f, $bytes - $read);
                $read = strlen($buffer);
            }
            fclose($f);
            if ($read >= $bytes) {
                $buffer_valid = true;
            }
        }
        if (!$buffer_valid || strlen($buffer) < $bytes) {
            $bl = strlen($buffer);
            for ($i = 0; $i < $bytes; $i++) {
                if ($i < $bl) {
                    $buffer[$i] = $buffer[$i] ^ chr(mt_rand(0, 255));
                } else {
                    $buffer .= chr(mt_rand(0, 255));
                }
            }
        }
        return $buffer;
    }

    /**
     * Get information about the password hash. Returns an array of the information
     * that was used to generate the password hash.
     *
     * array(
     *    'algo' => 1,
     *    'algoName' => 'bcrypt',
     *    'options' => array(
     *        'cost' => 10,
     *    ),
     * )
     *
     * @param string $hash The password hash to extract info from
     *
     * @return array The array of information about the hash.
     */
    function password_get_info($hash) {
        $return = array('algo' => 0, 'algoName' => 'unknown', 'options' => array(), );
        if (substr($hash, 0, 4) == '$2y$' && strlen($hash) == 60) {
            $return['algo'] = PASSWORD_BCRYPT;
            $return['algoName'] = 'bcrypt';
            list($cost) = sscanf($hash, "$2y$%d$");
            $return['options']['cost'] = $cost;
        }
        return $return;
    }

    /**
     * Determine if the password hash needs to be rehashed according to the options provided
     *
     * If the answer is true, after validating the password using password_verify, rehash it.
     *
     * @param string $hash    The hash to test
     * @param int    $algo    The algorithm used for new password hashes
     * @param array  $options The options array passed to password_hash
     *
     * @return boolean True if the password needs to be rehashed.
     */
    function password_needs_rehash($hash, $algo, array $options = array()) {
        $info = password_get_info($hash);
        if ($info['algo'] != $algo) {
            return true;
        }
        switch ($algo) {
            case PASSWORD_BCRYPT :
                $cost = isset($options['cost']) ? $options['cost'] : 10;
                if ($cost != $info['options']['cost']) {
                    return true;
                }
                break;
        }
        return false;
    }

    /**
     * Verify a password against a hash using a timing attack resistant approach
     *
     * @param string $password The password to verify
     * @param string $hash     The hash to verify against
     *
     * @return boolean If the password matches the hash
     */
    public function password_verify($password, $hash) {
        if (!function_exists('crypt')) {
            trigger_error("Crypt must be loaded for password_verify to function", E_USER_WARNING);
            return false;
        }
        $ret = crypt($password, $hash);
        if (!is_string($ret) || strlen($ret) != strlen($hash) || strlen($ret) <= 13) {
            return false;
        }

        $status = 0;
        for ($i = 0; $i < strlen($ret); $i++) {
            $status |= (ord($ret[$i]) ^ ord($hash[$i]));
        }

        return $status === 0;
    }

}


답변

저는 비밀번호 유효성 검사를 위해 항상 사용하는 함수를 만들고, 예를 들어 MySQL 데이터베이스에 저장하기 위해 비밀번호를 생성했습니다. 정적 솔트를 사용하는 것보다 훨씬 더 안전한 무작위 생성 솔트를 사용합니다.

function secure_password($user_pwd, $multi) {

/*
    secure_password ( string $user_pwd, boolean/string $multi ) 

    *** Description: 
        This function verifies a password against a (database-) stored password's hash or
        returns $hash for a given password if $multi is set to either true or false

    *** Examples:
        // To check a password against its hash
        if(secure_password($user_password, $row['user_password'])) {
            login_function();
        } 
        // To create a password-hash
        $my_password = 'uber_sEcUrE_pass';
        $hash = secure_password($my_password, true);
        echo $hash;
*/

// Set options for encryption and build unique random hash
$crypt_options = ['cost' => 11, 'salt' => mcrypt_create_iv(22, MCRYPT_DEV_URANDOM)];
$hash = password_hash($user_pwd, PASSWORD_BCRYPT, $crypt_options);

// If $multi is not boolean check password and return validation state true/false
if($multi!==true && $multi!==false) {
    if (password_verify($user_pwd, $table_pwd = $multi)) {
        return true; // valid password
    } else {
        return false; // invalid password
    }
// If $multi is boolean return $hash
} else return $hash;

}