बीक्रिप्ट

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

बीक्रिप्ट फ़ंक्शन ओपनबीएसडी के लिए डिफ़ॉल्ट पासवर्ड हैश एल्गोरिथ्म है और कुछ लिनक्स वितरण जैसे एस यू एस इ लिनक्स के लिए डिफ़ॉल्ट था।

C, C++, Cशार्प, एम्बरकाडेरो डेल्फी, एलिक्सिर, गो, जावा, जावास्क्रिप्ट, पर्ल, पीएचपी, पायथन, रूबी, और अन्य भाषाओं में बीक्रिप्ट के कार्यान्वयन हैं। ।

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

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

विवरण
बीक्रिप्ट फ़ंक्शन का इनपुट पासवर्ड स्ट्रिंग (72 बाइट्स तक), एक संख्यात्मक लागत और 16-बाइट (128-बिट) साल्ट मान है। साल्ट प्रायः एक यादृच्छिक मान है। 24-बाइट (192-बिट) हैश की गणना करने के लिए बीक्रिप्ट फ़ंक्शन इन इनपुट्स का उपयोग करता है। बीक्रिप्ट फ़ंक्शन का अंतिम आउटपुट फ़ॉर्म की एक स्ट्रिंग है:

$2 $[लागत]$[22 वर्ण साल्ट] [31 वर्ण हैश]

उदाहरण के लिए, इनपुट पासवर्ड के साथ लागत , और एक यादृच्छिक साल्ट, बीक्रिप्ट का आउटपुट स्ट्रिंग है

$2a$12$R9h/cIPz0gi.URNNX3kh2OPST9/PgBkqquzi.Ss7KIUgO2t0jWMUW \__/\/ \____________________/\________________________________________/ एल्ग कॉस्ट      सॉल्ट                            हैश

जहां:


 * : हैश एल्गोरिथम पहचानकर्ता (बीक्रिप्ट)
 * : इनपुट लागत (212 यानी 4096 राउंड)
 * : इनपुट साल्ट का एक बेस-64 एनकोडिंग
 * : परिकलित 24 बाइट हैश के पहले 23 बाइट्स का बेस-64 एन्कोडिंग

बीक्रिप्ट में बेस-64 एनकोडिंग तालिका का उपयोग करता है, जो   बेस 64 एन्कोडिंग से अलग है।

संस्करण इतिहास
$2$ (1999)

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


 * : MD5-आधारित क्रिप्ट ('md5क्रिप्ट ')
 * : ब्लोफिश-आधारित क्रिप्ट ('बीक्रिप्ट')
 * : SHA-1-आधारित क्रिप्ट ('sha1क्रिप्ट')
 * : SHA-256-आधारित क्रिप्ट ('sha256क्रिप्ट')
 * : SHA-512-आधारित क्रिप्ट ('sha512क्रिप्ट')

$2a$

मूल विनिर्देश परिभाषित नहीं करता था कि गैर-एएससीआईआई वर्ण को कैसे संभालना है, न ही एक अशक्त टर्मिनेटर को कैसे संभालना है। विनिर्देश को यह निर्दिष्ट करने के लिए संशोधित किया गया था कि हैशिंग स्ट्रिंग्स:


 * स्ट्रिंग UTF-8 एन्कोडेड होनी चाहिए
 * अशक्त टर्मिनेटर सम्मिलित होना चाहिए

इस परिवर्तन के साथ, संस्करण को बदल दिया गया था

$2x$, $2y$ (जून 2011)

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

कैनोनिकल ओपनबीएसडी समेत किसी और ने 2x/2y के विचार को नहीं अपनाया। यह संस्करण मार्कर परिवर्तन क्रिप्ट_ब्लोफिश तक सीमित था।

$2b$ (फरवरी 2014)

बीक्रिप्ट के ओपनबीएसडी कार्यान्वयन में एक बग का पता चला था। यह पासवर्ड की लंबाई रखने के लिए एक असंकेतित 8-बिट मान का उपयोग कर रहा था। 255 बाइट्स से अधिक लंबे पासवर्ड के लिए, 72 बाइट्स पर छोटा किए जाने के अपेक्षाकृत पासवर्ड को 72 से कम या लंबाई माड्यूलो 256 पर छोटा कर दिया जाएगा। उदाहरण के लिए, एक 260 बाइट पासवर्ड को 72 बाइट्स पर छोटा करने के अपेक्षाकृत 4 बाइट्स पर छोटा कर दिया जाएगा।

बीक्रिप्ट ओपनबीएसडी के लिए बनाया गया था। जब उनके लाइब्रेरी में एक बग था, तो उन्होंने संस्करण संख्या को टक्कर देने का फैसला किया।

एल्गोरिथम
नीचे दिया गया बीक्रिप्ट फ़ंक्शन ब्लोफ़िश का उपयोग करके 64 बार  ऑर्फीनबीहोल्डरस्क्रीडाउट   टेक्स्ट को एन्क्रिप्ट करता है। बीक्रिप्ट में सामान्य ब्लोफिश की सेटअप फंक्शन को एक महंगे की सेटअप (ईकेएसब्लोफिशसेटअप) फंक्शन से बदल दिया जाता है:

Function bcrypt

Function bcrypt

Input: cost:    Number (4..31)                      log2(Iterations). e.g. 12 ==> 212 = 4,096 iterations salt:    array of Bytes (16 bytes)           random salt password: array of Bytes (1..72 bytes)       UTF-8 encoded password Output: hash:    array of Bytes (24 bytes) //Initialize Blowfish state with expensive key setup algorithm //P: array of 18 subkeys (UInt32[18]) //S: Four substitution boxes (S-boxes), S0...S3. Each S-box is 1,024 bytes (UInt32[256]) P, S ← EksBlowfishSetup(cost, salt, password) //Repeatedly encrypt the text "OrpheanBeholderScryDoubt" 64 times ctext ← "OrpheanBeholderScryDoubt" //24 bytes ==> three 64-bit blocks repeat (64) ctext ← EncryptECB(P, S, ctext) //encrypt using standard Blowfish in ECB mode //24-byte ctext is resulting password hash return Concatenate(cost, salt, ctext)

महंगा कुंजी सेटअप
बीक्रिप्ट एल्गोरिथम अपने  ईकेएसब्लोफिश  कुंजी सेटअप एल्गोरिथम पर बहुत अधिक निर्भर करता है, जो निम्नानुसार चलता है:

Function EksBlowfishSetup

Input: password: array of Bytes (1..72 bytes)  UTF-8 encoded password

salt:    array of Bytes (16 bytes)      random salt cost:    Number (4..31)                 log2(Iterations). e.g. 12 ==> 212 = 4,096 iterations Output: P:       array of UInt32                array of 18 per-round subkeys S1..S4:  array of UInt32                array of four SBoxes; each SBox is 256 UInt32 (i.e. each SBox is 1 KiB) //Initialize P (Subkeys), and S (Substitution boxes) with the hex digits of pi    P, S ← InitialState //Permute P and S based on the password and salt P, S ← ExpandKey(P, S, salt, password) //This is the "Expensive" part of the "Expensive Key Setup". //Otherwise the key setup is identical to Blowfish. repeat (2cost) P, S ← ExpandKey(P, S, 0, password) P, S ← ExpandKey(P, S, 0, salt) return P, S इनिशियलस्टेट ब्लोफिश एल्गोरिथम की तरह काम करता है, पी-ऐरे और एस-बॉक्स प्रविष्टियों को हेक्साडेसिमल हेक्साडेसिमल $$\pi$$ के आंशिक भाग के साथ पॉप्युलेट करता है।

एक्सपैंड कीय
एक्सपैंडकीय फ़ंक्शन निम्न कार्य करता है:

Function ExpandKey Input: password: array of Bytes (1..72 bytes) UTF-8 encoded password salt:    Byte[16]                      random salt P:       array of UInt32               Array of 18 subkeys

S1..S4:  UInt32[1024]                  Four 1 KB SBoxes Output:

P:       array of UInt32               Array of 18 per-round subkeys S1..S4:  UInt32[1024]                  Four 1 KB SBoxes //Mix password into the P subkeys array for n ← 1 to 18 do Pn ← Pn xor password[32(n-1)..32n-1] //treat the password as cyclic //Treat the 128-bit salt as two 64-bit halves (the Blowfish block size). saltHalf[0] ← salt[0..63] //Lower 64-bits of salt saltHalf[1] ← salt[64..127] //Upper 64-bits of salt //Initialize an 8-byte (64-bit) buffer with all zeros. block ← 0 //Mix internal state into P-boxes for n ← 1 to 9 do //xor 64-bit block with a 64-bit salt half block ← block xor saltHalf[(n-1) mod 2] //each iteration alternating between saltHalf[0], and saltHalf[1] //encrypt block using current key schedule block ← Encrypt(P, S, block) P2n ← block[0..31]     //lower 32-bits of block P2n+1 ← block[32..63] //upper 32-bits block //Mix encrypted state into the internal S-boxes of state for i ← 1 to 4 do for n ← 0 to 127 do block ← Encrypt(state, block xor salt[64(n-1)..64n-1]) //as above Si[2n]  ← block[0..31]  //lower 32-bits Si[2n+1] ← block[32..63] //upper 32-bits return state इस तरह, नियमित ब्लोफिश की अनुसूची के समान है क्योंकि सभी शून्य साल्ट मूल्य वाले सभी एक्सओआर अप्रभावी हैं।   समान है, लेकिन 128-बिट कुंजी के रूप में साल्ट का उपयोग करता है।

उपयोगकर्ता इनपुट
ओपनबीएसडी कार्यान्वयन के बाद, बीक्रिप्ट के कई कार्यान्वयन पासवर्ड को पहले 72 बाइट्स तक काट देते हैं।

गणितीय एल्गोरिथ्म को स्वयं 18 32-बिट उपकुंजियों (72 ऑक्टेट/बाइट्स के बराबर) के साथ आरंभीकरण की आवश्यकता होती है। बीक्रिप्ट का मूल विनिर्देश एल्गोरिदम के लिए उपयोगकर्ता स्थान से संख्यात्मक मानों में टेक्स्ट-आधारित पासवर्ड मैप करने के लिए किसी एक विशेष विधि को अनिवार्य नहीं करता है। पाठ में एक संक्षिप्त टिप्पणी का उल्लेख है, लेकिन यह अनिवार्य नहीं है, केवल एक वर्ण स्ट्रिंग के ASCII एन्कोडेड मान का उपयोग करने की संभावना: अंत में, मुख्य तर्क एक गुप्त एन्क्रिप्शन कुंजी है, जो 56 तक उपयोगकर्ता द्वारा चुना गया पासवर्ड हो सकता है बाइट्स (कुंजी के ASCII स्ट्रिंग होने पर समाप्ति शून्य बाइट सहित)।

ध्यान दें कि उपरोक्त उद्धरण 56 बाइट्स तक के पासवर्ड का उल्लेख करता है, भले ही एल्गोरिथ्म स्वयं 72 बाइट प्रारंभिक मान का उपयोग करता हो। हालांकि प्रोवोस और माजिएरेस छोटे प्रतिबंध का कारण नहीं बताते हैं, वे ब्रूस श्नेयर के ब्लोफिश के मूल विनिर्देश से निम्नलिखित कथन से प्रेरित हो सकते हैं, कुंजी आकार पर 448 [बिट] सीमा यह सुनिश्चित करती है कि [sic] प्रत्येक उपकुंजी का प्रत्येक बिट कुंजी के प्रत्येक बिट पर निर्भर करता है। कार्यान्वयन में पासवर्ड को प्रारंभिक संख्यात्मक मानों में परिवर्तित करने के उनके दृष्टिकोण में भिन्नता है, जिसमें कभी-कभी गैर-ASCII वर्णों वाले पासवर्ड की शक्ति को कम करना भी सम्मिलित है।

अन्य पासवर्ड हैशिंग एल्गोरिदम की तुलना
यह नोट करना महत्वपूर्ण है कि बीक्रिप्ट एक Key_derivation_function|key deriation function (KDF) नहीं है। उदाहरण के लिए, पासवर्ड से 512-बिट कुंजी प्राप्त करने के लिए बीक्रिप्ट का उपयोग नहीं किया जा सकता है। उसी समय, pbkdf2, scrypt, और argon2 जैसे एल्गोरिदम पासवर्ड-आधारित कुंजी व्युत्पत्ति कार्य हैं - जहाँ आउटपुट का उपयोग केवल कुंजी व्युत्पत्ति के बजाय पासवर्ड हैशिंग के उद्देश्य से किया जाता है।

पासवर्ड हैशिंग को आम तौर पर <1000 एमएस पूरा करने की आवश्यकता होती है। इस परिदृश्य में, बीक्रिप्ट pbkdf2, scrypt, और argon2 से ज्यादा मजबूत है।


 * 'पीबीकेडीएफ2': पीबीकेडीएफ2 बीक्रिप्ट से कमजोर है। प्रायः इस्तेमाल किया जाने वाला SHA2 हैशिंग एल्गोरिथम मेमोरी-हार्ड नहीं है। SHA2 को अत्यधिक हल्के होने के लिए डिज़ाइन किया गया है ताकि यह हल्के उपकरणों (जैसे स्मार्ट कार्ड) पर चल सके। इसका मतलब है कि PBKDF2 पासवर्ड स्टोरेज के लिए बहुत कमजोर है, क्योंकि कमोडिटी SHA-2 हैशिंग हार्डवेयर जो प्रति सेकंड खरबों हैश का प्रदर्शन कर सकता है, आसानी से खरीदा जाता है
 * स्क्रीप्ट: 4 एमबी से कम मेमोरी आवश्यकताओं के लिए स्क्रीप्ट बीक्रिप्ट से कमजोर है। जीपीयू आधारित हमलों (पासवर्ड भंडारण के लिए) के खिलाफ रक्षा के तुलनीय स्तर को प्राप्त करने के लिए स्क्रिप को लगभग 1000 गुना मेमोरी की आवश्यकता होती है।
 * आर्गन2: आर्गन2 1 सेकेंड से कम रन टाइम (यानी पासवर्ड ऑथेंटिकेशन के लिए) के लिए बीक्रिप्ट से कमजोर है। Argon2 > = ~ 1000ms रनटाइम (जो पासवर्ड हैशिंग के लिए अनुपयुक्त है, लेकिन कुंजी-व्युत्पत्ति के लिए पूरी तरह से स्वीकार्य है) तक बीक्रिप्ट की ताकत से मेल नहीं खाता या पार नहीं करता है।
 * पफरफिश2 बीक्रिप्ट का विकास है जो ट्यून करने योग्य मेमोरी फुटप्रिंट (जैसे स्क्रीप्ट और आर्गन2) का उपयोग करता है, न कि बीक्रिप्ट के फिक्स्ड 4 केबी मेमोरी फुटप्रिंट का। स्क्रीप्ट या आर्गन2 के समान, पफरफिश2 अधिक मेमोरी का उपयोग करके अपनी कठिनाई प्राप्त करता है। स्क्रीप्ट और आर्गन2 के विपरीत, पफरफिश2 केवल सीपीयू कोर के एल2 कैश में काम करता है। जबकि स्क्रीप्ट और आर्गन 2 अपनी मेमोरी कठोरता को बेतरतीब ढंग से बहुत सी रैम तक पहुंच कर प्राप्त करते हैं, पफरफिश 2 खुद को सीपीयू कोर के लिए उपलब्ध समर्पित एल 2 कैश तक ही सीमित करता है। यह स्क्रीप्ट और आर्गन2 की तुलना में कस्टम हार्डवेयर में लागू करना और भी कठिन बना देता है। पफरफिश 2 का आदर्श स्मृति पदचिह्न कोर के लिए उपलब्ध कैश का आकार है (उदाहरण के लिए इंटेल एल्डर लेक के लिए 1.25 एमबी ) यह पफरफिश2 को जीपीयू या एएसआईसी के प्रति अधिक प्रतिरोधी बनाता है।

अधिकतम पासवर्ड लंबाई
बीक्रिप्ट की अधिकतम पासवर्ड लंबाई 72 बाइट्स है। यह अधिकतम ExpandKey फ़ंक्शन के पहले ऑपरेशन से आता है  पासवर्ड के साथ 18 4-बाइट उपकुंजी (पी):

पी1..पी18 ← पी1..पी18 xor पासवर्डबाइट्स

पासवर्ड (जो UTF-8 एन्कोडेड है), 72-बाइट लंबा होने तक दोहराया जाता है। उदाहरण के लिए, का एक पासवर्ड:


 * (29 बाइट्स)

तब तक दोहराया जाता है जब तक यह 18 पी प्रति-राउंड उपकुंजियों के 72-बाइट से मेल नहीं खाता:


 * (72 बाइट्स)

सबसे खराब स्थिति में एक पासवर्ड 18 वर्णों तक सीमित होता है, जब प्रत्येक वर्ण को UTF-8 एन्कोडिंग के 4 बाइट्स की आवश्यकता होती है। उदाहरण के लिए:


 * (18 अक्षर, 72 बाइट्स)

पासवर्ड हैश ट्रंकेशन
बीक्रिप्ट एल्गोरिथम में 24-बाइट टेक्स्ट को बार-बार एन्क्रिप्ट करना सम्मिलित है:


 * (24-बाइट्स)

यह सिफरटेक्स्ट के 24 बाइट्स उत्पन्न करता है, जैसे:


 * (24-बाइट्स)

विहित ओपनबीएसडी कार्यान्वयन इसे 23 बाइट्स तक काट देता है:


 * (23-बाइट्स)

यह स्पष्ट नहीं है कि विहित कार्यान्वयन परिणामी पासवर्ड हैश से 8-बिट क्यों हटाता है।

रेडिक्स -64 एन्कोडेड होने पर ये 23 बाइट 31 वर्ण बन जाते हैं:


 * (31-अक्षर)

बेस 64 एन्कोडिंग वर्णमाला
कैनोनिकल ओपनबीएसडी कार्यान्वयन द्वारा उपयोग की जाने वाली एन्कोडिंग क्रिप्ट (सी) के समान बेस 64 वर्णमाला का उपयोग करती है, जो है. इसका अर्थ है कि एन्कोडिंग अधिक सामान्य बेस64#कार्यान्वयन और इतिहास के साथ संगत नहीं है।

यह भी देखें

 * Argon2 - 2015 में पासवर्ड हैशिंग प्रतियोगिता का विजेता
 * क्रिप्ट (सी) # ब्लोफिश-आधारित योजना - 2002 में विकसित ब्लोफिश-आधारित क्रॉस-प्लेटफ़ॉर्म फ़ाइल एन्क्रिप्शन उपयोगिता
 * ccrypt (सी) - यूनिक्स सी लाइब्रेरी फ़ंक्शन
 * क्रिप्ट (यूनिक्स) - यूनिक्स उपयोगिता
 * सीक्रिप्ट - उपयोगिता
 * चाबी खींचना
 * mcrypt - उपयोगिता
 * PBKDF2 - एक व्यापक रूप से इस्तेमाल किया जाने वाला मानक पासवर्ड-आधारित कुंजी व्युत्पत्ति फ़ंक्शन 2
 * स्क्रीप्ट - पासवर्ड-आधारित कुंजी व्युत्पत्ति फ़ंक्शन (और एक उपयोगिता भी)

बाहरी संबंध

 * crypt_blowfish, the implementation maintained by Openwall