php Password_hash का उपयोग कैसे करें




salt password-hash (6)

हाल ही में मैं इंटरनेट पर ठोकर खाई हुई स्क्रिप्ट पर एक लॉग पर अपनी खुद की सुरक्षा को लागू करने की कोशिश कर रहा हूं। प्रत्येक उपयोगकर्ता के लिए नमक बनाने के लिए अपनी स्क्रिप्ट बनाने का तरीका सीखने की कोशिश करने के संघर्ष के बाद, मैंने पासवर्ड_हश पर ठोकर खाई।

जो मैं समझता हूं, इस पृष्ठ पर पढ़ने के आधार पर: http://php.net/manual/en/faq.passwords.php ), जब आप पासवर्ड_हश का उपयोग करते हैं तो पंक्ति में पहले से ही नमक उत्पन्न होता है। क्या ये सच है?

एक और सवाल मैं था, यह 2 लवण के लिए स्मार्ट नहीं होगा? एक सीधे फाइल में और एक डीबी में? इस तरह, अगर कोई आपके नमक को डीबी में समझौता करता है, तो आपके पास सीधे फाइल में एक है? मैंने यहाँ पर पढ़ा कि नमक जमा करना कभी भी एक अच्छा विचार नहीं है, लेकिन इसने मुझे हमेशा भ्रमित किया कि लोगों का इससे क्या मतलब है।


अपने पासवर्ड को सुरक्षित रखने के लिए कभी भी md5 () का उपयोग न करें, यहां तक ​​कि नमक के साथ, यह हमेशा खतरनाक होता है !!

नीचे दिए गए नवीनतम हैशिंग एल्गोरिदम के साथ अपना पासवर्ड सुरक्षित बनाएं।

<?php

// Your original Password
$password = '[email protected]';

//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';
}

?>

यदि आप अपने स्वयं के नमक का उपयोग करना चाहते हैं, तो उसी के लिए अपने कस्टम जनरेटेड फ़ंक्शन का उपयोग करें, बस नीचे का पालन करें, लेकिन मैं इसे अनुशंसित नहीं करता हूं क्योंकि यह पीएचपी के नवीनतम संस्करणों में पदावनत पाया गया है।

नीचे दिए गए कोड का उपयोग करने से पहले इसे http://php.net/manual/en/function.password-hash.php पढ़ें।

<?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);

?>

आशा है ये सभी मदद करेंगे !!


हाँ, आपने इसे सही ढंग से समझा, फंक्शन पासवर्ड_हाश () अपने आप ही एक नमक उत्पन्न करेगा, और इसे परिणामी हैश-मूल्य में शामिल करता है। डेटाबेस में नमक का भंडारण बिल्कुल सही है, यह अपना काम करता है भले ही वह जानता हो।

// 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);

आपके द्वारा उल्लेखित दूसरा नमक (एक फ़ाइल में संग्रहीत), वास्तव में एक काली मिर्च या सर्वर साइड कुंजी है। यदि आप इसे हैशिंग (नमक की तरह) से पहले जोड़ते हैं, तो आप एक काली मिर्च जोड़ते हैं। एक बेहतर तरीका है, हालांकि, आप पहले हैश की गणना कर सकते हैं, और बाद में सर्वर-साइड की के साथ हैश को एन्क्रिप्ट (दो-तरफा) कर सकते हैं। यह आपको आवश्यक होने पर कुंजी को बदलने की संभावना देता है।

नमक के विपरीत, इस कुंजी को गुप्त रखा जाना चाहिए। लोग अक्सर इसे मिलाते हैं और नमक को छिपाने की कोशिश करते हैं, लेकिन नमक को अपना काम करने देना बेहतर है और एक कुंजी के साथ रहस्य को जोड़ना है।


मैंने एक फ़ंक्शन बनाया है जो मैं पासवर्ड सत्यापन के लिए और पासवर्ड बनाने के लिए हर समय उपयोग करता हूं, उदाहरण के लिए उन्हें एक 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;

}

कक्षा पासवर्ड पूर्ण कोड:

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;
    }

}

हाँ यह सच हे। आप फ़ंक्शन पर php faq पर संदेह क्यों करते हैं? :)

password_hash() परिणाम के चार भाग हैं:

  1. एल्गोरिथ्म का इस्तेमाल किया
  2. मापदंडों
  3. नमक
  4. वास्तविक पासवर्ड हैश

तो जैसा कि आप देख सकते हैं, हैश इसका एक हिस्सा है।

ज़रूर, आपके पास सुरक्षा की एक अतिरिक्त परत के लिए एक अतिरिक्त नमक हो सकता है, लेकिन मुझे ईमानदारी से लगता है कि यह एक नियमित php एप्लिकेशन में ओवरकिल है। डिफ़ॉल्ट bcrypt एल्गोरिथ्म अच्छा है, और वैकल्पिक ब्लोफिश एक यकीनन बेहतर भी है।


password_hash स्टोर करने के लिए पासवर्ड_हाश का उपयोग करना अनुशंसित तरीका है। उन्हें DB और फ़ाइलों से अलग न करें।

मान लें कि हमारे पास निम्नलिखित इनपुट हैं:

$password = $_POST['password'];

मैं केवल अवधारणा को समझने के लिए इनपुट को मान्य नहीं करता हूं।

ऐसा करने से आपको पहले पासवर्ड हैश करना चाहिए:

$hashed_password = password_hash($password, PASSWORD_DEFAULT);

फिर आउटपुट देखें:

var_dump($hashed_password);

जैसा कि आप देख सकते हैं कि यह हैशेड है। (मुझे लगता है कि आप उन चरणों को किया था)।

अब आप अपने डेटाबेस में इस hashed_password को स्टोर करते हैं, और फिर कहते हैं कि जब कोई उपयोगकर्ता उन्हें लॉग इन करने के लिए कहता है। आप डेटाबेस में इस हैश मान के साथ पासवर्ड इनपुट की जाँच करते हैं:

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

आधिकारिक संदर्भ





php-password-hash