उपयोगकर्ता पासवर्ड में नमक कैसे जोड़ें?

Question

मैं सरल md5($password); प्रारूप का उपयोग कर रहा हूं लेकिन मैं नमक जोड़ना चाहता हूं तो मैं यह कैसे कर सकता हूं?

यहाँ मेरी कोड है:

if($success) 
    { 
     $data['firstname'] = $firstname; 
     $data['lastname'] = $lastname; 
     $data['username'] = $username; 
     $data['password'] = md5($password); 
     $data['email'] = $email; 


     $newUser = new User($data); 
     $newUser->save(true); 
     $Newuser->login($username, $password); 
     header("Location: welcome.php"); 

    } 

Answer 1

$data['hashedpwd'] = md5($salt . $password); 

अब, और अधिक जटिल और प्रत्येक उपयोगकर्ता के लिए अद्वितीय आप नमक कठिन किसी को भी (पासवर्ड प्राप्त करने के लिए हालांकि यह असंभव नहीं है यह हो जाएगा कर सकते हैं)।

एक साधारण (लेकिन गरीब नमक) होगा: $salt = '10';
एक बहुत मजबूत नमक होगा: $salt = '-45dfeHK/__yu349@-/klF21-1_\/4JkUP/4';

लवण है कि उपयोगकर्ता के लिए अद्वितीय हैं और भी बेहतर कर रहे हैं।

जैसा कि कई टिप्पणियों में उल्लिखित है md5 एक पुराना और अपेक्षाकृत खराब हैशिंग अल्गोरिथम है, SHA-512 या SHA-2 परिवार में से कोई भी बेहतर विकल्प होगा।

अधिक जानकारी के लिए this salting question देखें।

Answer 2

यहाँ एक उदाहरण है: (अपना पासवर्ड यहां का प्रयोग करें)

$pass = 'abcxyz123'; // password 
    $salt = '}#f4ga~g%7hjg4&j(7mk?/!bj30ab-wi=6^7-$^R9F|GK5J#E6WT;IO[JN'; // random string 

    $hash = md5($pass); 
    $hash_md5 = md5($salt . $pass); 

    // echo now 
    echo 'Original Password: ' . $pass . '<br><br>'; 
    echo 'Original Salt: ' . $salt . '<br><br>'; 
    echo 'MD5: ' . $hash . '<br><br>'; 
    echo 'MD5 with Salt: ' . $hash_md5 . '<br><br>'; 

Answer 3

$salt="Your text vatiable"; 
$data[passsord] = md5($salt . $password); 

Answer 4

अन्य लोगों को पता चला है कि यह कैसे किया जा सकता है ताकि सामान्य रूप में सिद्धांतों के बारे में ...

की तरह पहले से ही टिप्पणियों में NullUserException से जुड़ा हुआ है, अगर सुरक्षा मामलों के मामले में आपको एमडी 5 में स्थिर नमक जोड़कर ऐसा नहीं करना चाहिए। Note however that you can store your salt as-is। स्थिर नमक और एमडी 5 दोनों को बहुत सुरक्षित दृष्टिकोण नहीं माना जाता है। वे ठीक हैं अगर इससे कोई फर्क नहीं पड़ता है, लेकिन अगर ऐसा होता है, तो आपको दूसरी तरफ जाना चाहिए।

About static salt:

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

प्रत्येक बार जब उपयोगकर्ता खाता बनाता है या अपना पासवर्ड बदलता है तो एक नया यादृच्छिक नमक उत्पन्न किया जाना चाहिए।

यदि नमक स्थिर है, तो हमलावर सभी संभावनाओं के लिए इंद्रधनुष तालिका उत्पन्न कर सकता है। एक नमक के साथ जो उपयोगकर्ता के लिए अद्वितीय है, ऐसा करने में कोई बात नहीं है।

md5 कम्प्यूटेशनल गति के लिए डिज़ाइन किया गया है, इसलिए यह fundamentally not the way to go है। इसके अलावा, इसके लिए pre-created rainbow tables पहले से ही बहुत सारे हैं, और online cracking tools के बहुत सारे हैं।

लिंक किए गए पृष्ठ में PHP source code भी शामिल है, यह भी एक उदाहरण के रूप में है कि इसे ठीक से कैसे किया जाए।

<?php 
/* 
* Password hashing with PBKDF2. 
* Author: havoc AT defuse.ca 
* www: https://defuse.ca/php-pbkdf2.htm 
*/ 

// These constants may be changed without breaking existing hashes. 
define("PBKDF2_HASH_ALGORITHM", "sha256"); 
define("PBKDF2_ITERATIONS", 1000); 
define("PBKDF2_SALT_BYTES", 24); 
define("PBKDF2_HASH_BYTES", 24); 

define("HASH_SECTIONS", 4); 
define("HASH_ALGORITHM_INDEX", 0); 
define("HASH_ITERATION_INDEX", 1); 
define("HASH_SALT_INDEX", 2); 
define("HASH_PBKDF2_INDEX", 3); 

function create_hash($password) 
{ 
    // format: algorithm:iterations:salt:hash 
    $salt = base64_encode(mcrypt_create_iv(PBKDF2_SALT_BYTES, MCRYPT_DEV_URANDOM)); 
    return PBKDF2_HASH_ALGORITHM . ":" . PBKDF2_ITERATIONS . ":" . $salt . ":" . 
     base64_encode(pbkdf2(
      PBKDF2_HASH_ALGORITHM, 
      $password, 
      $salt, 
      PBKDF2_ITERATIONS, 
      PBKDF2_HASH_BYTES, 
      true 
     )); 
} 

function validate_password($password, $good_hash) 
{ 
    $params = explode(":", $good_hash); 
    if(count($params) < HASH_SECTIONS) 
     return false; 
    $pbkdf2 = base64_decode($params[HASH_PBKDF2_INDEX]); 
    return slow_equals(
     $pbkdf2, 
     pbkdf2(
      $params[HASH_ALGORITHM_INDEX], 
      $password, 
      $params[HASH_SALT_INDEX], 
      (int)$params[HASH_ITERATION_INDEX], 
      strlen($pbkdf2), 
      true 
     ) 
    ); 
} 

// Compares two strings $a and $b in length-constant time. 
function slow_equals($a, $b) 
{ 
    $diff = strlen($a)^strlen($b); 
    for($i = 0; $i < strlen($a) && $i < strlen($b); $i++) 
    { 
     $diff |= ord($a[$i])^ord($b[$i]); 
    } 
    return $diff === 0; 
} 

/* 
* PBKDF2 key derivation function as defined by RSA's PKCS #5: https://www.ietf.org/rfc/rfc2898.txt 
* $algorithm - The hash algorithm to use. Recommended: SHA256 
* $password - The password. 
* $salt - A salt that is unique to the password. 
* $count - Iteration count. Higher is better, but slower. Recommended: At least 1000. 
* $key_length - The length of the derived key in bytes. 
* $raw_output - If true, the key is returned in raw binary format. Hex encoded otherwise. 
* Returns: A $key_length-byte key derived from the password and salt. 
* 
* Test vectors can be found here: https://www.ietf.org/rfc/rfc6070.txt 
* 
* This implementation of PBKDF2 was originally created by https://defuse.ca 
* With improvements by http://www.variations-of-shadow.com 
*/ 
function pbkdf2($algorithm, $password, $salt, $count, $key_length, $raw_output = false) 
{ 
    $algorithm = strtolower($algorithm); 
    if(!in_array($algorithm, hash_algos(), true)) 
     die('PBKDF2 ERROR: Invalid hash algorithm.'); 
    if($count <= 0 || $key_length <= 0) 
     die('PBKDF2 ERROR: Invalid parameters.'); 

    $hash_length = strlen(hash($algorithm, "", true)); 
    $block_count = ceil($key_length/$hash_length); 

    $output = ""; 
    for($i = 1; $i <= $block_count; $i++) { 
     // $i encoded as 4 bytes, big endian. 
     $last = $salt . pack("N", $i); 
     // first iteration 
     $last = $xorsum = hash_hmac($algorithm, $last, $password, true); 
     // perform the other $count - 1 iterations 
     for ($j = 1; $j < $count; $j++) { 
      $xorsum ^= ($last = hash_hmac($algorithm, $last, $password, true)); 
     } 
     $output .= $xorsum; 
    } 

    if($raw_output) 
     return substr($output, 0, $key_length); 
    else 
     return bin2hex(substr($output, 0, $key_length)); 
} 

Answer 5

पीएचपी 5.5 एक बहुत ही आसान पासवर्ड हैशिंग एपीआई का उपयोग करने लाएगा, और यह वर्तमान PHP संस्करण 5.3.7 पर शुरू के साथ अभी प्रयोग की जाने वाली reimplemented है।

मैं नकल कर सकता है & स्पष्टीकरण पेस्ट, लेकिन खुद के लिए देखें: https://github.com/ircmaxell/password_compat

संक्षेप में, यह इस तरह है:

/* Create the hash */ 
$hash = password_hash($password, PASSWORD_BCRYPT, array('cost' => 10)); 

/* Store the hash... then user comes back */ 
if (password_verify($password, $hash)) { 
    /* Valid */ 
} else { 
    /* Invalid */ 
} 

/* 
* If the security level has to be increased to new $options or a new $algorithm, 
* silent rehashing is supported 
*/ 
if (password_verify($password, $hash)) { 
    if (password_needs_rehash($hash, $algorithm, $options)) { 
     $hash = password_hash($password, $algorithm, $options); 
     /* Store new hash in db */ 
    } 
} 

हैश जब तक 255 के रूप में वर्ण हो सकता है (नहीं bcrypt साथ, लेकिन जो भी हो सकता है), तदनुसार भंडारण की योजना बनाएं। डेटाबेस VARCHAR (255) का उपयोग करना चाहिए।