🤞🏻 🥅 🧒🏿 एक बार का पासवर्ड कैसे काम करता है 🌘 🧓🏻 🎗️

प्रविष्टि

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

इस संक्षिप्त लेख को पढ़ने के बाद, आप समझेंगे कि हैश के आधार पर एकमुश्त पासवर्ड कैसे काम करता है , और एक ही समय में पायथन में एक छोटा प्रोग्राम लिखें जो Google के दो-चरणीय प्रमाणीकरण के लिए पासवर्ड की गणना कर सकता है।

हैश फंक्शन

हैश फ़ंक्शन आपको किसी भी लंबाई का कोई भी डेटा लेने और उन पर एक छोटा "डिजिटल फिंगरप्रिंट" बनाने की अनुमति देता है। हैश फ़ंक्शन मान की लंबाई स्रोत पाठ की लंबाई पर निर्भर नहीं करती है; उदाहरण के लिए, लोकप्रिय SHA-1 एल्गोरिथ्म के मामले में, इस फिंगरप्रिंट की लंबाई 160 बिट्स है।

यह समझने के लिए कि एक मान हमेशा एक ही लंबाई क्यों होता है और स्रोत पाठ पर निर्भर नहीं करता है, आप पहियों के साथ कोड लॉक के रूप में हैश फ़ंक्शन को सरल कर सकते हैं। पहले हम सभी पहियों को "शून्य" पर सेट करते हैं, फिर पाठ के माध्यम से जाते हैं और कुछ नियमों के अनुसार प्रत्येक अक्षर के लिए पहियों को स्क्रॉल करते हैं। अंत में लॉक होने वाली संख्या हैश फ़ंक्शन का मान है। ऐसे कार्यों के उदाहरण MD5, SHA-1, GOST_P_34.11-94 हैं।

अपने स्वयं के हैश कार्यों का आविष्कार न करें, मानक कार्यान्वयन का उपयोग करें (उदाहरण के लिए, पायथन के मामले में):

import hashlib print hashlib.sha1("Hello, Bob!").hexdigest()

: 88192e3e2e83243887410897efd90287b8e453a7

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

 import hashlib print hashlib.sha1("Hello, Bob?").hexdigest()

: cbad4b0e05703acf2e8572be7438830fe7f8ddf5

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

हालांकि, हम मैलोरी के बारे में भूल गए, जो एलिस और बॉब के बीच कहीं है, उनके पत्राचार को स्वीकार करता है और लिफाफे खोलता है! वह संदेश को अच्छी तरह से बदल सकता है, और फिर उसके लिए SHA-1 की गणना कर सकता है और पत्र को संलग्न कर सकता है; बॉब मूल्यों की तुलना करेगा और कुछ भी नोटिस नहीं करेगा।

प्रमाणीकरण

सोचने के बाद, ऐलिस और बॉब बैठक में सहमत होते हैं कि SHA-1 की गणना करते समय, वे अस्थायी रूप से एक गुप्त शब्द जोड़ेंगे, उदाहरण के लिए, पाठ के लिए "गुप्त" (निश्चित रूप से, वास्तव में ऐलिस और बॉब ने बहुत लंबे शब्द का उपयोग करने का फैसला किया ताकि इसे ढूंढना मुश्किल हो) । मेलोरी इस शब्द को नहीं जानता है, और इसलिए, भले ही वह संदेश बदल दे, वह अपने हैश को समायोजित करने में सक्षम नहीं होगा, है ना?

एक उदाहरण:

 import hashlib print hashlib.sha1("Secret" + "Hello, Bob").hexdigest()

: 99beeff3ef1971d2cb1be129f986739f6bcba8cc

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

इससे बचाव के लिए, हम अपने कार्य को थोड़ा जटिल करेंगे:

 print hashlib.sha1("Secret" + hashlib.sha1("Hello, Bob").hexdigest()).hexdigest()

: 3f51e9fc540676bc3ce54367fd3e467f3299c743

अब संदेश के अंत में कुछ जोड़ने से SHA-1 में "बाहरी" कॉल के लिए स्रोत डेटा पूरी तरह से बदल जाएगा और मेलरी खेल से बाहर रहेगी।

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

अपने स्वयं के HMAC कार्यान्वयन का आविष्कार न करें, उदाहरण के लिए, मानक कार्यान्वयन का उपयोग करें, HMAC-SHA1

 import hmac import hashlib print hmac.new(key="Secret", msg="Hello, Bob", digestmod=hashlib.sha1).hexdigest()

एक बार का पासवर्ड

वन-टाइम पासवर्ड क्या है? यह एक पासवर्ड है कि एक कीलॉगर का उपयोग करना, आपके कंधे पर झांकना या टेलीफोन लाइन को सुनना व्यर्थ है - यह पासवर्ड बिल्कुल एक बार उपयोग किया जाता है।

इस योजना को कैसे लागू किया जा सकता है? उदाहरण के लिए, ऐलिस एक सौ यादृच्छिक पासवर्ड उत्पन्न कर सकता है और बॉब को एक प्रति दे सकता है। जब बॉब अगली बार कॉल करेगा, तो वह सूची में सबसे अधिक पासवर्ड को निर्देशित करेगा, ऐलिस उसके साथ इसे सत्यापित करेगा, जिसके बाद दोनों इसे हटा देंगे। अगली कॉल पर, वे अगले पासवर्ड का उपयोग करते हैं और इसी तरह जब तक वे बाहर नहीं निकलते। यह बहुत सुविधाजनक नहीं है: सूची संग्रहीत करना, नए पासवर्ड बनाना, और इसी तरह।

इस योजना को एल्गोरिथम के रूप में लागू करना बेहतर है। उदाहरण के लिए, एक पासवर्ड क्रम में अपनी संख्या है, एक गुप्त संख्या से गुणा किया जाता है। बता दें कि ऐलिस और बॉब सहमत हैं कि गुप्त संख्या 42 है; फिर पहला पासवर्ड 42, दूसरा 84, तीसरा 126 और इसी तरह का होगा। एल्गोरिथ्म और गुप्त संख्या को नहीं जानने वाला मेलोरी, कभी भी यह अनुमान नहीं लगाएगा कि अगला पासवर्ड कौन सा होगा!

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

 import hmac import hashlib print hmac.new(key="Secret", msg="20", digestmod=hashlib.sha1).hexdigest()

: 393e9efaae1a687bc2dcc257c8e9e2a61f26fe4b

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

कुछ समय के लिए सब कुछ ठीक चल रहा है। जब तक बॉब और ऐलिस गिनती के थक नहीं जाते, तब तक वे किस तरह के पासवर्ड का इस्तेमाल करते हैं। कोई उन्हें बताता है कि संख्या के बजाय एचएमएसी () के तर्क के रूप में, आप उन सभी चीजों का उपयोग कर सकते हैं, जो ऐलिस और बॉब के पास एक साथ पहुंच है ... उदाहरण के लिए, वर्तमान समय!

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

अब पासवर्ड की गणना निम्न सूत्र का उपयोग करके की जाती है: HMAC ("गुप्त", unix_timestamp / 30) ।

हमें वर्तमान समय के आधार पर वन-टाइम पासवर्ड प्राप्त हुआ। केवल जिनके पास कुंजी है वे इन पासवर्ड को उत्पन्न कर सकते हैं और सत्यापित कर सकते हैं (ऊपर के उदाहरण में "गुप्त"); दूसरे शब्दों में, सर्वर और उपयोगकर्ता।

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

OATH, TOTP, HOTP, RFC ... WTF?

इसलिए, हमने केवल मूल विचारों का वर्णन किया है:

1) HMAC, हैश-आधारित संदेश प्रमाणीकरण कोड: RFC2104
2) HOTP, हैश-आधारित वन-टाइम पासवर्ड: RFC4226
3) टीओटीपी, टाइम-बेस्ड वन-टाइम पासवर्ड: RFC6238

ये विचार इनिशिएटिव फॉर ओपन ऑथेंटिकेशन (OATH) पहल के एक कोने में से एक हैं, जिसका उद्देश्य प्रमाणीकरण विधियों को मानक बनाना है।

Google 2-चरणीय सत्यापन

Google प्रमाणक अनुप्रयोग में Google द्वारा समय-समय पर आधारित पासवर्ड (TOTP RFC 6238 एल्गोरिथम पर आधारित गणना) का उपयोग किया जाता है, जिसे iOS, Android, BlackBerry पर स्थापित किया जा सकता है। यह एप्लिकेशन स्वचालित रूप से हर 30 सेकंड में (Google खाते पर मुख्य पासवर्ड के अलावा) एक बार पासवर्ड उत्पन्न करता है। इसका मतलब यह है कि अगर कोई आपके प्राथमिक पासवर्ड को स्नूप या इंटरसेप्ट करता है, तो भी अगले वन-टाइम पासवर्ड के बिना सिस्टम में प्रवेश करना असंभव होगा। सुविधाजनक।

ध्यान दें : मैं GOOGLE के दो-चरण स्वचालन को चालू करने और बंद करने के साथ अपने कार्यों के लिए कोई जवाबदेही नहीं है; आप अपने खुद के जोखिम पर पूरी तरह से उन्हें स्वीकार करते हैं ।

वास्तव में, चिंता करने की कोई बात नहीं है (निर्देश हैं, विश्वसनीय कंप्यूटर हैं, बैकअप कोड हैं, आदि), लेकिन अगर आप बिना सोचे समझे बटन पर क्लिक करके कड़ी मेहनत करते हैं, तो आप पूरी तरह से अपने खाते तक पहुंच खो सकते हैं। और फिर भी: यदि आप प्रयोग करने के लिए तैयार नहीं हैं, तो Gmail को स्पर्श न करें; बस अपने फोन पर Google प्रमाणक ऐप डाउनलोड करें, मैन्युअल रूप से "समय के अनुसार कुंजी" जोड़ें (उदाहरण के लिए, "एबीसी डीईसी एबीसी डीईसी एबीसी" या बस नीचे दिए गए क्यूआर कोड को स्कैन करें)।

सबसे पहले, हमें गुप्त कुंजी प्राप्त करने की आवश्यकता है, जिसका उपयोग वन-टाइम पासवर्ड बनाने के लिए किया जाता है। आप इसे खाता सेटिंग में Google प्रमाणक जोड़ने के लिए पृष्ठ पर देख सकते हैं, यह QR कोड के अंतर्गत स्थित है:

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

Base32 में कुंजी को इनकोड किया गया है (सुविधा के लिए, रिक्त स्थान हटा दें और ऊपरी मामले में अक्षरों का अनुवाद करें)।

एक प्रोग्राम जो वर्तमान वन-टाइम पासवर्ड की गणना करता है:

 import time import hmac import hashlib import base64 ### TOTP-key (get it from Google) secret = base64.b32decode("AABCDEFABCDEFABC") ### Calc counter from UNIX time (see RFC6238) counter = long(time.time() / 30) ### Use counter as 8 byte array bytes=bytearray() for i in reversed(range(0, 8)): bytes.insert(0, counter & 0xff) counter >>= 8 ### Calculate HMAC-SHA1(secret, counter) hs = bytearray(hmac.new(secret, bytes, hashlib.sha1).digest()) ### Truncate result (see RFC4226) n = hs[-1] & 0xF result = (hs[n] << 24 | hs[n+1] << 16 | hs[n+2] << 8 | hs[n+3]) & 0x7fffffff ### Print last 6 digits print str(result)[-6:]

अब आप आगे चल रहे Google प्रमाणक को रख सकते हैं और मूल्यों की तुलना कर सकते हैं।

अपडेट: जावास्क्रिप्ट कार्यान्वयन उदाहरण (धन्यवाद roman_pro )

अपडेट # 2: यदि आप ड्रॉपबॉक्स से 2-चरणीय सत्यापन के साथ खेलना चाहते हैं, तो गुप्त के अंत में "======" जोड़ें (यह सही तरीके से काम करने के लिए पैडिंग और बेस 32 डिकोडर के लिए आवश्यक है)।

निष्कर्ष

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

एक बार का पासवर्ड कैसे काम करता है