हम निजी ssh कुंजियों की सुरक्षा बढ़ाते हैं

क्या तुमने कभी कैसे ssh चाबियाँ काम में रुचि रखते हैं? या वे कितने सुरक्षित हैं?

मैं हर दिन कई बार ssh का उपयोग करता हूं - जब मैं git fetch या git push रन करता हूं, जब मैं कोड को तैनात करता हूं या सर्वर पर लॉग करता हूं। बहुत पहले नहीं, मुझे एहसास हुआ कि मेरे लिए ssh एक जादू बन गया है जिसका उपयोग मैं इसके काम के सिद्धांतों को समझे बिना करता था। मुझे यह बहुत पसंद नहीं था - मैं उन उपकरणों को समझना पसंद करता हूं जो मैं उपयोग करता हूं। इसलिए मैंने थोड़ा शोध किया और आपके साथ परिणाम साझा किया।

प्रस्तुति के दौरान, कई संक्षिप्त रूप होंगे। वे विचारों को समझने में मदद नहीं करेंगे, लेकिन यदि आप विवरणों को गूगल करने का निर्णय लेते हैं तो यह उपयोगी होगा।

इसलिए, यदि आपको कुंजी द्वारा प्रमाणीकरण का सहारा लेना पड़ता है, तो आपके पास अपने घर की निर्देशिका में एक फ़ाइल ~/.ssh/id_rsa ~/.ssh/id_dsa या या ~/.ssh/id_dsa है। यह एक निजी (उर्फ निजी) RSA / DSA कुंजी है, और ~/.ssh/id_rsa.pub या ~/.ssh/id_dsa.pub एक सार्वजनिक (उर्फ सार्वजनिक) कुंजी है। जिस सर्वर पर आप लॉग इन करना चाहते हैं, उसके पास ~/.ssh/authorized_keys में सार्वजनिक कुंजी की एक प्रति होनी चाहिए। जब आप लॉग इन करने का प्रयास करते हैं, तो ssh क्लाइंट पुष्टि करता है कि आपके पास डिजिटल हस्ताक्षर का उपयोग करके एक निजी कुंजी है; सर्वर यह जाँचता है कि हस्ताक्षर वैध है और ~/.ssh/authorized_keys में एक सार्वजनिक कुंजी है और आपको पहुँच प्राप्त है।

निजी कुंजी के अंदर क्या संग्रहीत किया जाता है?

अनएन्क्रिप्टेड प्राइवेट की फॉर्मेट

यह एक पासवर्ड (पासफ़्रेज़) के साथ निजी कुंजी की रक्षा करने के लिए अनुशंसित है, अन्यथा एक हमलावर जो आपकी निजी कुंजी को आपसे चोरी करने में कामयाब रहा, वह आपके सर्वर में समस्याओं के बिना लॉग इन कर सकेगा। पहले, अनएन्क्रिप्टेड फ़ाइल प्रारूप पर एक नज़र डालते हैं, लेकिन हम बाद में एन्क्रिप्ट किए गए से निपटेंगे।

एक अनएन्क्रिप्टेड कुंजी कुछ इस तरह दिखती है:

 -----BEGIN RSA PRIVATE KEY----- MIIEogIBAAKCAQEArCQG213utzqE5YVjTVF5exGRCkE9OuM7LCp/FOuPdoHrFUXk y2MQcwf29J3A4i8zxpES9RdSEU6iIEsow98wIi0x1/Lnfx6jG5Y0/iQsG1NRlNCC aydGvGaC+PwwWiwYRc7PtBgV4KOAVXMZdMB5nFRaekQ1ksdH/360KCGgljPtzTNl 09e97QBwHFIZ3ea5Eih/HireTrRSnvF+ywmwuxX4ubDr0ZeSceuF2S5WLXH2+TV0 ...    ... -----END RSA PRIVATE KEY----- 

निजी कुंजी में ASN.1 प्रारूप में डेटा होता है, जिसे X.690 मानक के अनुसार बाइट्स के अनुक्रम के रूप में प्रस्तुत किया जाता है और Base64 में इनकोड किया गया है। मोटे तौर पर, ASN.1 की तुलना JSON से की जा सकती है (यह विभिन्न डेटा प्रकारों का समर्थन करता है, जैसे कि INTEGER, BOOLEAN, तार और अनुक्रम जो एक पेड़ की संरचना बना सकते हैं)। ASN.1 व्यापक रूप से क्रिप्टोग्राफी में उपयोग किया जाता है, हालांकि यह वेब के आगमन के साथ फैशन से थोड़ा बाहर हो गया है (मुझे पता नहीं क्यों - यह एक सुंदर सभ्य प्रारूप की तरह दिखता है ( आप इसके साथ बहस कर सकते हैं - लगभग ट्रांस। )

हम ssh-keygen का उपयोग करके पासवर्ड के बिना एक परीक्षण RSA कुंजी उत्पन्न करेंगे और इसे asn1parse (या जावास्क्रिप्ट में लिखे ASN.1 डिकोडर का उपयोग करके) को डीकोड करेंगे:

 $ ssh-keygen -t rsa -N '' -f test_rsa_key $ openssl asn1parse -in test_rsa_key 0:d=0 hl=4 l=1189 cons: SEQUENCE 4:d=1 hl=2 l= 1 prim: INTEGER :00 7:d=1 hl=4 l= 257 prim: INTEGER :C36EB2429D429C7768AD9D879F98C... 268:d=1 hl=2 l= 3 prim: INTEGER :010001 273:d=1 hl=4 l= 257 prim: INTEGER :A27759F60AEA1F4D1D56878901E27... 534:d=1 hl=3 l= 129 prim: INTEGER :F9D23EF31A387694F03AD0D050265... 666:d=1 hl=3 l= 129 prim: INTEGER :C84415C26A468934F1037F99B6D14... 798:d=1 hl=3 l= 129 prim: INTEGER :D0ACED4635B5CA5FB896F88BB9177... 930:d=1 hl=3 l= 128 prim: INTEGER :511810DF9AFD590E11126397310A6... 1061:d=1 hl=3 l= 129 prim: INTEGER :E3A296AE14E7CAF32F7E493FDF474... 

ASN.1 में डेटा संरचना काफी सरल है: यह नौ पूर्णांक का एक क्रम है। उनका उद्देश्य RFC2313 में परिभाषित किया गया है । पहली और तीसरी संख्या संस्करण संख्या (0) और खुले प्रतिपादक ई हैं । दूसरी और चौथी संख्या (2048 बिट लंबी) मॉड्यूल एन और गुप्त प्रतिपादक हैं। ये संख्या RSA प्रमुख पैरामीटर हैं। शेष पाँचों को n और d को जानकर प्राप्त किया जा सकता है - उन्हें कुछ कार्यों को गति देने के लिए फ़ाइल में कैश किया जाता है।

डीएसए कुंजी की संरचना समान है और इसमें छह नंबर शामिल हैं:

 $ ssh-keygen -t dsa -N '' -f test_dsa_key $ openssl asn1parse -in test_dsa_key 0:d=0 hl=4 l= 444 cons: SEQUENCE 4:d=1 hl=2 l= 1 prim: INTEGER :00 7:d=1 hl=3 l= 129 prim: INTEGER :E497DFBFB5610906D18BCFB4C3CCD... 139:d=1 hl=2 l= 21 prim: INTEGER :CF2478A96A941FB440C38A86F22CF... 162:d=1 hl=3 l= 129 prim: INTEGER :83218C0CA49BA8F11BE40EE1A7C72... 294:d=1 hl=3 l= 128 prim: INTEGER :16953EA4012988E914B466B9C37CB... 425:d=1 hl=2 l= 21 prim: INTEGER :89A356E922688EDEB1D388258C825... 

पासवर्ड संरक्षित निजी कुंजी प्रारूप

अब हम एक संभावित हमलावर के जीवन को जटिल बनाते हैं जो निजी कुंजी चोरी करने में सक्षम था - हम इसे एक पासवर्ड के साथ संरक्षित करेंगे। फाइल का क्या हुआ?

 $ ssh-keygen -t rsa -N 'super secret passphrase' -f test_rsa_key $ cat test_rsa_key -----BEGIN RSA PRIVATE KEY----- Proc-Type: 4,ENCRYPTED DEK-Info: AES-128-CBC,D54228DB5838E32589695E83A22595C7 3+Mz0A4wqbMuyzrvBIHx1HNc2ZUZU2cPPRagDc3M+rv+XnGJ6PpThbOeMawz4Cbu lQX/Ahbx+UadJZOFrTx8aEWyZoI0ltBh9O5+ODov+vc25Hia3jtayE51McVWwSXg wYeg2L6U7iZBk78yg+sIKFVijxiWnpA7W2dj2B9QV0X3ILQPxbU/cRAVTd7AVrKT ...    ... -----END RSA PRIVATE KEY----- 

ध्यान दें कि दो हेडर लाइनें जोड़ी गई हैं, और बेस 64 स्ट्रिंग को डीकोड करने का परिणाम अब मान्य ASN.1 नहीं है। तथ्य यह है कि ASN.1 की संरचना। एन्क्रिप्टेड। हेडर से हमें पता चलता है कि एन्क्रिप्शन के लिए किस एल्गोरिदम का उपयोग किया गया था: CES मोड में AES-128 । DEK-Info हेडर में 128-बिट हेक्साडेसिमल स्ट्रिंग इनिशियलाइज़ेशन वेक्टर (IV) है। यहां कुछ भी असामान्य नहीं है, सभी सामान्य क्रिप्टोग्राफिक लाइब्रेरी यहां उपयोग किए गए एल्गोरिदम के साथ काम कर सकते हैं।

लेकिन AES कुंजी पासवर्ड से कैसे प्राप्त की जाती है? मुझे यह प्रलेखन में नहीं मिला और इसलिए मुझे ओपनएसएसएल स्रोत कोड को समझने के लिए मजबूर किया गया। यहाँ मुझे एन्क्रिप्शन कुंजी प्राप्त करने के बारे में पता चला है:

1. प्रारंभिक वेक्टर के 8 बाइट्स को पासवर्ड से जोड़ा जाता है (वास्तव में, वे नमक हैं)।
2. एक बार प्राप्त स्ट्रिंग से एक MD5 हैश लिया जाता है।

सत्यापित करने के लिए, हम DEK-Info हेडर से इनिशियलाइज़ेशन वेक्टर लेकर निजी कुंजी को डिक्रिप्ट करते हैं:

 $ tail -n +4 test_rsa_key | grep -v 'END ' | base64 -d | openssl aes-128-cbc -d -iv D54228DB5838E32589695E83A22595C7 -K $( ruby -rdigest/md5 -e 'puts Digest::MD5.hexdigest(["super secret passphrase",0xD5,0x42,0x28,0xDB,0x58,0x38,0xE3,0x25].pack("a*cccccccc"))' ) | openssl asn1parse -inform DER 

यह कमांड RSA प्रमुख मापदंडों को आउटपुट करेगा। यदि आप केवल कुंजी देखना चाहते हैं, तो एक सरल तरीका है:

 $ openssl rsa -text -in test_rsa_key -passin 'pass:super secret passphrase' 

लेकिन मैं यह दिखाना चाहता था कि दो कमजोरियों पर ध्यान देने के लिए पासवर्ड से एईएस कुंजी कैसे प्राप्त की जाती है:

1. MD5 का उपयोग कोड में पंजीकृत है, जिसका अर्थ है कि प्रारूप को बदले बिना किसी अन्य हैश फ़ंक्शन (उदाहरण के लिए, SHA-1) पर स्विच करना असंभव है। अगर यह पता चला कि एमडी 5 पर्याप्त सुरक्षित नहीं है, तो समस्याएं होंगी। ( वास्तव में नहीं, टिप्पणियों को देखें - लगभग। )
2. हैश फ़ंक्शन केवल एक बार लागू किया जाता है। चूंकि एमडी 5 और एईएस की गणना जल्दी होती है, इसलिए शॉर्ट पासवर्ड का अनुमान लगाना आसान है।

यदि ssh कुंजी खराब हाथों में आती है, उदाहरण के लिए, कोई आपके लैपटॉप या हार्ड ड्राइव को बैकअप के साथ चुराता है, तो एक हमलावर बड़ी संख्या में पासवर्ड की कोशिश कर सकता है, यहां तक ​​कि थोड़ी कंप्यूटिंग शक्ति के साथ भी। यदि आप एक शब्दकोश पासवर्ड सेट करते हैं, तो आप इसे सेकंड में चुन सकते हैं।

यह बुरी खबर है: एक कुंजी का पासवर्ड सुरक्षा उतना अच्छा नहीं है जितना कि कोई अनुमान लगा सकता है। लेकिन अच्छी खबर है: आप एक अधिक सुरक्षित निजी कुंजी प्रारूप में स्विच कर सकते हैं।

PKCS # 8 का उपयोग करके महत्वपूर्ण सुरक्षा बढ़ाना

तो, हमें एक पासवर्ड से एक सममित एन्क्रिप्शन कुंजी प्राप्त करने के लिए एक एल्गोरिथ्म की आवश्यकता है, जो धीरे-धीरे काम करेगी, ताकि एक हमलावर को पासवर्ड का अनुमान लगाने के लिए अधिक कम्प्यूटेशनल समय की आवश्यकता हो।

Ssh कुंजियों के अजीब नामों के साथ कई मानक हैं:

• PKCS # 5 (RFC 2898) PBKDF2 (पासवर्ड-आधारित कुंजी व्युत्पत्ति फ़ंक्शन 2) एल्गोरिथ्म को बार-बार हैश फ़ंक्शन लागू करके पासवर्ड से एन्क्रिप्शन कुंजी प्राप्त करने के लिए परिभाषित करता है। यह PBES2 (पासवर्ड-आधारित एन्क्रिप्शन स्कीम 2) एन्क्रिप्शन स्कीम को भी परिभाषित करता है, जिसमें PBKDF2 द्वारा उत्पन्न कुंजी का उपयोग और एक सममित सिफर शामिल है।
• PKCS # 8 (RFC 5208) PBKDF2 समर्थन के साथ एन्क्रिप्टेड निजी कुंजी के लिए भंडारण प्रारूप को परिभाषित करता है। OpenSSL PKCS # 8 प्रारूप में निजी कुंजी का समर्थन करता है, और OpenSSH OpenSSL का उपयोग करता है, इसलिए यदि आप OpenSSH का उपयोग करते हैं, तो आप पारंपरिक ssh कुंजी फ़ाइल स्वरूप से PKCS # 8 प्रारूप में स्विच कर सकते हैं।

मुझे नहीं पता कि ssh-keygen अभी भी पारंपरिक प्रारूप में चाबियाँ क्यों उत्पन्न करता है, इस तथ्य के बावजूद कि कई सालों से बेहतर विकल्प हैं। यह सर्वर सॉफ़्टवेयर के साथ संगतता के बारे में नहीं है: निजी कुंजी आपके कंप्यूटर को कभी नहीं छोड़ती है। सौभाग्य से, मौजूदा कुंजियाँ PKCS # 8 में बदलना काफी आसान है:

 $ mv test_rsa_key test_rsa_key.old $ openssl pkcs8 -topk8 -v2 des3 \ -in test_rsa_key.old -passin 'pass:super secret passphrase' \ -out test_rsa_key -passout 'pass:super secret passphrase' 

यदि आप PKCS # 8 प्रारूप में नई कुंजी फ़ाइल का उपयोग करने का प्रयास करते हैं, तो आप पा सकते हैं कि सब कुछ पहले जैसा ही है। आइए देखें कि अब फ़ाइल के अंदर क्या है।

 $ cat test_rsa_key -----BEGIN ENCRYPTED PRIVATE KEY----- MIIFDjBABgkqhkiG9w0BBQ0wMzAbBgkqhkiG9w0BBQwwDgQIOu/S2/v547MCAggA MBQGCCqGSIb3DQMHBAh4q+o4ELaHnwSCBMjA+ho9K816gN1h9MAof4stq0akPoO0 CNvXdtqLudIxBq0dNxX0AxvEW6exWxz45bUdLOjQ5miO6Bko0lFoNUrOeOo/Gq4H dMyI7Ot1vL9UvZRqLNj51cj/7B/bmfa4msfJXeuFs8jMtDz9J19k6uuCLUGlJscP ... - ... -----END ENCRYPTED PRIVATE KEY----- 

ध्यान दें कि पहली और आखिरी पंक्तियाँ बदल गई हैं ( BEGIN ENCRYPTED PRIVATE KEY जगह BEGIN RSA PRIVATE KEY ), और Proc-Type और DEK-Info हेडर गायब हो गए हैं। वास्तव में, फ़ाइल समान ASN.1 प्रारूप में डेटा संग्रहीत करती है:

 $ openssl asn1parse -in test_rsa_key 0:d=0 hl=4 l=1294 cons: SEQUENCE 4:d=1 hl=2 l= 64 cons: SEQUENCE 6:d=2 hl=2 l= 9 prim: OBJECT :PBES2 17:d=2 hl=2 l= 51 cons: SEQUENCE 19:d=3 hl=2 l= 27 cons: SEQUENCE 21:d=4 hl=2 l= 9 prim: OBJECT :PBKDF2 32:d=4 hl=2 l= 14 cons: SEQUENCE 34:d=5 hl=2 l= 8 prim: OCTET STRING [HEX DUMP]:3AEFD2DBFBF9E3B3 44:d=5 hl=2 l= 2 prim: INTEGER :0800 48:d=3 hl=2 l= 20 cons: SEQUENCE 50:d=4 hl=2 l= 8 prim: OBJECT :des-ede3-cbc 60:d=4 hl=2 l= 8 prim: OCTET STRING [HEX DUMP]:78ABEA3810B6879F 70:d=1 hl=4 l=1224 prim: OCTET STRING [HEX DUMP]:C0FA1A3D2BCD7A80DD61F4C0287F8B2D... 

हम ASN.1 की संरचना की जांच करने के लिए एक जावास्क्रिप्ट डिकोडर का उपयोग करेंगे:

 Sequence (2 elements) |- Sequence (2 elements) | |- Object identifier: 1.2.840.113549.1.5.13 // using PBES2 from PKCS#5 | `- Sequence (2 elements) | |- Sequence (2 elements) | | |- Object identifier: 1.2.840.113549.1.5.12 // using PBKDF2 — yay! :) | | `- Sequence (2 elements) | | |- Byte string (8 bytes): 3AEFD2DBFBF9E3B3 // salt | | `- Integer: 2048 // iteration count | `- Sequence (2 elements) | Object identifier: 1.2.840.113549.3.7 // encrypted with Triple DES, CBC | Byte string (8 bytes): 78ABEA3810B6879F // initialization vector `- Byte string (1224 bytes): C0FA1A3D2BCD7A80DD61F4C0287F8B2DAB46A43E... // encrypted key blob 

यह OID (ऑब्जेक्ट आइडेंटिफ़ायर) को संदर्भित करता है - विश्व स्तर पर अद्वितीय डिजिटल पहचानकर्ता। उनसे हम सीखते हैं कि एन्क्रिप्शन स्कीम pkcs5PBES2 , कुंजी पुनर्प्राप्ति फ़ंक्शन PBKDF2 और एन्क्रिप्शन एल्गोरिथ्म des-ede3-cbc का उपयोग किया जाता है । हैश फ़ंक्शन स्पष्ट रूप से निर्दिष्ट नहीं है, जिसका अर्थ है कि hMAC-SHA1 डिफ़ॉल्ट रूप से उपयोग किया जाता है ।

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

हम यह भी देखते हैं कि एन्क्रिप्शन कुंजी प्राप्त करने की प्रक्रिया में, 2048 पुनरावृत्तियों का प्रदर्शन किया जाता है। यह पारंपरिक ssh- कुंजी प्रारूप का उपयोग करते समय हैश फ़ंक्शन के एक बार के उपयोग से बहुत बेहतर है - एन्यूमरेटिंग पासवर्ड अधिक समय लगेगा। वर्तमान में, पुनरावृत्तियों की संख्या ओपनएसएसएल कोड में पंजीकृत है, मुझे उम्मीद है कि भविष्य में इसे कॉन्फ़िगर करना संभव होगा।

निष्कर्ष

यदि आप निजी कुंजी के लिए एक जटिल पासवर्ड सेट करते हैं, तो इसे पारंपरिक प्रारूप से पीकेसीएस # 8 में परिवर्तित करके कुछ वर्णों की पासवर्ड लंबाई बढ़ाने के साथ तुलना की जा सकती है। यदि आप एक कमजोर पासवर्ड का उपयोग करते हैं, तो PKCS # 8 इसके चयन को और अधिक कठिन बना देगा।

कुंजी प्रारूप बदलना बहुत सरल है:

 $ mv ~/.ssh/id_rsa ~/.ssh/id_rsa.old $ openssl pkcs8 -topk8 -v2 des3 -in ~/.ssh/id_rsa.old -out ~/.ssh/id_rsa $ chmod 600 ~/.ssh/id_rsa # ,    .  ,    $ rm ~/.ssh/id_rsa.old 

openssl pkcs8 तीन बार एक पासवर्ड का अनुरोध करती है: एक बार एक मौजूदा कुंजी को अनलॉक करने के लिए और एक नई कुंजी फ़ाइल बनाते समय दो बार। आप एक नया पासवर्ड ले सकते हैं या पुराने का उपयोग कर सकते हैं, इससे कोई फर्क नहीं पड़ता।

सभी सॉफ्टवेयर PKCS # 8 प्रारूप को नहीं पढ़ सकते हैं, लेकिन चिंता करने की कोई बात नहीं है - केवल ssh क्लाइंट को निजी ssh कुंजी तक पहुंच की आवश्यकता होती है। सर्वर के दृष्टिकोण से, निजी कुंजी को एक अलग प्रारूप में संग्रहीत करने से कुछ भी नहीं बदलता है।

अनुवादक टिप्पणी और रचनात्मक आलोचना सुनकर खुश होगा।