Rutoken EDS और Rutoken S का उपयोग करके एस्ट्रा लिनक्स में प्रमाणीकरण के लिए PAM मॉड्यूल का विकास और अनुप्रयोग

इस आलेख में, मैं इस बारे में बात करना चाहूंगा कि कैसे लिनक्स एप्लिकेशन उपयोगकर्ताओं को पारदर्शी रूप से प्रमाणित करने के लिए प्लगगेज ऑथेंटिकेशन मॉड्यूल सिस्टम का उपयोग कर सकते हैं। हम लिनक्स में प्रमाणीकरण तंत्र के विकास के इतिहास में थोड़ा बदलाव करेंगे, हम PAM सेटिंग्स सिस्टम को समझेंगे और pam_p11 प्रमाणीकरण मॉड्यूल के स्रोत कोड का विश्लेषण करेंगे, जो उपयोगकर्ताओं को स्मार्ट कार्ड का उपयोग करके प्रमाणित करने की अनुमति देता है।
लेख के अंत में, हम अभ्यास में जांच करेंगे कि सुरक्षा वर्ग 3 एसवीटी और स्तर 2 के अनुसार प्रमाणित मॉड्यूल के प्रमाणीकरण और संचालन का संचालन यूएसबी टोकन टोकन यूडीएस और रुतोकेन एस के साथ प्रमाणीकरण के लिए एस्ट्रा लिनक्स वितरण की अघोषित क्षमताओं की कमी को नियंत्रित करता है। NDV 3, और Rutoken EDS के लिए NDV 4 के लिए, इस समाधान का उपयोग सूचना प्रणालियों में किया जा सकता है जो गोपनीय जानकारी को संसाधित करता है, "C" के साथ चिह्नित जानकारी तक।

थोड़ा इतिहास

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

1. लिनक्स-पीएएम पीएएम वास्तुकला का प्राथमिक कार्यान्वयन है, जिसकी चर्चा हम इस लेख में करते हैं।
2. OpenPAM BSD सिस्टम और Mac OS X में उपयोग किए जाने वाले PAM का वैकल्पिक कार्यान्वयन है
3. जावा पैम - लिनक्स-पीएएम पर जावा आवरण

PAM संरचना

पहले, आइए जानें कि "PAM मॉड्यूल" क्या है। मॉड्यूल वे लाइब्रेरीज़ हैं जिनमें ऑपरेशन हैंडलर होते हैं जो PAM खुद उन्हें निर्देशित कर सकते हैं। उदाहरण के लिए, मानक pam_unix मॉड्यूल निम्नलिखित कार्य कर सकता है:

• उपयोगकर्ता से एक पासवर्ड का अनुरोध करें और सिस्टम में संग्रहीत के साथ दर्ज मूल्य की जांच करें
• जांचें कि क्या पासवर्ड सुरक्षा आवश्यकताओं को पूरा करता है और यदि यह समाप्त हो गया है

नीचे एक सामान्य अवलोकन है कि PAM कैसे काम करता है।

PAM का उपयोग करते हुए एक आवेदन में एक बहुत ही सरल प्रमाणीकरण योजना इस प्रकार है:

1. आवेदन PAM पुस्तकालय (libpam.so) को प्रारंभ करता है
2. आवेदन के लिए कॉन्फ़िगरेशन फ़ाइल के अनुसार PAM आवश्यक मॉड्यूल तक पहुँचता है
3. मॉड्यूल उन्हें सौंपे गए कार्यों को पूरा करते हैं
4. ऑपरेशन का परिणाम आवेदन पर वापस आ गया है।

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

• प्रमाणीकरण (सामान्य)
• खाता प्रबंधन
• सत्र प्रबंधन
• पासवर्ड प्रबंधन (पासवार्ड)

अब हम केवल प्रमाणीकरण में रुचि रखते हैं, इसलिए हम पाठक के लिए बाकी उत्सुकता छोड़ देंगे।

PAM कॉन्फ़िगरेशन

यदि एप्लिकेशन को प्रमाणीकरण की आवश्यकता होती है, तो उसे /etc/pam.d निर्देशिका में उसके नाम के साथ एक फ़ाइल बनानी होगी, जिसमें मॉड्यूल जिसके साथ प्रमाणीकरण और अन्य क्रियाएं की जाती हैं, को इंगित किया जाना चाहिए। आइए देखें कि Ubuntu 11.10 में /etc/pam.d निर्देशिका में क्या निहित है

$ ls /etc/pam.d/ atd common-account common-session-noninteractive lightdm other samba vmtoolsd chfn common-auth cron lightdm-autologin passwd sshd chpasswd common-password cups login polkit-1 su chsh common-session gnome-screensaver newusers ppp sudo 

उदाहरण के लिए, लॉगिन एप्लिकेशन के लिए अमूर्त कॉन्फ़िगरेशन फ़ाइल देखें।

 # PAM configuration for login auth requisite pam_securetty.so auth required pam_nologin.so auth required pam_env.so auth required pam_unix.so nullok account required pam_unix.so session required pam_unix.so session optional pam_lastlog.so password required pam_unix.so nullok obscure min=4 max=8 

विन्यास की प्रत्येक पंक्ति के रूप में लिखा गया है

 < > < > <  > <> 

• मॉड्यूल का प्रकार स्वयं मॉड्यूल के संकेतन से मेल खाता है (यानी, सामान्य / खाता / सत्र / पासवार्ड)
• सफल संचालन के लिए नियंत्रण ध्वज मॉड्यूल की महत्वपूर्णता को इंगित करता है। ध्वज निम्नलिखित मान ले सकता है: अपेक्षित (आवश्यक), आवश्यक (आवश्यक), पर्याप्त (पर्याप्त) और वैकल्पिक (वैकल्पिक)।
• लायब्रेरी का पथ मॉड्यूल फ़ाइल के लिए वास्तविक पथ सेट करता है। डिफ़ॉल्ट रूप से, उन्हें / lib / सुरक्षा / में खोजा जाता है
• पैरामीटर उन तर्कों की सूची को निर्दिष्ट करते हैं जो मॉड्यूल को पारित किए जाएंगे। तर्कों को उसी तरह से पारित किया जाता है जैसे मुख्य () फ़ंक्शन में argc / argv सिद्धांत, सिवाय इसके कि argv [0] में मॉड्यूल नाम नहीं होता है, लेकिन एक विशिष्ट तर्क होता है।

इस प्रकार, हमें मॉड्यूल का ढेर मिलता है, जिनमें से प्रत्येक अपनी कार्रवाई करता है। PAM एक ही समय में स्टैक को पार्स करता है, जैसा कि ऊपर से नीचे तक होना चाहिए। नियंत्रण ध्वज के अनुसार, ऑपरेशन की सफलता के लिए निम्नलिखित आवश्यकताएं निर्धारित की गई हैं:

• अपेक्षित (आवश्यक): यदि स्टैक मॉड्यूल नकारात्मक प्रतिक्रिया देता है, तो अनुरोध तुरंत अस्वीकार कर दिया जाता है। अन्य मॉड्यूल निष्पादित नहीं किया जाएगा।
• आवश्यक: यदि एक या अधिक स्टैक मॉड्यूल नकारात्मक प्रतिक्रिया देता है, तो अन्य सभी मॉड्यूल निष्पादित किए जाएंगे, लेकिन एप्लिकेशन अनुरोध अस्वीकार कर दिया जाएगा।
• पर्याप्त: यदि मॉड्यूल को पर्याप्त के रूप में चिह्नित किया गया है और इससे पहले कि आवश्यक या पर्याप्त मॉड्यूल में से कोई भी नकारात्मक उत्तर नहीं देता है, तो स्टैक में शेष सभी मॉड्यूल को अनदेखा किया जाता है, और एक सकारात्मक उत्तर दिया जाता है।
• वैकल्पिक: यदि स्टैक में आवश्यक मॉड्यूल नहीं हैं, और यदि पर्याप्त मॉड्यूल में से किसी ने भी सकारात्मक प्रतिक्रिया नहीं दी है, तो कम से कम एप्लिकेशन या सेवा के अतिरिक्त मॉड्यूलों में से एक को सकारात्मक प्रतिक्रिया देना चाहिए

मॉड्यूल कॉन्फ़िगरेशन फ़ाइलों को / usr / share / pam-configs / <मॉड्यूल नाम> में संग्रहीत किया जाता है। प्रत्येक फ़ाइल मॉड्यूल के पूर्ण नाम को इंगित करती है, चाहे वह डिफ़ॉल्ट रूप से सक्षम हो, मॉड्यूल की प्राथमिकता और प्रमाणीकरण पैरामीटर।

PAM के लिए एक प्रमाणीकरण मॉड्यूल का विकास

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

pam_p11

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

• उपयोगकर्ता प्रमाणपत्र और उसकी निजी कुंजी टोकन पर संग्रहीत होती है
• प्रमाण पत्र भी उपयोगकर्ता के घर निर्देशिका में संग्रहीत के रूप में विश्वसनीय है

प्रमाणीकरण निम्नानुसार है:

1. उपयोगकर्ता प्रमाणपत्र के लिए टोकन खोजा जाता है
2. PAM के माध्यम से, टोकन के लिए एक पिन कोड मांगा जाता है
3. यदि टोकन पर प्रमाणीकरण सफल था, तो टोकन से निजी कुंजी का उपयोग करके यादृच्छिक डेटा पर हस्ताक्षर किए जाते हैं। हस्ताक्षर स्वयं हार्डवेयर में किया जाता है।
4. प्राप्त डिजिटल हस्ताक्षर को एक उपयोगकर्ता प्रमाणपत्र का उपयोग करके सत्यापित किया गया है।

यदि, परिणामस्वरूप, हस्ताक्षर का सत्यापन सफल रहा, तो मॉड्यूल बाहरी रूप से कहता है कि सब कुछ ठीक है।
इस योजना में, 2048-बिट आरएसए कुंजी जोड़ी का उपयोग किया जाता है, टोकन पर हार्डवेयर-जनरेट किया जाता है।

वास्तव में मॉड्यूल विकास

मॉड्यूल की कार्यक्षमता के आधार पर, PAM को निम्नलिखित कार्यों की आवश्यकता हो सकती है:

• pam_sm_authenticate, pam_sm_setcred - प्रमाणीकरण
• pam_sm_acct_mgmt - खाता प्रबंधन
• pam_sm_chauthtok - पासवर्ड प्रबंधन
• pam_sm_open_session, pam_sm_close_session - सत्र प्रबंधन

मॉड्यूल को प्रमाणित करने में सक्षम होने के लिए, हमें इसमें pam_sm_authenticate और pam_sm_setcred फ़ंक्शंस लागू करने की आवश्यकता है। अन्य कार्यों में, बस स्टब्स को जोड़ने के लिए पर्याप्त है ताकि हमारे मॉड्यूल को अन्य कार्यों के लिए उपयोग नहीं किया जा सके।
PAM के साथ काम करने के लिए, आपको विशेष स्थिरांक को परिभाषित करने की आवश्यकता है, और उसके बाद ही शीर्ष लेख फ़ाइलों को शामिल करें:

 #define PAM_SM_AUTH #define PAM_SM_ACCOUNT #define PAM_SM_SESSION #define PAM_SM_PASSWORD #include <security/pam_appl.h> #include <security/pam_modules.h> 

PAM के लिए ये स्थिरांक आवश्यक हैं, यह जानने के लिए कि हमारा मॉड्यूल ऊपर वर्णित सभी कार्यों को कर सकता है। बेशक, अगर हम केवल प्रमाणीकरण को लागू करते हैं, तो बाकी कार्यों को छोड़ दिया जा सकता है, लेकिन pam_p11 के डेवलपर्स ने फैसला किया कि अप्रयुक्त कार्यों के बजाय स्टब्स डालना अधिक विश्वसनीय होगा।
चलिए pam_sm_authenticate फ़ंक्शन लिखना शुरू करते हैं। इसके निम्नलिखित हस्ताक्षर हैं:

 PAM_EXTERN int pam_sm_authenticate(pam_handle_t *pamh, int flags, int argc, const char **argv); 

यहाँ महत्वपूर्ण मापदंडों में से यह ध्यान देने योग्य है:

• pamh - एप्लिकेशन द्वारा प्राप्त PAM को हैंडल करें
• argc, argv - कॉन्फ़िगरेशन फ़ाइल में निर्दिष्ट तर्क। हमारा मॉड्यूल एक तर्क को स्वीकार करता है - PKCS # 11 पुस्तकालय का मार्ग

फ़ंक्शन को निम्न मानों में से एक को वापस करना चाहिए:

• PAM_AUTH_ERR - प्रमाणीकरण त्रुटि
• PAM_CRED_INSUFFICIENT - प्रमाणीकरण करने के लिए आवेदन में पर्याप्त विशेषाधिकार नहीं हैं
• PAM_AUTHINFO_UNAVAIL - मॉड्यूल प्रमाणीकरण के लिए जानकारी प्राप्त करने में असमर्थ था। यह नेटवर्क समस्याओं या अन्य हार्डवेयर विफलता के कारण हो सकता है।
• PAM_SUCCESS - प्रमाणीकरण सफल
• PAM_USER_UNKNOWN - दिए गए नाम वाला उपयोगकर्ता मौजूद नहीं है
• PAM_MAXTRIES - एक या अधिक प्रमाणीकरण मॉड्यूल प्रयासों की अनुमत सीमा से अधिक हो गए।

हमारे मॉड्यूल के अंदर, हम प्रमाणपत्रों के साथ काम करने के लिए PKCS # 11 API और OpenSSL के साथ काम करने के लिए libp11 लाइब्रेरी का उपयोग करेंगे।
सबसे पहले, हम उन चर को परिभाषित करते हैं जिनकी हमें आवश्यकता है:

 int i, rv; const char *user; //   char *password; //    char password_prompt[64]; //    ,   //  PAM struct pam_conv *conv; //   PAM struct pam_message msg; //   PAM struct pam_message *(msgp[1]); struct pam_response *resp; //  PAM //  lib_p11: PKCS11_CTX *ctx; //  PKCS#11 PKCS11_SLOT *slot, *slots; //  PKCS11_CERT *certs; //  unsigned int nslots, ncerts; PKCS11_KEY *authkey; //   PKCS11_CERT *authcert; //  EVP_PKEY *pubkey; //   OpenSSL    unsigned char rand_bytes[RANDOM_SIZE]; unsigned char signature[MAX_SIGSIZE]; int fd; unsigned siglen; 

यदि हम PKCS # 11 पुस्तकालय के लिए रास्ता दिया गया है तो हम जाँच करेंगे

 if (argc != 1) { pam_syslog(pamh, LOG_ERR, "need pkcs11 module as argument"); return PAM_ABORT; } 

उसके बाद हम ओपनएसएसएल और पीकेसीएस # 11 संदर्भ को इनिशियलाइज़ करते हैं

 OpenSSL_add_all_algorithms(); ERR_load_crypto_strings(); ctx = PKCS11_CTX_new(); 

पीएएम उपयोगकर्ता नाम का अनुरोध करें

 rv = pam_get_user(pamh, &user, NULL); if (rv != PAM_SUCCESS) { pam_syslog(pamh, LOG_ERR, "pam_get_user() failed %s", pam_strerror(pamh, rv)); return PAM_USER_UNKNOWN; } 

अब PKCS # 11 लाइब्रेरी को लोड करें, पहले उपलब्ध टोकन को ढूंढें और उससे प्रमाणपत्र प्राप्त करें

 rv = PKCS11_CTX_load(ctx, argv[0]); if (rv) { pam_syslog(pamh, LOG_ERR, "loading pkcs11 engine failed"); return PAM_AUTHINFO_UNAVAIL; } //     PKCS#11 rv = PKCS11_enumerate_slots(ctx, &slots, &nslots); if (rv) { pam_syslog(pamh, LOG_ERR, "listing slots failed"); return PAM_AUTHINFO_UNAVAIL; } //      slot = PKCS11_find_token(ctx, slots, nslots); if (!slot || !slot->token) { pam_syslog(pamh, LOG_ERR, "no token available"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } //     rv = PKCS11_enumerate_certs(slot->token, &certs, &ncerts); if (rv) { pam_syslog(pamh, LOG_ERR, "PKCS11_enumerate_certs failed"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } if (ncerts <= 0) { pam_syslog(pamh, LOG_ERR, "no certificates found"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } 

अब टोकन के प्रमाणपत्रों के बीच हम पाते हैं कि ~ / .eid / प्राधिकृत_पत्रकारों में हमारे साथ निहित है:

 for (i = 0; i < ncerts; i++) { authcert = &certs[i]; if (authcert != NULL) { /* ,        */ rv = match_user(authcert->x509, user); if (rv < 0) { pam_syslog(pamh, LOG_ERR, "match_user() failed"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } else if (rv == 0) { /* this is not the cert we are looking for */ authcert = NULL; } else { break; } } } if (!authcert) { pam_syslog(pamh, LOG_ERR, "no matching certificates found"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } 

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

 //   ,    PAM      rv = pam_get_item(pamh, PAM_AUTHTOK, (void *)&password); if (rv == PAM_SUCCESS && password) { password = strdup(password); } else { //    ,      sprintf(password_prompt, "Password for token %.32s: ", slot->token->label); //    PAM:     "" msg.msg_style = PAM_PROMPT_ECHO_OFF; msg.msg = password_prompt; //      PAM rv = pam_get_item(pamh, PAM_CONV, (const void **)&conv); if (rv != PAM_SUCCESS) { rv = PAM_AUTHINFO_UNAVAIL; goto out; } if ((conv == NULL) || (conv->conv == NULL)) { rv = PAM_AUTHINFO_UNAVAIL; goto out; } //   ,      resp rv = conv->conv(1, (const struct pam_message **)msgp, &resp, conv->appdata_ptr); if (rv != PAM_SUCCESS) { rv = PAM_AUTHINFO_UNAVAIL; goto out; } if ((resp == NULL) || (resp[0].resp == NULL)) { rv = PAM_AUTHINFO_UNAVAIL; goto out; } //       password = strdup(resp[0].resp); memset(resp[0].resp, 0, strlen(resp[0].resp)); free(&resp[0]); } 

अब हम टोकन पर प्रमाणीकरण कर सकते हैं:

 rv = PKCS11_login(slot, 0, password); //    ,    memset(password, 0, strlen(password)); free(password); if (rv != 0) { pam_syslog(pamh, LOG_ERR, "PKCS11_login failed"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } 

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

 fd = open(RANDOM_SOURCE, O_RDONLY); if (fd < 0) { pam_syslog(pamh, LOG_ERR, "fatal: cannot open RANDOM_SOURCE: "); rv = PAM_AUTHINFO_UNAVAIL; goto out; } rv = read(fd, rand_bytes, RANDOM_SIZE); if (rv < 0) { pam_syslog(pamh, LOG_ERR, "fatal: read from random source failed: "); close(fd); rv = PAM_AUTHINFO_UNAVAIL; goto out; } if (rv < RANDOM_SIZE) { pam_syslog(pamh, LOG_ERR, "fatal: read returned less than %d<%d bytes\n", rv, RANDOM_SIZE); close(fd); rv = PAM_AUTHINFO_UNAVAIL; goto out; } close(fd); 

तब हमें प्रमाणपत्र के अनुरूप निजी कुंजी मिलती है और उस पर यादृच्छिक डेटा पर हस्ताक्षर करते हैं

 //      authkey = PKCS11_find_key(authcert); if (!authkey) { pam_syslog(pamh, LOG_ERR, "no key matching certificate available"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } //    siglen = MAX_SIGSIZE; rv = PKCS11_sign(NID_sha1, rand_bytes, RANDOM_SIZE, signature, &siglen, authkey); if (rv != 1) { pam_syslog(pamh, LOG_ERR, "fatal: pkcs11_sign failed\n"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } 

हस्ताक्षर सत्यापित करें। ऐसा करने के लिए, पहले, ओपनएसएसएल का उपयोग करते हुए, हमें प्रमाणपत्र से सार्वजनिक कुंजी मिल जाएगी, और फिर हम डिजिटल हस्ताक्षर की जांच करेंगे

 pubkey = X509_get_pubkey(authcert->x509); if (pubkey == NULL) { pam_syslog(pamh, LOG_ERR, "could not extract public key"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } //      OpenSSL rv = RSA_verify(NID_sha1, rand_bytes, RANDOM_SIZE, signature, siglen, pubkey->pkey.rsa); if (rv != 1) { pam_syslog(pamh, LOG_ERR, "fatal: RSA_verify failed\n"); rv = PAM_AUTHINFO_UNAVAIL; goto out; } 

यदि हस्ताक्षर का सत्यापन सफल रहा, तो हम PKCS # 11 पुस्तकालय के साथ काम पूरा कर सकते हैं और PAM_SUCCESS को लौटा सकते हैं।

  rv = PAM_SUCCESS; out: PKCS11_release_all_slots(ctx, slots, nslots); PKCS11_CTX_unload(ctx); PKCS11_CTX_free(ctx); return rv; 

बाकी कार्यों के बजाय, हम बिना किसी ब्याज के स्टब्स को छोड़ देंगे, मॉड्यूल को इकट्ठा करेंगे और इसके कॉन्फ़िगरेशन और उपयोग के साथ आगे बढ़ेंगे।

व्यावहारिक उपयोग

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

अतिरिक्त पैकेज स्थापित करें

पहले मुझे कुछ पैकेज स्थापित करने थे। रुतोकेन एस के संचालन के लिए, ओपनएससी के एक पुराने संस्करण की आवश्यकता है: 0.11.13, और रुतोकेन ईडीएस के संचालन के लिए, एक नए संस्करण की आवश्यकता है: 0.12.2। OpenCT संस्करण 0.6.20 का उपयोग दोनों टोकन के लिए मिडलवेयर के रूप में किया जाता है।
परिणामस्वरूप, वितरण किट के डेवलपर्स द्वारा वितरित पैकेज वितरित किए गए:

• libopenct1 (0.6.20-1.2): libopenct1_0.6.20-1.2_amd64.deb
• openct (0.6.20-1.2): openct_0.6.20-1.2_amd64.deb

रुतोकेन एस के लिए

• libopensc2_0.11.13-1.1_amd64.deb
• opensc_0.11.13-1.1_amd64.deb
• मोज़िला opensc_0.11.13-1.1_amd64.deb

रुतोकेन के लिए ई.डी.एस.

• खुलता है (0.12.2-2): खुलता है_0.12.2-2_amd64.deb

ओपनसी के नए संस्करण को स्थापित करते समय, पैकेजों की निर्भरता को संतुष्ट करना आवश्यक था। इसके लिए, डेबियन निचोड़ भंडार से निम्नलिखित पैकेज लिए गए:

• libltdl7 (> = 2.2.6b): libltdl7_2.2.6b-2_amd64.deb
• libssl0.9.8 (> = 0.9.8m-1): libssl0.9.8_0.9.8o-4squeeze11_amd64.deb

PAM मॉड्यूल और इसकी निर्भरताएँ

टोकन द्वारा प्रमाणीकरण को लागू करने के लिए, निम्नलिखित पैकेज स्थापित किए गए थे:

• libp11-1 (0.2.7-2): libp11-1_0.2.7-2_amd64.deb
• libpam-p11 (0.1.5-1): libpam-p11_0.1.5-1 + b1_amd64.deb
• libengine-pkcs11-खुलता है (0.1.8-2): libengine-pkcs11-खुलता है_0.1.8-2_amd64.deb

Pam_p11 सेटिंग

सौभाग्य से, हमें लगभग अपने हाथों से कॉन्फ़िगरेशन को संपादित करने की आवश्यकता नहीं है। यह निम्नलिखित सामग्री के साथ फ़ाइल / usr / शेयर / pam-configs / p11 बनाने के लिए पर्याप्त है:

 Name: Pam_p11 Default: yes Priority: 800 Auth-Type: Primary Auth: sufficient pam_p11_opensc.so /usr/lib/opensc-pkcs11.so 

ब्याज की विन्यास की अंतिम पंक्ति है, जिसमें हम मॉड्यूल के प्रकार, लाइब्रेरी का नाम और मॉड्यूल को दिए गए मापदंडों को दर्शाते हैं। हमारा मॉड्यूल पीकेसीएस # 11 पुस्तकालय के लिए एक पैरामीटर के रूप में लेता है।
अब हमें बस कमांड को निष्पादित करना है

 $ pam-auth-update 

दिखाई देने वाले संवाद में, pam_p11 चुनें। यदि आप पासवर्ड प्रमाणीकरण को अक्षम करना चाहते हैं, तो आप यूनिक्स प्रमाणीकरण को अक्षम कर सकते हैं। चूंकि यह प्रोफ़ाइल कॉन्फ़िगरेशन फ़ाइल में इंगित किया गया था कि मॉड्यूल "पर्याप्त" होगा, हमारे मॉड्यूल से प्रतिक्रिया "PAM_SUCCESS" प्राप्त होने पर, संपूर्ण प्रमाणीकरण प्रक्रिया को सफल माना जाएगा।

एक कुंजी और प्रमाण पत्र बनाएँ

सबसे पहले, आईडी "45" के साथ 2048 बिट्स की आरएसए कुंजी जोड़ी बनाएं (आईडी याद रखने योग्य है, प्रमाण पत्र बनाते समय आपको इसकी आवश्यकता होगी)।

 $ pkcs15-init --generate-key rsa/2048 --auth-id 02 --id 45 < PIN > 

उत्पन्न कुंजी की जाँच करें:

 $ pkcs15-tool --list-keys Using reader with a card: Aktiv Rutoken ECP 00 00 Private RSA Key [Private Key] Object Flags : [0x3], private, modifiable Usage : [0x4], sign Access Flags : [0x1D], sensitive, alwaysSensitive, neverExtract, local ModLength : 2048 Key ref : 1 (0x1) Native : yes Path : 3f001000100060020001 Auth ID : 02 ID : 45 

अब ओपनएसएसएल का उपयोग करते हुए, एक स्व-हस्ताक्षरित प्रमाण पत्र बनाएं। हम खुलता है और pkcs11 समर्थन मॉड्यूल को लोड करना शुरू करते हैं:

 $ openssl OpenSSL> engine dynamic -pre SO_PATH:/usr/lib/engines/engine_pkcs11.so -pre ID:pkcs11 -pre LIST_ADD:1 -pre LOAD -pre MODULE_PATH:opensc-pkcs11.so (dynamic) Dynamic engine loading support [Success]: SO_PATH:/usr/lib/engines/engine_pkcs11.so [Success]: ID:pkcs11 [Success]: LIST_ADD:1 [Success]: LOAD Loaded: (pkcs11) pkcs11 engine 

PEM प्रारूप में एक प्रमाण पत्र बनाएँ:

 OpenSSL> req -engine pkcs11 -new -key 1:45 -keyform engine -x509 -out cert.pem –text 

अंतिम कमांड में, 1:45 एक जोड़ी है: <कुंजी आईडी>। इस प्रकार, हमने टोकन पर संग्रहीत एक प्रमुख जोड़ी के आधार पर एक प्रमाण पत्र बनाया। इस मामले में, एक सर्टिफिकेट नाम की सर्टिफिकेट फाइल वर्तमान निर्देशिका में बनाई जानी चाहिए।
अब टोकन प्रमाणपत्र सहेजें:

 $ pkcs15-init --store-certificate cert.pem --auth-id 02 --id 45 --format pem < PIN > 

विश्वसनीय की सूची में प्रमाण पत्र दर्ज करना

इस स्तर पर, हमें केवल टोकन से वांछित आईडी के साथ प्रमाण पत्र को पढ़ना होगा और इसे विश्वसनीय प्रमाण पत्र की फ़ाइल में लिखना होगा:

 $ mkdir ~/.eid $ chmod 0755 ~/.eid $ pkcs15-tool -r <certificate_id> > ~/.eid/authorized_certificates $ chmod 0644 ~/.eid/authorized_certificates 

निष्कर्ष

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