निजी तौर पर, मैं mcryptदूसरों की तरह इस्तेमाल करूंगा । लेकिन नोट करने के लिए बहुत कुछ है ...
मैं PHP में पासवर्ड कैसे एन्क्रिप्ट और डिक्रिप्ट कर सकता हूं?
एक मजबूत वर्ग के लिए नीचे देखें जो आपके लिए हर चीज़ का ध्यान रखता है:
पासवर्ड को एन्क्रिप्ट करने के लिए सबसे सुरक्षित एल्गोरिदम क्या है?
सबसे सुरक्षित ? उनमे से कोई भी। यदि आप एन्क्रिप्ट करने जा रहे हैं तो सबसे सुरक्षित तरीका है सूचना प्रकटीकरण भेद्यता (XSS, दूरस्थ समावेशन, आदि) से बचाव करना। यदि यह बाहर हो जाता है, तो हमलावर अंततः एन्क्रिप्शन को क्रैक कर सकता है (कोई एन्क्रिप्शन कुंजी के बिना 100% अन-रिवर्सिबल है - जैसा कि @NullUserException बताते हैं कि यह पूरी तरह से सच नहीं है। कुछ एन्क्रिप्शन योजनाएं हैं जो कि वनटाइमपैड को क्रैक करना असंभव हैं )। ।
मैं निजी कुंजी कहां संग्रहीत करूं?
मैं क्या करूँगा 3 कुंजी का उपयोग करें। एक उपयोगकर्ता की आपूर्ति की है, एक आवेदन विशिष्ट है और दूसरा उपयोगकर्ता विशिष्ट (एक नमक की तरह) है। एप्लिकेशन विशिष्ट कुंजी कहीं भी संग्रहीत की जा सकती है (वेब-रूट के बाहर एक कॉन्फ़िगरेशन फ़ाइल में, एक पर्यावरण चर में, आदि)। उपयोगकर्ता विशिष्ट एक एन्क्रिप्टेड पासवर्ड के बगल में db में एक कॉलम में संग्रहीत किया जाएगा। आपूर्ति की गई उपयोगकर्ता को संग्रहीत नहीं किया जाएगा। फिर, आप ऐसा कुछ करेंगे:
$key = $userKey . $serverKey . $userSuppliedKey;
वहाँ लाभ यह है कि किसी भी 2 कीज़ को डेटा से समझौता किए बिना समझौता किया जा सकता है। यदि कोई SQL इंजेक्शन हमला होता है, तो वे प्राप्त कर सकते हैं $userKey, लेकिन अन्य नहीं। 2. यदि कोई स्थानीय सर्वर शोषण है, तो वे मिल सकते हैं $userKeyऔर $serverKeyतीसरे नहीं $userSuppliedKey। यदि वे उपयोगकर्ता को रिंच के साथ हराते हैं, तो वे प्राप्त कर सकते हैं $userSuppliedKey, लेकिन अन्य 2 नहीं (लेकिन फिर से, यदि उपयोगकर्ता रिंच के साथ पीटा जाता है, तो आप वैसे भी बहुत देर हो चुके हैं)।
निजी कुंजी संग्रहीत करने के बजाय, क्या उपयोगकर्ताओं को निजी कुंजी दर्ज करने के लिए किसी भी समय पासवर्ड की आवश्यकता होती है, जिसे उन्हें डिक्रिप्ट किए गए पासवर्ड की आवश्यकता होती है? (इस एप्लिकेशन के उपयोगकर्ताओं पर भरोसा किया जा सकता है)
पूर्ण रूप से। वास्तव में, यह एकमात्र तरीका है कि मैं इसे करूंगा। अन्यथा आपको एक टिकाऊ भंडारण प्रारूप में एक अनएन्क्रिप्टेड संस्करण को संग्रहीत करने की आवश्यकता होगी (साझा मेमोरी जैसे एपीसी या मेमकेड, या एक सत्र फ़ाइल में)। वह खुद को अतिरिक्त समझौते के लिए उजागर कर रहा है। पासवर्ड के अनएन्क्रिप्टेड वर्जन को कभी भी स्थानीय वैरिएबल के अलावा किसी भी स्टोर में न रखें।
पासवर्ड किन तरीकों से चोरी और डिक्रिप्ट किया जा सकता है? मुझे क्या पता होना चाहिए?
आपके सिस्टम के किसी भी प्रकार का समझौता उन्हें एन्क्रिप्टेड डेटा को देखने देगा। यदि वे कोड को इंजेक्ट कर सकते हैं या आपके फाइल सिस्टम में आ सकते हैं, तो वे डिक्रिप्टेड डेटा देख सकते हैं (क्योंकि वे उन फ़ाइलों को संपादित कर सकते हैं जो डेटा को डिक्रिप्ट कर सकते हैं)। रीप्ले या MITM हमले के किसी भी रूप में उन्हें शामिल कुंजियों तक पूरी पहुंच मिलेगी। कच्चे HTTP ट्रैफ़िक को सूँघने से भी उन्हें चाबी मिलेगी।
सभी ट्रैफ़िक के लिए SSL का उपयोग करें। और सुनिश्चित करें कि सर्वर पर किसी भी प्रकार की कमजोरियां (CSRF, XSS, SQL इंजेक्शन, विशेषाधिकार वृद्धि, रिमोट कोड निष्पादन, आदि) नहीं हैं।
संपादित करें: यहाँ एक मजबूत एन्क्रिप्शन विधि का PHP वर्ग कार्यान्वयन है:
/**
* A class to handle secure encryption and decryption of arbitrary data
*
* Note that this is not just straight encryption. It also has a few other
* features in it to make the encrypted data far more secure. Note that any
* other implementations used to decrypt data will have to do the same exact
* operations.
*
* Security Benefits:
*
* - Uses Key stretching
* - Hides the Initialization Vector
* - Does HMAC verification of source data
*
*/
class Encryption {
/**
* @var string $cipher The mcrypt cipher to use for this instance
*/
protected $cipher = '';
/**
* @var int $mode The mcrypt cipher mode to use
*/
protected $mode = '';
/**
* @var int $rounds The number of rounds to feed into PBKDF2 for key generation
*/
protected $rounds = 100;
/**
* Constructor!
*
* @param string $cipher The MCRYPT_* cypher to use for this instance
* @param int $mode The MCRYPT_MODE_* mode to use for this instance
* @param int $rounds The number of PBKDF2 rounds to do on the key
*/
public function __construct($cipher, $mode, $rounds = 100) {
$this->cipher = $cipher;
$this->mode = $mode;
$this->rounds = (int) $rounds;
}
/**
* Decrypt the data with the provided key
*
* @param string $data The encrypted datat to decrypt
* @param string $key The key to use for decryption
*
* @returns string|false The returned string if decryption is successful
* false if it is not
*/
public function decrypt($data, $key) {
$salt = substr($data, 0, 128);
$enc = substr($data, 128, -64);
$mac = substr($data, -64);
list ($cipherKey, $macKey, $iv) = $this->getKeys($salt, $key);
if (!hash_equals(hash_hmac('sha512', $enc, $macKey, true), $mac)) {
return false;
}
$dec = mcrypt_decrypt($this->cipher, $cipherKey, $enc, $this->mode, $iv);
$data = $this->unpad($dec);
return $data;
}
/**
* Encrypt the supplied data using the supplied key
*
* @param string $data The data to encrypt
* @param string $key The key to encrypt with
*
* @returns string The encrypted data
*/
public function encrypt($data, $key) {
$salt = mcrypt_create_iv(128, MCRYPT_DEV_URANDOM);
list ($cipherKey, $macKey, $iv) = $this->getKeys($salt, $key);
$data = $this->pad($data);
$enc = mcrypt_encrypt($this->cipher, $cipherKey, $data, $this->mode, $iv);
$mac = hash_hmac('sha512', $enc, $macKey, true);
return $salt . $enc . $mac;
}
/**
* Generates a set of keys given a random salt and a master key
*
* @param string $salt A random string to change the keys each encryption
* @param string $key The supplied key to encrypt with
*
* @returns array An array of keys (a cipher key, a mac key, and a IV)
*/
protected function getKeys($salt, $key) {
$ivSize = mcrypt_get_iv_size($this->cipher, $this->mode);
$keySize = mcrypt_get_key_size($this->cipher, $this->mode);
$length = 2 * $keySize + $ivSize;
$key = $this->pbkdf2('sha512', $key, $salt, $this->rounds, $length);
$cipherKey = substr($key, 0, $keySize);
$macKey = substr($key, $keySize, $keySize);
$iv = substr($key, 2 * $keySize);
return array($cipherKey, $macKey, $iv);
}
/**
* Stretch the key using the PBKDF2 algorithm
*
* @see http://en.wikipedia.org/wiki/PBKDF2
*
* @param string $algo The algorithm to use
* @param string $key The key to stretch
* @param string $salt A random salt
* @param int $rounds The number of rounds to derive
* @param int $length The length of the output key
*
* @returns string The derived key.
*/
protected function pbkdf2($algo, $key, $salt, $rounds, $length) {
$size = strlen(hash($algo, '', true));
$len = ceil($length / $size);
$result = '';
for ($i = 1; $i <= $len; $i++) {
$tmp = hash_hmac($algo, $salt . pack('N', $i), $key, true);
$res = $tmp;
for ($j = 1; $j < $rounds; $j++) {
$tmp = hash_hmac($algo, $tmp, $key, true);
$res ^= $tmp;
}
$result .= $res;
}
return substr($result, 0, $length);
}
protected function pad($data) {
$length = mcrypt_get_block_size($this->cipher, $this->mode);
$padAmount = $length - strlen($data) % $length;
if ($padAmount == 0) {
$padAmount = $length;
}
return $data . str_repeat(chr($padAmount), $padAmount);
}
protected function unpad($data) {
$length = mcrypt_get_block_size($this->cipher, $this->mode);
$last = ord($data[strlen($data) - 1]);
if ($last > $length) return false;
if (substr($data, -1 * $last) !== str_repeat(chr($last), $last)) {
return false;
}
return substr($data, 0, -1 * $last);
}
}
ध्यान दें कि मैं PHP 5.6 में जोड़े गए फ़ंक्शन का उपयोग कर रहा हूं hash_equals:। यदि आप 5.6 से कम पर हैं, तो आप इस विकल्प फ़ंक्शन का उपयोग कर सकते हैं जो दोहरे एचएमएसी सत्यापन का उपयोग करके समय-सुरक्षित तुलना फ़ंक्शन को लागू करता है :
function hash_equals($a, $b) {
$key = mcrypt_create_iv(128, MCRYPT_DEV_URANDOM);
return hash_hmac('sha512', $a, $key) === hash_hmac('sha512', $b, $key);
}
उपयोग:
$e = new Encryption(MCRYPT_BLOWFISH, MCRYPT_MODE_CBC);
$encryptedData = $e->encrypt($data, $key);
फिर, डिक्रिप्ट करने के लिए:
$e2 = new Encryption(MCRYPT_BLOWFISH, MCRYPT_MODE_CBC);
$data = $e2->decrypt($encryptedData, $key);
ध्यान दें कि मैंने $e2दूसरी बार आपको विभिन्न उदाहरण दिखाने के लिए उपयोग किया था फिर भी डेटा को ठीक से डिक्रिप्ट करेगा।
अब, यह कैसे काम करता है / इसे किसी अन्य समाधान पर क्यों उपयोग किया जाता है:
चांबियाँ
चाबियाँ सीधे उपयोग नहीं की जाती हैं। इसके बजाय, कुंजी को एक मानक PBKDF2 व्युत्पत्ति द्वारा बढ़ाया जाता है।
एन्क्रिप्शन के लिए उपयोग की जाने वाली कुंजी पाठ के हर एन्क्रिप्ट किए गए ब्लॉक के लिए अद्वितीय है। इसलिए आपूर्ति की गई कुंजी "मास्टर कुंजी" बन जाती है। इसलिए यह वर्ग सिफर और ऑर्टिकल कीज़ के लिए मुख्य रोटेशन प्रदान करता है।
महत्वपूर्ण नोट , $roundsपैरामीटर पर्याप्त शक्ति की सच्ची यादृच्छिक कुंजियों के लिए कॉन्फ़िगर किया गया है (न्यूनतम पर क्रिप्टोग्राफिक रूप से सुरक्षित यादृच्छिक के 128 बिट्स)। यदि आप पासवर्ड, या गैर-यादृच्छिक कुंजी (या कम यादृच्छिक तो CS यादृच्छिक के 128 बिट्स) का उपयोग करने जा रहे हैं, तो आपको इस पैरामीटर को बढ़ाना होगा । मैं पासवर्ड के लिए न्यूनतम 10000 का सुझाव दूंगा (जितना अधिक आप खर्च कर सकते हैं, उतना बेहतर होगा, लेकिन यह रनटाइम को जोड़ देगा) ...
डेटा अखंडता
- अपडेट किया गया संस्करण ENCRYPT-THEN-MAC का उपयोग करता है, जो एन्क्रिप्टेड डेटा की प्रामाणिकता सुनिश्चित करने के लिए एक बेहतर तरीका है।
एन्क्रिप्शन:
- यह वास्तव में एन्क्रिप्शन का प्रदर्शन करने के लिए mcrypt का उपयोग करता है। मैं
MCRYPT_BLOWFISHया तो MCRYPT_RIJNDAEL_128साइफर्स और MCRYPT_MODE_CBCमोड के लिए उपयोग करने का सुझाव दूंगा । यह पर्याप्त मजबूत है, और अभी भी काफी तेज है (एक एन्क्रिप्शन और डिक्रिप्शन चक्र मेरी मशीन पर लगभग 1/2 सेकंड लेता है)।
अब, पहली सूची से बिंदु 3 के रूप में, जो आपको देता है वह इस तरह से एक फ़ंक्शन है:
function makeKey($userKey, $serverKey, $userSuppliedKey) {
$key = hash_hmac('sha512', $userKey, $serverKey);
$key = hash_hmac('sha512', $key, $userSuppliedKey);
return $key;
}
आप इसे makeKey()फंक्शन में स्ट्रेच कर सकते हैं , लेकिन चूंकि यह बाद में स्ट्रेच होने वाला है, इसलिए ऐसा करने के लिए वास्तव में बहुत बड़ी बात नहीं है।
जहाँ तक भंडारण आकार की बात है, यह सादे पाठ पर निर्भर करता है। ब्लोफिश 8 बाइट ब्लॉक आकार का उपयोग करता है, इसलिए आपके पास होगा:
- नमक के लिए 16 बाइट्स
- एचएएमएसी के लिए 64 बाइट्स
- डेटा की लंबाई
- पैडिंग ताकि डेटा लंबाई% 8 == 0 हो
तो 16 वर्ण डेटा स्रोत के लिए, एन्क्रिप्ट किए जाने वाले डेटा के 16 वर्ण होंगे। तो इसका मतलब है कि वास्तविक एन्क्रिप्टेड डेटा का आकार पैडिंग के कारण 16 बाइट्स है। फिर नमक के लिए 16 बाइट्स और एचएमएसी के लिए 64 बाइट्स जोड़ें और कुल संग्रहीत आकार 96 बाइट्स है। तो वहाँ सबसे अच्छा एक 80 चरित्र उपरि है, और सबसे खराब एक 87 चरित्र उपरि ...
मुझे आशा है कि वह मदद करेंगे...
नोट: १२/११/१२: मैंने सिर्फ बेहतर व्युत्पन्न कुंजियों का उपयोग करके और बेहतर तरीके से मैक जेनरेशन का उपयोग करते हुए इस वर्ग को बेहतर एन्क्रिप्शन विधि से अपडेट किया है ...