GOST एल्गोरिदम का उपयोग करके डोमेन में प्रवेश करने के लिए लिनक्स को कैसे कॉन्फ़िगर करें

परिचय

Kerberos 5 प्रोटोकॉल अब प्रमाणीकरण के लिए सक्रिय रूप से उपयोग किया जाता है। इस प्रोटोकॉल की एक विशेषता यह है कि यह चार स्तंभों के आधार पर प्रमाणीकरण करता है:

1. सममित एन्क्रिप्शन;
2. हैश;
3. ईडीएस;
4. थर्ड ट्रस्टेड पार्टी।

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

दुर्भाग्य से, एन्क्रिप्शन, हैशिंग और डिजिटल हस्ताक्षर एल्गोरिदम की संख्या, जो इस प्रोटोकॉल का उपयोग करता है, जितना मैं चाहूंगा उतना बड़ा नहीं है, इसलिए इस लेख में मैं यह दिखाना चाहता हूं कि कैसे जोड़ना है आसान और सरल एमआईटी द्वारा इस प्रोटोकॉल के कार्यान्वयन के लिए स्वयं के एल्गोरिदम। हम अपने घरेलू एल्गोरिदम जोड़ेंगे: GOST 28147-89 (उर्फ मैग्मा), GOST R 34.11-2012 (उर्फ Stribog) और GOST R 34.10-2012 (मैं भी इसके लिए उर्फ ​​करना चाहूंगा, लेकिन मुझे पता नहीं है :()। इन एल्गोरिदम के लिए एक समाधान मेरी रिपॉजिटरी में पाया जा सकता है । क्लाइंट की ओर से, हम रुटोकन ईडीएस 2.0 में GOST एल्गोरिदम के हार्डवेयर कार्यान्वयन और ओपनएसएल के लिए इंजन GOST में उनके सॉफ्टवेयर कार्यान्वयन का उपयोग करेंगे। लेकिन कुंजी जमा करने के लिए सबसे सुरक्षित विकल्प है जब वे सीधे रुतोकेन पर उत्पन्न होते हैं और कभी नहीं। क्रिप्टोग्राफिक संचालन के दौरान उसकी स्मृति को न छोड़ें इस विकल्प के लिए, rtengine की आवश्यकता है।

एल्गोरिदम को लागू करने से पहले, हम उन मुख्य स्थानों का वर्णन करते हैं जहां परिवर्तन किए जाएंगे। Src / lib / crypto / directory के अंदर सममित क्रिप्टोग्राफी और हैशिंग के लिए जिम्मेदार सभी एल्गोरिदम के कार्यान्वयन हैं। इसमें इन क्रिप्टोग्राफिक एल्गोरिदम के 2 कार्यान्वयन हैं: बिलिन और ओपनसेल। समय और स्थान बचाने के लिए, हम, निश्चित रूप से, ओप्स्नल का उपयोग करके एल्गोरिदम के कार्यान्वयन को जोड़ेंगे, जिसमें वे पहले से मौजूद हैं (अच्छी तरह से, या लगभग वहां, लेकिन बाद में उस पर और अधिक)। असममित एल्गोरिदम को जोड़ने के लिए, आपको src / plugins / proputh / pkinit प्लगइन को ट्विक करना होगा

यदि आपने अभी तक केर्बरोस को कॉन्फ़िगर नहीं किया है, तो इसके प्रारंभिक कॉन्फ़िगरेशन और संचालन के निर्देश यहां मिल सकते हैं । इसके अलावा, लेखक मानता है कि आप AKTIV-TEST.RU डोमेन के साथ काम कर रहे हैं

हैश एल्गोरिदम और सममित एन्क्रिप्शन जोड़ना

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

OpenSl इंजन इंजन का एक छोटा सा परिचय और इंजन GOST को जोड़ना

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

उदाहरण के लिए, स्थापना बहुत ही सरल है, और इस प्रकार आगे बढ़ती है:

1. इस इंजन का कार्यान्वयन रिपॉजिटरी से डाउनलोड करें ।

   
   

2. इसके साथ एक पुस्तकालय बनाएं (mkdir build && cd build && cmake ... && make):

   
   

   mkdir build cd build cmake .. make 

   
   

3. बिन निर्देशिका में (जो परियोजना के रूट सूची में शामिल होंगे !!!) एक गतिशील पुस्तकालय gost.so होगा - यह हमारा इंजन है। इसे उस डायरेक्टरी में ले जाना होगा जहाँ पर ओपनस्क्ल इंजन को स्टोर किया जाता है। इस निर्देशिका का उपयोग करके पता लगाएँ:

   
   

    openssl version -a | grep ENGINESDIR 

   
   

4. यह उत्तरार्द्ध तक है - आपको ओपनसेल को यह बताने की जरूरत है कि दिया गया इंजन कहां है और इसे क्या कहा जाता है। आप इसे opensl.cnf कॉन्फ़िगरेशन फ़ाइल को बदलकर कर सकते हैं। जिस स्थान का उपयोग करके पाया जा सकता है:

   
   

    openssl version -a | grep OPENSSLDIR 

   
   

   इस फ़ाइल के अंत में आपको निम्नलिखित सामग्री डालनी होगी:

   
   

    #     openssl_conf = openssl_def ... #    # OpenSSL default section [openssl_def] engines = engine_section # Engine section [engine_section] gost = gost_section # Engine gost section [gost_section] engine_id = gost dynamic_path = /path/to/engines/dir/with/gost.so default_algorithms = ALL init = 0 

   
   

उसके बाद, यह इंजन ओपनसेल में दिखाई देना चाहिए। आप उदाहरण के लिए, उदाहरण के लिए, GOST R 34.10-2012 के अनुसार फ़ाइल में एक निजी कुंजी उत्पन्न करने के लिए इसके प्रदर्शन की जांच कर सकते हैं:

 openssl genpkey -engine gost -algorithm gost2012_512 -pkeyopt paramset:A -out client_key.pem 

-गाइनिन ध्वज केवल इंगित करता है कि काम शुरू करने से पहले किस इंजन को लोड करने की आवश्यकता है ताकि GOST R 34.10-2012 के लिए प्रमुख पीढ़ी का एल्गोरिथ्म दिखाई दे।

हैश एल्गोरिथम कार्यान्वयन

आइए सरलतम से शुरू करें - स्ट्रिबॉग एल्गोरिदम के कार्यान्वयन के साथ। केरबरोस का हैशिंग और एन्क्रिप्शन एल्गोरिदम के बीच एक मजबूत संबंध है, अर्थात, आप एन्क्रिप्शन के लिए केवल एक एल्गोरिथ्म चुन और चुन नहीं सकते हैं, और हैशिंग अन्य के लिए, आपको हैश और एन्क्रिप्शन एल्गोरिथ्म को एकीकृत करने की आवश्यकता होगी। इसका कारण मुझे ज्ञात नहीं है, लेकिन चूंकि इस तरह के नियम मौजूद हैं - आइए स्ट्रीब एल्गोरिथ्म और एईएस का संयोजन बनाने का प्रयास करें।

1. क्योंकि हमें अपने कार्यक्रम के विभिन्न स्थानों में कनेक्शन की आवश्यकता है, आइए पहले एक छोटी सी gost_helper लाइब्रेरी बनाएं जिसमें खुलने में इंजन का इनिशियलाइज़ेशन फंक्शन होगा, साथ ही कुछ फ़ंक्शंस जो सुविधा के लिए कुछ हैशिंग एल्गोरिदम के संदर्भों को लौटाते हैं - यह हमें भविष्य में मदद करेगा। हम इस लाइब्रेरी को gost_helper नाम देते हैं और src / lib / crypto / खुलने / निर्देशिका में इसके लिए एक उपयुक्त हेडर और सोर्स फ़ाइल बनाते हैं:

   
   

    // gost_helper.h #include <openssl/evp.h> //    GOST void krb5int_init_gost(); //  ,     const EVP_MD * EVP_gostR3411_2012_256(); const EVP_MD * EVP_gostR3411_2012_512(); // gost_helper.c #include "gost_helper.h" #include <openssl/engine.h> //     static ENGINE *eng = NULL; void krb5int_init_gost() { //    ,      if (eng) return; OPENSSL_add_all_algorithms_conf(); ERR_load_crypto_strings(); if (!(eng = ENGINE_by_id("gost"))) { printf("Engine gost doesn't exist"); return; } ENGINE_init(eng); ENGINE_set_default(eng, ENGINE_METHOD_ALL); } const EVP_MD * EVP_gostR3411_2012_256() { krb5int_init_gost(); return EVP_get_digestbynid(NID_id_GostR3411_2012_256); } const EVP_MD * EVP_gostR3411_2012_512() { krb5int_init_gost(); return EVP_get_digestbynid(NID_id_GostR3411_2012_512); } 

   
   

2. सहायक पुस्तकालय को जोड़ने के बाद, आपको मेकफाइल में इसके अस्तित्व की घोषणा करने और इसकी फ़ाइल निर्भरता को लिखने की आवश्यकता होगी। ऐसा करने के लिए, निम्नलिखित जोड़ें:

   
   

    #    src/lib/crypto/openssl/Makefile.in      : STLIBOBJS=\ hmac.o \ ... stubs.o \ gost_helper.o OBJS=\ $(OUTPRE)hmac.$(OBJEXT) \ ... $(OUTPRE)stubs.$(OBJEXT) \ $(OUTPRE)gost_helper$(OBJEXT) SRCS=\ $(srcdir)/hmac.c \ ... $(srcdir)/stubs.c \ $(srcdir)/gost_helper.c #    src/lib/crypto/openssl/deps ,         : gost_helper.so gost_helper.po $(OUTPRE)gost_helper.$(OBJEXT): $(BUILDTOP)/include/autoconf.h \ $(BUILDTOP)/include/krb5/krb5.h $(BUILDTOP)/include/osconf.h \ $(BUILDTOP)/include/profile.h $(COM_ERR_DEPS) $(top_srcdir)/include/k5-buf.h \ $(top_srcdir)/include/k5-err.h $(top_srcdir)/include/k5-gmt_mktime.h \ $(top_srcdir)/include/k5-int-pkinit.h $(top_srcdir)/include/k5-int.h \ $(top_srcdir)/include/k5-platform.h $(top_srcdir)/include/k5-plugin.h \ $(top_srcdir)/include/k5-thread.h $(top_srcdir)/include/k5-trace.h \ $(top_srcdir)/include/krb5.h $(top_srcdir)/include/krb5/authdata_plugin.h \ $(top_srcdir)/include/krb5/plugin.h $(top_srcdir)/include/port-sockets.h \ gost_helper.c gost_helper.h 

   
   

3. यह ध्यान देने योग्य है कि भविष्य में, इस लाइब्रेरी को कनेक्ट करते समय, हमें इस लाइब्रेरी के हेडर पर कुछ फाइलों की निर्भरता को जोड़ना होगा। यह बहुत सरलता से किया जाता है - लक्ष्य पाया जाता है, जहां आपको डिप्स फ़ाइल में निर्भरता जोड़ने की आवश्यकता होती है और rel / path / to / gost_helper.h पर निर्भरता दर्ज की जाती है । उदाहरण के लिए, src / lib / crypto / opensl / hash_provider / deps में आपको निम्नलिखित जोड़ने की आवश्यकता होगी:

   
   

    hash_evp.so hash_evp.po $(OUTPRE)hash_evp.$(OBJEXT): \ $(BUILDTOP)/include/autoconf.h $(BUILDTOP)/include/krb5/krb5.h \ ... $(srcdir)/../gost_helper.h hash_evp.c 

   
   

   लेख में स्थान बचाने और अपने दिमाग को लंबा करने के लिए, मैं अब इस पर ध्यान नहीं दूंगा: सावधान और सावधान रहें!

   
   

4. अब हैश फ़ंक्शन कार्यान्वयन जोड़ें, उनके सभी कार्यान्वयन src / lib / crypto / opensl / hash_provider / hash_evp.c में हैं । वहां आपको निम्नलिखित जोड़ना होगा:

   
   

    //     deps !!!          #include "crypto_int.h" #include "gost_helper.h" #include <openssl/evp.h> ... static krb5_error_code hash_sha384(const krb5_crypto_iov *data, size_t num_data, krb5_data *output) { return hash_evp(EVP_sha384(), data, num_data, output); } static krb5_error_code hash_stribog256(const krb5_crypto_iov *data, size_t num_data, krb5_data *output) { return hash_evp(EVP_gostR3411_2012_256(), data, num_data, output); } static krb5_error_code hash_stribog512(const krb5_crypto_iov *data, size_t num_data, krb5_data *output) { return hash_evp(EVP_gostR3411_2012_512(), data, num_data, output); } //    /*   --    --      --        --     */ const struct krb5_hash_provider krb5int_hash_sha384 = { "SHA-384", 48, 128, hash_sha384 }; const struct krb5_hash_provider krb5int_hash_stribog256 = { "GOSTR34.11-2012-256", 32, 64, hash_stribog256 }; const struct krb5_hash_provider krb5int_hash_stribog512 = { "GOSTR34.11-2012-512", 64, 64, hash_stribog512 }; 

   
   

5. अब हमें पूरे पुस्तकालय में इन संदर्भों को घोषित करने की आवश्यकता है। ऐसा करने के लिए, src / lib / crypto / krb / crypto_int.h फ़ाइल में उनका विवरण बनाएं।

   
   

    //  ,    ,        ,     krb5_hash_provider   -     : ... struct krb5_hash_provider { char hash_name[32]; //  8 size_t hashsize, blocksize; krb5_error_code (*hash)(const krb5_crypto_iov *data, size_t num_data, krb5_data *output); }; ... extern const struct krb5_hash_provider krb5int_hash_sha384; extern const struct krb5_hash_provider krb5int_hash_stribog256; extern const struct krb5_hash_provider krb5int_hash_stribog512; ... 

   
   

6. हम Stribog और AES बंडल के पहचानकर्ता की घोषणा करेंगे, मैक्रोज़ का परिचय देते हुए कहेंगे कि हम CKSUMTYPE_STRIBOG_256_AES256 , CKSUMTYPE_STRIBOG_512_AES256 , ENCTYPE_AES256_CS_STRIBOG_25 , ENCTY256 को कॉल करेंगे। उन्हें हेडर फ़ाइल टेम्पलेट src / / krb5 / krb5.hin में शामिल किया जाना चाहिए। यह कुछ इस तरह दिखेगा:

   
   

    #define ENCTYPE_ARCFOUR_HMAC_EXP 0x0018 /**< RFC 4757 */ #define ENCTYPE_CAMELLIA128_CTS_CMAC 0x0019 /**< RFC 6803 */ #define ENCTYPE_CAMELLIA256_CTS_CMAC 0x001a /**< RFC 6803 */ #define ENCTYPE_AES256_CTS_STRIBOG_256 0x001b /**< NO RFC */ #define ENCTYPE_AES256_CTS_STRIBOG_512 0x001c /**< NO RFC */ #define ENCTYPE_UNKNOWN 0x01ff ... #define CKSUMTYPE_CMAC_CAMELLIA256 0x0012 /**< RFC 6803 */ #define CKSUMTYPE_MD5_HMAC_ARCFOUR -137 /* Microsoft netlogon */ #define CKSUMTYPE_HMAC_MD5_ARCFOUR -138 /**< RFC 4757 */ #define CKSUMTYPE_STRIBOG_256_AES256 -139 /**< NO RFC */ #define CKSUMTYPE_STRIBOG_512_AES256 -140 /**< NO RFC */ 

   
   

7. अब आपको हैशिंग और एन्क्रिप्शन फ़ंक्शंस के दो बंडलों और एन्क्रिप्शन और हैशिंग फ़ंक्शंस को जोड़ने की आवश्यकता है। दो क्यों, यदि वे समान हैं, तो आप पूछें? उत्तर: मुझे नहीं पता, या यह एक ऐतिहासिक बैसाखी या अनुकूलन का एक तरीका है। फिर भी, आइए आवश्यक फाइलों में नई संरचनाएँ जोड़ें:

   
   

    //   src/lib/crypto/krb/cksumtypes.c          /*   --   --     --       --    --       --       --    "  "   --     --     --   */ const struct krb5_cksumtypes krb5int_cksumtypes_list[] = { ... { CKSUMTYPE_STRIBOG_256_AES256, "stribog-256-aes256", { 0 }, "STRIBOG256 AES256 key", &krb5int_enc_aes256, &krb5int_hash_stribog256, krb5int_etm_checksum, NULL, 64, 32, 0 }, { CKSUMTYPE_STRIBOG_512_AES256, "stribog-512-aes256", { 0 }, "STRIBOG512 AES256 key", &krb5int_enc_aes256, &krb5int_hash_stribog512, krb5int_etm_checksum, NULL, 64, 64, 0 }, }; //   src/lib/crypto/krb/etypes.c         : /*   --   --   --   --   --      --      --           --   ,     --    ,       --    ,       --         --        --    --   */ const struct krb5_keytypes krb5int_enctypes_list[] = { ... { ENCTYPE_AES256_CTS_STRIBOG_256, "aes256-cts-stribog-256", { "aes256-stribog256" }, "AES-256 CTS mode with 256-bit stribog", &krb5int_enc_aes256, &krb5int_hash_stribog256, 16, krb5int_aes2_crypto_length, krb5int_etm_encrypt, krb5int_etm_decrypt, krb5int_aes2_string_to_key, k5_rand2key_direct, krb5int_aes2_prf, CKSUMTYPE_STRIBOG_256_AES256, 0 /*flags*/, 256 }, { ENCTYPE_AES256_CTS_STRIBOG_512, "aes256-cts-stribog-512", { "aes256-stribog512" }, "AES-256 CTS mode with 512-bit stribog", &krb5int_enc_aes256, &krb5int_hash_stribog512, 16, krb5int_aes2_crypto_length, krb5int_etm_encrypt, krb5int_etm_decrypt, krb5int_aes2_string_to_key, k5_rand2key_direct, krb5int_aes2_prf, CKSUMTYPE_STRIBOG_512_AES256, 0 /*flags*/, 256 }, }; 

   
   

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

   
   

    //   src/lib/crypto/openssl/hmac.c    map_digest --    -   .         .  : #include "crypto_int.h" #include "gost_helper.h" #include <openssl/hmac.h> #include <openssl/evp.h> static const EVP_MD * map_digest(const struct krb5_hash_provider *hash) { if (!strncmp(hash->hash_name, "SHA1",4)) return EVP_sha1(); ... else if (!strncmp(hash->hash_name, "GOSTR34.11-2012-256", 19)) return EVP_gostR3411_2012_256(); else if (!strncmp(hash->hash_name, "GOSTR34.11-2012-512", 19)) return EVP_gostR3411_2012_512(); else return NULL; } //   src/lib/crypto/openssl/pbkdf2.c  krb5int_pbkdf2_hmac,        : krb5_error_code krb5int_pbkdf2_hmac(const struct krb5_hash_provider *hash, const krb5_data *out, unsigned long count, const krb5_data *pass, const krb5_data *salt) { const EVP_MD *md = NULL; /* Get the message digest handle corresponding to the hash. */ if (hash == &krb5int_hash_sha1) md = EVP_sha1(); ... else if (hash == &krb5int_hash_stribog256) md = EVP_gostR3411_2012_256(); else if (hash == &krb5int_hash_stribog512) md = EVP_gostR3411_2012_512(); ... return 0; } //   src/lib/krb5/krb/init_ctx.c      ,   : static krb5_enctype default_enctype_list[] = { ... ENCTYPE_AES256_CTS_STRIBOG_256, ENCTYPE_AES256_CTS_STRIBOG_512, 0 }; 

   
   

इन सभी परिवर्तनों के बाद, आप एल्गोरिथ्म के संचालन की जांच कर सकते हैं। हम वह सब कुछ एकत्र करेंगे जो हमने किया है।

 autoconf ./configure --with-crypto-impl=openssl #     openssl make sudo make install 

अब चेक करना शुरू करते हैं। ऐसा करने के लिए, आइए हम उन एल्गोरिदम का जबरन उपयोग करें जिन्हें हमने केर्बरोस कॉन्फ़िगरेशन फ़ाइलों में लागू किया है। निम्नलिखित कार्य करें:

1. रोकें krb5kdc:

   
   

    service krb5-kdc stop 

   
   

2. हम kdc.conf कॉन्फ़िगरेशन फ़ाइल को ठीक करेंगे (मेरे पास /usr/local/var/krb5kdc/kdc.conf है)। नए शुरू किए गए एल्गोरिथ्म का उपयोग करके मजबूर हैशिंग को सेट करें:

   
   

    [realms] AKTIV-TEST.RU = { master_key_type = aes256-stribog512 supported_enctypes = aes256-stribog512:normal default_tgs_enctypes = aes256-stribog512 default_tkt_enctypes = aes256-stribog512 permitted_enctypes = aes256-stribog512 } #       256  

   
   

3. संपूर्ण krb5.conf प्रोटोकॉल की कॉन्फ़िगरेशन फ़ाइल में समान परिवर्तन (I / itc / krb5.conf पर है):

   
   

    [libdefaults] supported_enctypes = aes256-stribog512:normal default_tgs_enctypes = aes256-stribog512 default_tkt_enctypes = aes256-stribog512 permitted_enctypes = aes256-stribog512 #      256  

   
   

4. इसके बाद, krb5kdc चलाएं अगर मास्टर_की बदल जाती है, तो आपको krb5_newrealm का उपयोग करके फिर से प्रिंसिपल डेटाबेस बनाना होगा।

   
   

5. उसके बाद, हम सभी आवश्यक प्रिंसिपल बनाते हैं और आप काम शुरू कर सकते हैं। किनिट के साथ प्रमाणित करने का प्रयास करें।

   
   

6. हम यह सत्यापित करेंगे कि हैशिंग निर्दिष्ट एल्गोरिथम के अनुसार होता है।
   klist -e का उपयोग करना।

   
   

यदि सेवा शुरू नहीं होती है, तो इसे src / kdc / krb5kdc का उपयोग करके रूट के तहत शुरू किया जा सकता है। यदि सब कुछ शुरू हुआ, तो यह सुचारू रूप से चला गया - बधाई! अन्यथा - अफसोस, मैं सभी समस्याओं के लिए एक रामबाण पेशकश नहीं करता हूं, लेकिन केवल एक "छोटे" निर्देश की पेशकश करता हूं जिसमें मूल कदम होते हैं जो आपको करबरोस में नए एल्गोरिदम को लागू करने के लिए लेना होगा। और अगर आपके लिए कुछ भी काम नहीं करता है - जीडीबी उठाएं और देखें कि क्या गलत है। मैं आपको केवल कुछ सुझाव दे सकता हूं:

1. यदि आप इसे पास करते हैं तो आप डिबग मोड में एक प्रोजेक्ट बना सकते हैं ./configure CFLAGS = "-g -O0";
2. krb5kdc को -n फ्लैग का उपयोग करके बैकग्राउंड में लॉन्च किया जा सकता है;
3. मुझे उम्मीद है कि यह इस पर नहीं आया (हालांकि मैं अभी भी असममित एल्गोरिदम के कार्यान्वयन के साथ आया था) - आपको ओपनसेल डीबगिंग प्रतीकों की आवश्यकता हो सकती है - या तो रिपॉजिटरी से उन्हें स्थापित करें या डीबगिंग प्रतीकों के साथ स्रोत से ओपनसेल स्थापित करें;
4. वही गोस्ट इंजन के लिए जाता है।

युक्तियों के इस सेट का विचार आपके लिए "अज्ञात" की तलाश में समय बर्बाद करने से बचाने के लिए पर्याप्त होना चाहिए।

एन्क्रिप्शन एल्गोरिथ्म का कार्यान्वयन

इस खंड में मैं दिखाऊंगा कि कैसे आप केर्बेरोस में अपने स्वयं के डेटा एन्क्रिप्शन एल्गोरिदम को जोड़ सकते हैं, और हम आखिरी खंड में जोड़े गए मैग्मा और स्ट्रीबोग का एक गुच्छा बनाने की कोशिश करेंगे। यहाँ मैं पहले से ही मानता हूँ कि छोटे gost_helper पुस्तकालय को पहले ही अंतिम भाग में जोड़ दिया गया है। ठीक है, अपनी उंगलियों को फैलाएं और आगे बढ़ें:

1. सबसे पहले, हम अपने पुस्तकालय libk5crypto में हेडर फ़ाइल src / lib / crypto / krb / crypto_int.h में उनका वर्णन करके एल्गोरिथ्म का वर्णन करते हैं।

   
   

    ... extern const struct krb5_enc_provider krb5int_enc_camellia256; extern const struct krb5_enc_provider krb5int_enc_gost89; ... 

   
   

2. निर्देशिका में src / lib / crypto / opensl / enc_provider स्रोत gost.c को जोड़ते हैं, जिसमें सभी आवश्यक एल्गोरिदम का कार्यान्वयन होता है (मैंने आधार के रूप में डेस एल्गोरिथम का स्रोत लिया)। यह ध्यान रखना महत्वपूर्ण है कि हम केवल cbc एन्क्रिप्शन मोड को लागू करते हैं, इसलिए स्व-परीक्षण के लिए आप किसी भी अन्य एन्क्रिप्शन मोड को ले सकते हैं और इसे जोड़ सकते हैं:

   
   

    #include "crypto_int.h" #include "gost_helper.h" #include <openssl/evp.h> #define BLOCK_SIZE 8 static krb5_error_code krb5int_gost_encrypt(krb5_key key, const krb5_data *ivec, krb5_crypto_iov *data, size_t num_data) { int ret, olen = BLOCK_SIZE; unsigned char iblock[BLOCK_SIZE], oblock[BLOCK_SIZE]; struct iov_cursor cursor; EVP_CIPHER_CTX *ctx; //          ,   krb5int_gost_encrypt,    : krb5int_init_gost(); ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) return ENOMEM; ret = EVP_EncryptInit_ex(ctx, EVP_get_cipherbynid(NID_gost89_cbc), NULL, key->keyblock.contents, (ivec) ? (unsigned char*)ivec->data : NULL); if (!ret) { EVP_CIPHER_CTX_free(ctx); return KRB5_CRYPTO_INTERNAL; } EVP_CIPHER_CTX_set_padding(ctx,0); k5_iov_cursor_init(&cursor, data, num_data, BLOCK_SIZE, FALSE); while (k5_iov_cursor_get(&cursor, iblock)) { ret = EVP_EncryptUpdate(ctx, oblock, &olen, iblock, BLOCK_SIZE); if (!ret) break; k5_iov_cursor_put(&cursor, oblock); } if (ivec != NULL) memcpy(ivec->data, oblock, BLOCK_SIZE); EVP_CIPHER_CTX_free(ctx); zap(iblock, sizeof(iblock)); zap(oblock, sizeof(oblock)); if (ret != 1) return KRB5_CRYPTO_INTERNAL; return 0; } static krb5_error_code krb5int_gost_decrypt(krb5_key key, const krb5_data *ivec, krb5_crypto_iov *data, size_t num_data) { int ret, olen = BLOCK_SIZE; unsigned char iblock[BLOCK_SIZE], oblock[BLOCK_SIZE]; struct iov_cursor cursor; EVP_CIPHER_CTX *ctx; krb5int_init_gost(); ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) return ENOMEM; ret = EVP_DecryptInit_ex(ctx, EVP_get_cipherbynid(NID_gost89_cbc), NULL, key->keyblock.contents, (ivec) ? (unsigned char*)ivec->data : NULL); if (!ret) { EVP_CIPHER_CTX_free(ctx); return KRB5_CRYPTO_INTERNAL; } EVP_CIPHER_CTX_set_padding(ctx,0); k5_iov_cursor_init(&cursor, data, num_data, BLOCK_SIZE, FALSE); while (k5_iov_cursor_get(&cursor, iblock)) { ret = EVP_DecryptUpdate(ctx, oblock, &olen, (unsigned char *)iblock, BLOCK_SIZE); if (!ret) break; k5_iov_cursor_put(&cursor, oblock); } if (ivec != NULL) memcpy(ivec->data, iblock, BLOCK_SIZE); EVP_CIPHER_CTX_free(ctx); zap(iblock, sizeof(iblock)); zap(oblock, sizeof(oblock)); if (ret != 1) return KRB5_CRYPTO_INTERNAL; return 0; } static krb5_error_code krb5int_gost_init_state (const krb5_keyblock *key, krb5_keyusage usage, krb5_data *state) { state->length = 8; state->data = (void *) malloc(8); if (state->data == NULL) return ENOMEM; memset(state->data, 0, state->length); return 0; } static void krb5int_gost_free_state(krb5_data *state) { free(state->data); *state = empty_data(); } /*   --  ,    -- -       --        --      --      --    cbc-mac checksum,      , ..       --       --         */ const struct krb5_enc_provider krb5int_enc_gost89 = { BLOCK_SIZE, 32, 32, krb5int_gost_encrypt, krb5int_gost_decrypt, NULL, krb5int_gost_init_state, krb5int_gost_free_state }; 

   
   

3. Src / lib / crypto / opensl / enc_provider / Makefile.in टेम्पलेट में, हम संकेत देते हैं कि एक नया स्रोत दिखाई दिया है:

   
   

    STLIBOBJS= \ des.o \ ... gost.o OBJS= \ $(OUTPRE)des.$(OBJEXT) \ ... $(OUTPRE)gost$(OBJEXT) SRCS= \ $(srcdir)/des.c \ ... $(srcdir)/gost.c 

   
   

4. Src / lib / crypto / opensl / enc_provider / deps में निर्भरता निर्दिष्ट करने के बारे में मत भूलना:

   
   

    gost.so gost.po $(OUTPRE)gost.$(OBJEXT): $(BUILDTOP)/include/autoconf.h \ $(BUILDTOP)/include/krb5/krb5.h $(BUILDTOP)/include/osconf.h \ $(BUILDTOP)/include/profile.h $(COM_ERR_DEPS) $(srcdir)/../../krb/crypto_int.h \ $(srcdir)/../crypto_mod.h $(top_srcdir)/include/k5-buf.h \ $(top_srcdir)/include/k5-err.h $(top_srcdir)/include/k5-gmt_mktime.h \ $(top_srcdir)/include/k5-int-pkinit.h $(top_srcdir)/include/k5-int.h \ $(top_srcdir)/include/k5-platform.h $(top_srcdir)/include/k5-plugin.h \ $(top_srcdir)/include/k5-thread.h $(top_srcdir)/include/k5-trace.h \ $(top_srcdir)/include/krb5.h $(top_srcdir)/include/krb5/authdata_plugin.h \ $(top_srcdir)/include/krb5/plugin.h $(top_srcdir)/include/port-sockets.h \ $(top_srcdir)/include/socket-utils.h $(srcdir)/../gost_helper.h gost.c 

   
   

5. बंडल पहचानकर्ताओं को src में शामिल करें / शामिल करें / krb5 / krb5.hin :

   
   

    ... #define ENCTYPE_AES256_CTS_STRIBOG_256 0x001b /**< NO RFC */ #define ENCTYPE_AES256_CTS_STRIBOG_512 0x001c /**< NO RFC */ #define ENCTYPE_GOST89_CBC_STRIBOG_256 0x001d /**< SOME GOST */ #define ENCTYPE_GOST89_CBC_STRIBOG_512 0x001e /**< SOME GOST */ #define ENCTYPE_UNKNOWN 0x01ff ... #define CKSUMTYPE_STRIBOG_256_AES256 -139 /**< NO RFC */ #define CKSUMTYPE_STRIBOG_512_AES256 -140 /**< NO RFC */ #define CKSUMTYPE_STRIBOG_256_GOST89 -141 /**< SOME GOST */ #define CKSUMTYPE_STRIBOG_512_GOST89 -142 /**< SOME GOST */ 

   
   

6. आइए हम हैश और एन्क्रिप्शन फ़ंक्शन बंडलों की संरचना का वर्णन करें, जैसा कि अंतिम खंड में है:

   
   

    // src/lib/crypto/krb/cksumtypes.c const struct krb5_cksumtypes krb5int_cksumtypes_list[] = { ... { CKSUMTYPE_STRIBOG_256_GOST89, "stribog-256-gost89", { 0 }, "STRIBOG256 GOST89 key", &krb5int_enc_gost89, &krb5int_hash_stribog256, krb5int_dk_checksum, NULL, 64, 32, 0 }, { CKSUMTYPE_STRIBOG_512_GOST89, "stribog-512-gost89", { 0 }, "STRIBOG512 GOST89 key", &krb5int_enc_gost89, &krb5int_hash_stribog512, krb5int_dk_checksum, NULL, 64, 64, 0 }, }; // src/lib/crypto/krb/etypes.c //       ,         , ,      aes const struct krb5_keytypes krb5int_enctypes_list[] = { ... { ENCTYPE_GOST89_CBC_STRIBOG_256, "gost89-cbc-stribog-256", { "gost89-stribog256" }, "GOST 28147-89 CBC mode with 256-bit stribog", &krb5int_enc_gost89, &krb5int_hash_stribog256, 16, krb5int_dk_crypto_length, krb5int_dk_encrypt, krb5int_dk_decrypt, krb5int_dk_string_to_key, k5_rand2key_direct, krb5int_dk_prf, CKSUMTYPE_STRIBOG_256_GOST89, 0 /*flags*/, 256 }, { ENCTYPE_GOST89_CBC_STRIBOG_512, "gost89-cbc-stribog-512", { "gost89-stribog512" }, "GOST 28147-89 CBC mode with 512-bit stribog", &krb5int_enc_gost89, &krb5int_hash_stribog512, 16, krb5int_dk_crypto_length, krb5int_dk_encrypt, krb5int_dk_decrypt, krb5int_dk_string_to_key, k5_rand2key_direct, krb5int_dk_prf, CKSUMTYPE_STRIBOG_512_GOST89, 0 /*flags*/, 256 }, }; 

   
   

7. डिफ़ॉल्ट एन्क्रिप्शन मोड की सूची में जोड़ें src / lib / krb5 / krb / init_ctx.c फ़ाइल :

   
   

    static krb5_enctype default_enctype_list[] = { ... ENCTYPE_AES256_CTS_STRIBOG_256, ENCTYPE_AES256_CTS_STRIBOG_512, ENCTYPE_GOST89_CBC_STRIBOG_256, ENCTYPE_GOST89_CBC_STRIBOG_512, 0 }; 

   
   

इन जोड़तोड़ के बाद, आप नए पेश किए गए एल्गोरिदम का परीक्षण करने का प्रयास कर सकते हैं। परीक्षण अंतिम अनुभाग की तरह ही होता है। बंडल का नाम एक उपनाम के रूप में लिया जा सकता है (उदाहरण के लिए, gost89-stribog512) या स्वयं एल्गोरिथ्म के नाम का उपयोग करके (उदाहरण के लिए, gost89-cbc-stribog-512)। मुझे उम्मीद है कि सब कुछ काम करता है, अन्यथा जो मैंने पहले कहा था उसके बारे में मत भूलना।

एक डिजिटल हस्ताक्षर एल्गोरिथ्म जोड़ना

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

असममित एन्क्रिप्शन एक बहुत भारी चीज है। – : , - . ...

, . , , . . . . , . , . , , — . .

कुछ इस तरह। , , . : . , , , , , .

openssl ( )

, -, openssl rtengine. GOST, , .

1. SDK rutoken sdk/openssl/rtengine/bin/ engine.

   
   

2. librtpkcs11ecp.so.

   
   

3. master OpenSC 8cf1e6f

   
   

4. , openssl.cnf:

   
   

    #     openssl_conf = openssl_def ... #    # OpenSSL default section [openssl_def] engines = engine_section # Engine section [engine_section] gost = gost_section rtengine = rtengine_section # Engine gost section [gost_section] engine_id = gost dynamic_path = /usr/lib/x86_64-linux-gnu/engines-1.1/gost.so default_algorithms = ALL # Engine rtengine section [rtengine_section] engine_id = rtengine dynamic_path = /path/to/engine/librtengine.so MODULE_PATH = /path/to/module/librtpkcs11ecp.so RAND_TOKEN = pkcs11:manufacturer=Aktiv%20Co.;model=Rutoken%20ECP default_algorithms = CIPHERS, DIGEST, PKEY, RAND 

   
   

engine .

, KDC

kerberos . , .

1. , , , KDC:

   
   

    openssl genpkey -engine gost -algorithm gost2012_256 -pkeyopt paramset:B -out CA_key.pem #    openssl req -engine gost -key CA_key.pem -new -x509 -out CA_cert.pem #    openssl genpkey -engine gost -algorithm gost2012_256 -pkeyopt paramset:B -out KDC_key.pem #   KDC openssl req -engine gost -new -out KDC.req -key ./KDC_key.pem #      KDC # !!!     pkinit_extensions    REALM=AKTIV-TEST.RU; export REALM #   KDC CLIENT=127.0.0.1; export CLIENT #   ,     (    KDC).    ,   localhost openssl x509 -engine gost -req -in ./KDC.req -CAkey ./CA_key.pem -CA ./CA_cert.pem -out ./KDC.pem -extfile ./pkinit_extensions -extensions kdc_cert -CAcreateserial #    KDC. sudo cp ./KDC.pem ./KDC_key.pem ./CA_cert.pem /var/lib/krb5kdc #        kdc. 

   
   

2. kdc, , :

   
   

    [kdcdefaults] ... pkinit_identity = FILE:/var/lib/krb5kdc/KDC.pem,/var/lib/krb5kdc/KDC_key.pem pkinit_anchors = FILE:/var/lib/krb5kdc/CA_cert.pem 

   
   

[libdefaults]
spake_preauth_groups = edwards25519

 3.      : ```bash sudo kadmin.local kadmin.local$: modprinc +requires_preauth user 

1. . , , : :

   
   

   1. , KDC:

      
      

       openssl genpkey -engine gost -algorithm gost2012_256 -pkeyopt paramset:B -out client_key.pem #    openssl req -engine gost -new -out client.req -key ./client_key.pem #       

      
      

   2. :

      
      

       pkcs11-tool --module /path/to/module/librtpkcs11ecp.so --keypairgen --key-type GOSTR3410-2012-256:B -l --id 45 #             id=45 openssl req -engine rtengine -new -key="pkcs11:id=E" -keyform engine -out client.req #         . E -- ascii  45 

      
      
   
   

2. :

   
   

    REALM=AKTIV-TEST.RU; export REALM #   CLIENT=user; export CLIENT #  ,     openssl x509 -engine gost -CAkey ./CA_key.pem -CA ./CA_cert.pem -req -in ./client.req -extensions client_cert -extfile ./pkinit_extensions -out client.pem openssl x509 -engine gost -in client.pem -out client.crt -outform DER #     PEM   CRT 

   
   

3. : , – :

   
   

    sudo cp ./client_key.pem client.pem /etc/krb5 #   pkcs11-tool --module /usr/lib/librtpkcs11ecp.so -l -y cert -w ./client.crt --id 45 #   (     id,   ) 

   
   

4. ( /etc/krb5.conf):

   
   

    [libdefaults] ... pkinit_anchors = FILE:/var/lib/krb5kdc/CA_cert.pem #     pkinit_identities = FILE:/etc/krb5/client.pem,/etc/krb5/client_key.pem #     #pkinit_identities = PKCS11:/usr/lib/librtpkcs11ecp.so 

   
   

, . ! .

, – - 2 ! src/plugins/preauth/pkinit/pkcs11.h src/plugins/preauth/pkinit/pkinit_crypto_openssl.c

1. pkcs11.h . – , , . ( ). sdk/pkcs11/include/rtpkcs11t.h . :

   
   

    ... #define CKK_TWOFISH (0x21) #define CKK_GOSTR3410 (0x30) #define CKK_GOSTR3411 (0x31) #define CKK_GOST28147 (0x32) #define CKK_VENDOR_DEFINED (1UL << 31) // A mask for new GOST algorithms. // For details visit https://tc26.ru/standarts/perevody/guidelines-the-pkcs-11-extensions-for-implementing-the-gost-r-34-10-2012-and-gost-r-34-11-2012-russian-standards-.html #define NSSCK_VENDOR_PKCS11_RU_TEAM (CKK_VENDOR_DEFINED | 0x54321000) #define CK_VENDOR_PKCS11_RU_TEAM_TK26 NSSCK_VENDOR_PKCS11_RU_TEAM #define CKK_GOSTR3410_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x003) ... #define CKM_AES_MAC_GENERAL (0x1084) #define CKM_AES_CBC_PAD (0x1085) #define CKM_GOSTR3410_KEY_PAIR_GEN (0x1200UL) #define CKM_GOSTR3410 (0x1201UL) #define CKM_GOSTR3410_WITH_GOSTR3411 (0x1202UL) #define CKM_GOSTR3410_KEY_WRAP (0x1203UL) #define CKM_GOSTR3410_DERIVE (0x1204UL) #define CKM_GOSTR3410_512_KEY_PAIR_GEN (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x005) #define CKM_GOSTR3410_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x006) #define CKM_GOSTR3410_12_DERIVE (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x007) #define CKM_GOSTR3410_WITH_GOSTR3411_12_256 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x008) #define CKM_GOSTR3410_WITH_GOSTR3411_12_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x009) #define CKM_GOSTR3411 (0x1210UL) #define CKM_GOSTR3411_HMAC (0x1211UL) #define CKM_GOSTR3411_12_256 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x012) #define CKM_GOSTR3411_12_512 (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x013) #define CKM_GOSTR3411_12_256_HMAC (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x014) #define CKM_GOSTR3411_12_512_HMAC (CK_VENDOR_PKCS11_RU_TEAM_TK26 | 0x015) #define CKM_GOST28147_KEY_GEN (0x1220UL) #define CKM_GOST28147_ECB (0x1221UL) #define CKM_GOST28147 (0x1222UL) #define CKM_GOST28147_MAC (0x1223UL) #define CKM_GOST28147_KEY_WRAP (0x1224UL) 

   
   

   , .

   
   

2. pkinit_crypto_openssl.c , , . get_key, .. - :

   
   

    #include <dirent.h> #include <arpa/inet.h> #include <openssl/engine.h> static ENGINE *eng = NULL; krb5int_init_engines() { if (eng) return; OPENSSL_add_all_algorithms_conf(); ERR_load_crypto_strings(); if (!(eng = ENGINE_by_id("rtengine"))) { printf("Engine rtengine doesn't exist"); return; } ENGINE_init(eng); ENGINE_set_default(eng, ENGINE_METHOD_ALL); if (!(eng = ENGINE_by_id("gost"))) { printf("Engine gost doesn't exist"); return; } ENGINE_init(eng); ENGINE_set_default(eng, ENGINE_METHOD_ALL); } ... get_key(krb5_context context, pkinit_identity_crypto_context id_cryptoctx, char *filename, const char *fsname, EVP_PKEY **retkey, const char *password) { ... krb5_error_code retval; krb5int_init_engines(); ... } ... int pkinit_openssl_init() { /* Initialize OpenSSL. */ ERR_load_crypto_strings(); OpenSSL_add_all_algorithms(); krb5int_init_engines(); return 0; } 

   
   

3. . – RSA , sha1. , . , , . , .. RSA :

   
   

    //       krb5_error_code pkinit_find_private_key(pkinit_identity_crypto_context id_cryptoctx, CK_ATTRIBUTE_TYPE usage, CK_OBJECT_HANDLE *objp) { ... true_false = TRUE; attrs[nattrs].type = usage; attrs[nattrs].pValue = &true_false; attrs[nattrs].ulValueLen = sizeof true_false; nattrs++; #endif // keytype = CKK_RSA; // attrs[nattrs].type = CKA_KEY_TYPE; // attrs[nattrs].pValue = &keytype; // attrs[nattrs].ulValueLen = sizeof keytype; // nattrs++; ... } //             : static int ckk_key_to_nid(CK_KEY_TYPE type) { switch(type){ case CKK_GOSTR3410: return NID_id_GostR3410_2012_256; case CKK_GOSTR3410_512: return NID_id_GostR3410_2012_512; default: return NID_rsa; } } // ,     ,     : static int pkinit_get_pkey_type(krb5_context context, pkinit_identity_crypto_context id_cryptoctx) { CK_OBJECT_HANDLE obj; CK_ATTRIBUTE attrs[1]; CK_KEY_TYPE key_type; int r; //  : if (pkinit_open_session(context, id_cryptoctx)) { pkiDebug("can't open pkcs11 session\n"); return NID_rsa; } //   : if (pkinit_find_private_key(id_cryptoctx, CKA_SIGN, &obj)) { return NID_rsa; } //   : attrs[0].type = CKA_KEY_TYPE; attrs[0].pValue = &key_type; attrs[0].ulValueLen = sizeof (key_type); if ((r = id_cryptoctx->p11->C_GetAttributeValue(id_cryptoctx->session, obj, attrs, 1)) != CKR_OK) { pkiDebug("C_GetAttributeValue: %s\n Used RSA\n", pkinit_pkcs11_code_to_text(r)); return NID_rsa; } //   : return ckk_key_to_nid(key_type); } // ,        ,     : static int pkey_to_digest_nid(const EVP_PKEY* const pkey) { switch (EVP_PKEY_id(pkey)) { case NID_id_GostR3410_2012_256: return NID_id_GostR3411_2012_256; case NID_id_GostR3410_2012_512: return NID_id_GostR3411_2012_512; case NID_id_GostR3410_2001: return NID_id_GostR3411_2012_256; default: return NID_sha1; } } // ,       : static int get_digest_nid(krb5_context context, const pkinit_identity_crypto_context id_cryptctx) { int nid; //    (   ),   NID ,    if (id_cryptctx->my_key) { nid = EVP_PKEY_id(id_cryptctx->my_key); } else { nid = pkinit_get_pkey_type(context, id_cryptctx); } switch (nid) { case NID_id_GostR3410_2012_256: return NID_id_GostR3411_2012_256; case NID_id_GostR3410_2012_512: return NID_id_GostR3411_2012_512; case NID_id_GostR3410_2001: return NID_id_GostR3411_2012_256; default: return NID_sha1; } } // ,     : static int get_alg_nid(krb5_context context, const pkinit_identity_crypto_context id_cryptctx) { int nid; if (id_cryptctx->my_key) { nid = EVP_PKEY_id(id_cryptctx->my_key); } else { nid = pkinit_get_pkey_type(context, id_cryptctx); } switch (nid) { case NID_id_GostR3410_2012_256: return NID_id_tc26_signwithdigest_gost3410_2012_256; case NID_id_GostR3410_2012_512: return NID_id_tc26_signwithdigest_gost3410_2012_512; case NID_id_GostR3410_2001: return NID_id_tc26_signwithdigest_gost3410_2012_256; default: return NID_sha1WithRSAEncryption; } } //    : static CK_MECHANISM_TYPE get_mech_type(krb5_context context, const pkinit_identity_crypto_context id_cryptctx) { int nid; if (id_cryptctx->my_key) { nid = EVP_PKEY_id(id_cryptctx->my_key); } else { nid = pkinit_get_pkey_type(context, id_cryptctx); } switch (nid) { case NID_id_GostR3410_2012_256: return CKM_GOSTR3410_WITH_GOSTR3411_12_256; case NID_id_GostR3410_2012_512: return CKM_GOSTR3410_WITH_GOSTR3411_12_512; case NID_id_GostR3410_2001: return CKM_GOSTR3410_WITH_GOSTR3411_12_256; default: return CKM_RSA_PKCS; } } 

   
   

4. cms_signeddata_create create_signature :

   
   

    krb5_error_code cms_signeddata_create(krb5_context context, pkinit_plg_crypto_context plg_cryptoctx, pkinit_req_crypto_context req_cryptoctx, pkinit_identity_crypto_context id_cryptoctx, int cms_msg_type, int include_certchain, unsigned char *data, unsigned int data_len, unsigned char **signed_data, unsigned int *signed_data_len) { ... /* Set digest algs */ p7si->digest_alg->algorithm = OBJ_nid2obj( get_digest_nid(context, id_cryptoctx)); ... p7si->digest_enc_alg->algorithm = OBJ_nid2obj(get_alg_nid(context, id_cryptoctx)); ... EVP_DigestInit_ex(ctx, EVP_get_digestbynid(get_digest_nid(context, id_cryptoctx)), NULL); ... alen = (unsigned int )ASN1_item_i2d((ASN1_VALUE *) sk, &abuf, ASN1_ITEM_rptr(PKCS7_ATTR_SIGN)); ... //   ,      (    ): if (id_cryptoctx->pkcs11_method == 1 && get_digest_nid(context, id_cryptoctx) == NID_sha1) { } static krb5_error_code create_signature(unsigned char **sig, unsigned int *sig_len, unsigned char *data, unsigned int data_len, EVP_PKEY *pkey) { ... EVP_SignInit(ctx, EVP_get_digestbynid(pkey_to_digest_nid(pkey))); ... } //       : static krb5_error_code pkinit_sign_data_pkcs11(krb5_context context, pkinit_identity_crypto_context id_cryptoctx, unsigned char *data, unsigned int data_len, unsigned char **sig, unsigned int *sig_len) { ... mech.mechanism = get_mech_type(context, id_cryptoctx); mech.pParameter = NULL; mech.ulParameterLen = 0; ... } 

   
   

, ( , , ):

 sudo kinit user 

user, , .

, .