PHP में SSHA256 हैश के विरुद्ध पासवर्ड की पुष्टि करें




validation passwords (2)

आपको हथेले मूल्य के साथ नमक को स्टोर करने की आवश्यकता है

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

अपने प्रारूप के लिए, पहले base64_decode उपयोग करें, परिणाम के अंतिम 4 बाइट नमक होंगे।

Dovecot के साथ प्रमाणीकरण के लिए, मैं SSHA256 हैशेस का उपयोग करता हूं लेकिन मेरे पास कोई सुराग नहीं है कि मौजूदा हैश के खिलाफ दिए गए पासवर्ड को कैसे मान्य किया जाए। निम्न PHP फ़ंक्शंस (वेब ​​में उन्हें मिला) का उपयोग SSHA256 हैश बनाने के लिए किया जाता है:

function ssha256($pw) {
        $salt = make_salt();
        return "{SSHA256}" . base64_encode( hash('sha256', $pw . $salt, true ) . $salt );
}

function make_salt() {
        $len   = 4;
        $bytes = array();
        for ($i = 0; $i < $len; $i++ ) {
                $bytes[] = rand(1,255);
        }
        $salt_str = '';
        foreach ($bytes as $b) {
                $salt_str .= pack('C', $b);
        }
        return $salt_str;
}

उदाहरण आउटपुट: {SSHA256}lGq49JTKmBC49AUrk7wLyQVmeZ7cGl/V13A9QbY4RVKchckL

क्या मुझे नमक निकालना है, लेकिन कैसे? इस समस्या को सुलझाने के लिए मैंने पूरी तरह से रास्ता खो दिया है, क्या इसका कोई भी संकेत है?

मदद करने के लिए सभी के लिए धन्यवाद!

ओह और माफ करना, मुझे एसएसएच 256 का प्रयोग करना है, क्योंकि डवेकॉट 1.2.15 केवल उन योजनाओं का समर्थन करता है: CRYPT MD5 MD5-CRYPT SHA SHA1 SHA256 SMD5 SSHA SSHA256 PLAIN CLEARTEXT CRAM-MD5 HMAC-MD5 DIGEST-MD5 PLAIN-MD4 PLAIN-MD5 LDAP-MD5 LANMAN NTLM OTP SKEY RPA


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

class PassHash {
    public static function rand_str($length) {
        $total = $length % 2;
        $output = "";
        if ($total !== 0) {
            $count = floor($length / 2);
            $output .= ".";
        } else $count = $length / 2;

        $bytes = openssl_random_pseudo_bytes($count);
        $output .= bin2hex($bytes);

        // warning: prepending with a dot if the length is odd.
        // this can be very dangerous. no clue why you'd want your
        // bcrypt salt to do this, but /shrug

        return $output;
    }
    // 2y is an exploit fix, and an improvement over 2a. Only available in 5.4.0+
    public static function hash($input) {
        return crypt($input, "$2y$13$" . self::rand_str(22));

    }

    // legacy support, add exception handling and fall back to <= 5.3.0
    public static function hash_weak($input) {
        return crypt($input, "$2a$13$" . self::rand_str(22));
    }

    public static function compare($input, $hash) {
        return (crypt($input, $hash) === $hash);
    }
}

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

अगर, जैसा कि आप कहते हैं, आपके पास इसका क्रियान्वयन करने का कोई तरीका नहीं है, तो आप इस प्रकार हैश को खोल सकते हैं:

function unpack_hash($hash) {
        $hash = base64_decode($hash);
        $split = str_split($hash, 64);
        return array("salt" => $split[1], "hash" => $split[0]);

ऐसा इसलिए है क्योंकि SHA256 256 बिट या 64 हेक्स वर्ण हैं। आप हमेशा ही मान सकते हैं कि पहले 64 वर्ण हैंश हैं





salt