👏 👸🏿 🏺 स्क्रिप्टिंग भाषाओं में PKCS # 11 क्रिप्टोग्राफ़िक टोकन तंत्र का उपयोग करना 🧝 ⚙️ 🌒

"रूसी योग्य x509 प्रमाण पत्र देखने के लिए एक अंग्रेजी बोलने वाले क्रॉस-प्लेटफॉर्म उपयोगिता" लेख पर अपनी टिप्पणी में, पास ने पीकेसीएस # 11 टोकन को बहुत सही ढंग से नोट किया कि वे "सभी खुद को गिन सकते हैं।" हां, टोकन वास्तव में क्रिप्टोग्राफिक कंप्यूटर हैं। और इन कंप्यूटरों को स्क्रिप्टिंग भाषाओं में उपयोग करना चाहते हैं, यह पायथन, पर्ल या रूबी होना चाहिए। हमने पहले ही किसी तरह से PKCS # 11 टोकन के उपयोग को प्रमाण पत्र अनुरोध बनाने के लिए दस्तावेजों पर हस्ताक्षर करने और एन्क्रिप्ट करने के लिए पायथन में रूसी क्रिप्टोग्राफी के समर्थन के साथ माना है:

यहाँ हम Tcl भाषा के बारे में चर्चा जारी रखते हैं। पिछले लेख में , जब हमने PKCS # 11 टोकन / स्मार्ट कार्ड पर संग्रहीत प्रमाणपत्रों को देखने और मान्य करने पर ध्यान दिया, तो हमने उन्हें (प्रमाणपत्र) तक पहुंचने के लिए TclPKCS11 संस्करण 0.9.9 पैकेज का उपयोग किया। जैसा कि पहले ही उल्लेख किया गया है, दुर्भाग्य से, पैकेज को आरएसए क्रिप्टोग्राफी के लिए विकसित किया गया था और पीकेसीएस # 11 v.2.20 मानक को ध्यान में रखते हुए। आज, PKCS # 11 v.2.40 मानक पहले से ही उपयोग किया जाता है और यह क्रिप्टोग्राफी टीके -26 की तकनीकी समिति है, जिसे इसके द्वारा निर्देशित किया जाता है, रूसी क्रिप्टोग्राफी का समर्थन करने वाले टोकन / स्मार्टकार्ड के घरेलू निर्माताओं के लिए सिफारिशें जारी करता है। और इस सब के साथ, एक नया पैकेज TclPKCS11 संस्करण 1.0.1 दिखाई दिया है । हम तुरंत एक आरक्षण करेंगे कि TclPKCS11 v.10.1 पैकेज के नए संस्करण में RSA के लिए सभी क्रिप्टोग्राफ़िक इंटरफेस सहेजे गए हैं। पैकेज लाइब्रेरी C भाषा में लिखी गई है।

तो, पैकेज में नया क्या है? सबसे पहले, एक कमांड जोड़ा गया था जो आपको जुड़े हुए टोकन द्वारा समर्थित क्रिप्टोग्राफिक तंत्र की एक सूची प्राप्त करने की अनुमति देता है:

::pki::pkcs11::listmechs <handl> <slotid>

कनेक्टेड टोकन के साथ स्लॉट की एक सूची कैसे प्राप्त करें, यहां दिखाया गया है (प्रक्रिया - proc :: स्लॉट_with_token):

 proc ::slots_with_token {handle} { set slots [pki::pkcs11::listslots $handle] # puts "Slots: $slots" array set listtok [] foreach slotinfo $slots { set slotid [lindex $slotinfo 0] set slotlabel [lindex $slotinfo 1] set slotflags [lindex $slotinfo 2] if {[lsearch -exact $slotflags TOKEN_PRESENT] != -1} { set listtok($slotid) $slotlabel } } #     parray listtok return [array get listtok] }

एक साधारण स्क्रिप्ट लें:

 #!/usr/bin/tclsh lappend auto_path . package require pki::pkcs11 #      RuToken set lib "/usr/local/lib64/librtpkcs11ecp_2.0.so" <source lang="bash">set handle [pki::pkcs11::loadmodule $lib] #    #       set labslot [::slots_with_token $handle] if {[llength $labslot] == 0} { puts "     " exit } set slotid 0 set lmech [pki::pkcs11::listmechs $handle $slotid] set i 0 foreach mm $lmech { #   if {[string first "GOSTR3410" $mm] != -1} { puts -nonewline "[lindex $mm 0] " if {$i == 2} {puts "";set i 0} else { incr i} } } puts "\n" exit

यह स्क्रिप्ट आपको RuToken परिवार के टोकन पर समर्थित GOSTR3410 क्रिप्टोग्राफी तंत्र की एक सूची प्राप्त करने की अनुमति देती है। शुरू करने के लिए, आइए, जैसा कि पास ने लेख में लिखा है, "सभी प्रकार के ईडीओ द्वारा रुतोकन हल्का प्रिय":

 $ tclsh TEST_for_HABR.tcl listtok(0) = ruToken Lite 0 {ruToken Lite } $

और स्वाभाविक रूप से यह पता चलता है कि वह किसी भी GOST mezanism का समर्थन नहीं करता है, जिसे साबित किया जाना था। हम एक और टोकन रॉटोकन ईडीएस लेते हैं:

 $ tclsh TEST_for_HABR.tcl listtok(0) = ruToken ECP } 0 {ruToken ECP } CKM_GOSTR3410_KEY_PAIR_GEN CKM_GOSTR3410 CKM_GOSTR3410_DERIVE CKM_GOSTR3410_WITH_GOSTR3411 $

हां, यह टोकन रूसी क्रिप्टोग्राफी का समर्थन करता है, लेकिन केवल GOST R 34.10-2001 के हस्ताक्षर हैं, जो लगभग उपयोग से बाहर है । लेकिन अगर आप रुतोकन ईडीएस-2.0 टोकन लेते हैं, तो सबकुछ ठीक हो जाएगा, यह GOST R 34.10-2012 की कुंजियों के साथ 256 और 512 बिट लंबा का समर्थन करता है:

 $ tclsh TEST_for_HABR.tcl listtok(0) = RuTokenECP20 0 {RuTokenECP20 } CKM_GOSTR3410_KEY_PAIR_GEN CKM_GOSTR3410 CKM_GOSTR3410_DERIVE CKM_GOSTR3410_512_KEY_PAIR_GEN CKM_GOSTR3410_512 CKM_GOSTR3410_12_DERIVE CKM_GOSTR3410_WITH_GOSTR3411 CKM_GOSTR3410_WITH_GOSTR3411_12_256 CKM_GOS TR3410_WITH_GOSTR3411_12_512 $

यदि हमने रूसी क्रिप्टोग्राफी का समर्थन करने के बारे में बात की, जिसमें टिड्डे और मैग्मा एन्क्रिप्शन एल्गोरिदम शामिल हैं, एक या दूसरे टोकन के साथ, तो यह सॉफ्टवेयर और क्लाउड टोकन द्वारा पूरी तरह से समर्थित है और यह स्वाभाविक है:

 $ tclsh TEST_for_HABR.tcl listtok(0) = LS11SW2016_LIN_64 0 {LS11SW2016_LIN_64 }

तंत्र की सूची

CKM_GOSTR3410_KEY_PAIR_GEN
CKM_GOSTR3410_512_KEY_PAIR_GEN
CKM_GOSTR3410
CKM_GOSTR3410_512
CKM_GOSTR3410_WITH_GOSTR3411
CKM_GOSTR3410_WITH_GOSTR3411_12_256
CKM_GOSTR3410_WITH_GOSTR3411_12_512
CKM_GOSTR3410_DERIVE
CKM_GOSTR3410_12_DERIVE
CKM_GOSR3410_2012_VKO_256
CKM_GOSR3410_2012_VKO_512
CKM_KDF_4357
CKM_KDF_GOSTR3411_2012_256
CKM_KDF_TREE_GOSTR3411_2012_256
CKM_GOSTR3410_KEY_WRAP
CKM_GOSTR3410_PUBLIC_KEY_DERIVE
CKM_LISSI_GOSTR3410_PUBLIC_KEY_DERIVE
CKM_GOST_GENERIC_SECRET_KEY_GEN
CKM_GOST_CIPHER_KEY_GEN
CKM_GOST_CIPHER_ECB
CKM_GOST_CIPHER_CBC
CKM_GOST_CIPHER_CTR
CKM_GOST_CIPHER_OFB
CKM_GOST_CIPHER_CFB
CKM_GOST_CIPHER_OMAC
CKM_GOST_CIPHER_KEY_WRAP
CKM_GOST_CIPHER_ACPKM_CTR
CKM_GOST_CIPHER_ACPKM_OMAC
CKM_GOST28147_KEY_GEN
CKM_GOST28147
CKM_GOST28147_KEY_WRAP
CKM_GOST28147_PKCS8_KEY_WRAP
CKM_GOST_CIPHER_PKCS8_KEY_WRAP
CKM_GOST28147_ECB
CKM_GOST28147_CNT
CKM_GOST28147_MAC
CKM_KUZNYECHIK_KEY_GEN
CKM_KUZNYECHIK_ECB
CKM_KUZNYECHIK_CBC
CKM_KUZNYECHIK_CTR
CKM_KUZNYECHIK_OFB
CKM_KUZNYECHIK_CFB
CKM_KUZNYECHIK_OMAC
CKM_KUZNYECHIK_KEY_WRAP
CKM_KUZNYECHIK_ACPKM_CTR
CKM_KUZNYECHIK_ACPKM_OMAC
CKM_MAGMA_KEY_GEN
CKM_MAGMA_ECB
CKM_MAGMA_CBC
CKM_MAGMA_CTR
CKM_MAGMA_OFB
CKM_MAGMA_CFB
CKM_MAGMA_OMAC
CKM_MAGMA_KEY_WRAP
CKM_MAGMA_ACPKM_CTR
CKM_MAGMA_ACPKM_OMAC
CKM_GOSTR3411
CKM_GOSTR3411_12_256
CKM_GOSTR3411_12_512
CKM_GOSTR3411_HMAC
CKM_GOSTR3411_12_256_HMAC
CKM_GOSTR3411_12_512_HMAC
CKM_PKCS5_PBKD2
CKM_PBA_GOSTR3411_WITH_GOSTR3411_HMAC
CKM_TLS_GOST_KEY_AND_MAC_DERIVE
CKM_TLS_GOST_PRE_MASTER_KEY_GEN
CKM_TLS_GOST_MASTER_KEY_DERIVE
CKM_TLS_GOST_PRF
CKM_TLS_GOST_PRF_2012_256
CKM_TLS_GOST_PRF_2012_512
CKM_TLS12_MASTER_KEY_DERIVE
CKM_TLS12_KEY_AND_MAC_DERIVE
CKM_TLS_MAC
CKM_TLS_KDF
CKM_TLS_TREE_GOSTR3411_2012_256
CKM_EXTRACT_KEY_FROM_KEY
CKM_SHA_1
CKM_MD5

हम पैकेज में जोड़े गए अगले नए फ़ीचर की ओर बढ़ते हैं:

 set listcertsder [pki::pkcs11::listcertsder $handle $slotid]

यह फ़ंक्शन बिना टोकन द्वारा संग्रहीत प्रमाणपत्रों की सूची लौटाता है। सवाल स्वाभाविक रूप से उठता है, लेकिन यह मौजूदा फ़ंक्शन pki :: pkcs11 :: listcerts से कैसे भिन्न होता है?

सबसे पहले, नया फ़ंक्शन :: pki पैकेज का उपयोग नहीं करता है। लौटाए गए तत्वों में से एक cert_der तत्व है, जिसमें पूर्ण प्रमाणपत्र शामिल है। यह सुविधाजनक है, उदाहरण के लिए, जब कोई प्रमाणपत्र निर्यात करता है, या उसका फिंगरप्रिंट प्राप्त करता है। पहले, मुझे tbs प्रमाणपत्र और उसके हस्ताक्षर से पूर्ण प्रमाण पत्र एकत्र करना था। एक प्रमाण पत्र की सामग्री को प्रिंट करते समय प्रत्येक प्रमाण पत्र के लिए लौटी वस्तुओं की पूरी सूची स्पष्ट रूप से दिखाई देती है:

 . . . array set derc [[pki::pkcs11::listcertsder $handle $slotid] 0] parray derc derc(cert_der) = 3082064a … derc(pkcs11_handle) = pkcsmod0 derc(pkcs11_id) = 5882d64386211cf3a8367d2f87659f9330e5605d derc(pkcs11_label) = Thenderbird-60   derc(pkcs11_slotid) = 0 derc(type) = pkcs11 . . .

Pkcs11_id तत्व सार्वजनिक कुंजी से SHA-1 हैश का मान CKA_ID विशेषता को संग्रहीत करता है। Cert_der तत्व प्रमाणपत्र का CKA_VALUE है, pkcs11_label CKA_LABEL है।

Pkcs11_id तत्व (PKCS # 11 मानक की शब्दावली में CKA_ID), pkcs11_handle लाइब्रेरी के साथ, और pkcs11_slotid के साथ स्लॉट पहचानकर्ता टोकन पर संग्रहीत कुंजी और प्रमाणपत्र तक पहुंचने के लिए एक प्रमुख तत्व को टोकन करता है।

इसलिए, यदि हम प्रमाणपत्र या कुंजियों के लेबल (pkcs11_label) को बदलना चाहते हैं, तो हम फ़ॉर्म की एक कमांड निष्पादित करते हैं:

 pki::pkcs11::rname <cert|key|all> <  >

किसी प्रमाणपत्र या कुंजी को टोकन से निकालने के लिए, प्रपत्र की एक कमांड निष्पादित की जाती है:

 pki::pkcs11::delete <cert|key|all> <  >

प्रमुख तत्वों की सूची निम्नानुसार बनाई जा सकती है:

 set listparam {} lappend listparam pkcs11_handle lappend listparam $handle lappend listparam pkcs11_slotid lappend listparam $pkcs11_slotid lappend listparam pkcs11_id lappend listparam $pkcs11_id

आदि
इस मामले में फ़ंक्शन कॉल इस तरह दिखता है (हम प्रमाण पत्र और उससे जुड़ी कुंजियों को हटा देंगे):

 pki::pkcs11::delete all $listparam

पाठक शायद पहले से ही अनुमान लगा चुके हैं कि इस सूची को एक डिक्शनरी के रूप में व्यवस्थित किया जा सकता है:

 set listparam [dict create pkcs11_handle $pkcs11_handle] dict set listparam pkcs11_slotid $pkcs11_slotid) dict set listparam pkcs11_id $pkcs11_id

अन्य तरीके हैं, उदाहरण के लिए, एक सरणी के माध्यम से।

एक बार फिर, हम ध्यान दें कि pkcs11_handle और pkcs11_slotid तत्वों को हमेशा प्रमुख तत्वों की सूची में मौजूद होना चाहिए, जो विशिष्ट रूप से जुड़े हुए टोकन की पहचान करते हैं। शेष रचना एक विशिष्ट कार्य द्वारा निर्धारित की जाती है।

टोकन पर प्रमाणपत्र स्थापित करने के लिए निम्न फ़ंक्शन का उपयोग किया जाता है:

 set pkcs11_id_cert [::pki::pkcs11::importcert <cert_der_hex> <  >

फ़ंक्शन हेक्साडेसिमल में CKA_ID मान लौटाता है। मुख्य मापदंडों की सूची टोकन को निर्धारित करती है जिस पर प्रमाण पत्र स्थित होगा:

 {pkcs11_handle <handle> pkcs11_slotid <slotid>}

आगे हमारी हैश गणना है। रूसी क्रिप्टोग्राफी में आज तीन प्रकार के हैश कार्यों का उपयोग किया जाता है:
- GOST R 34.11-94
- GOST R 34 .11-2012 256 बिट के हैश मान (stribog256) के साथ
- GOST R 34 .11-2012 512 बिट्स का हैश मान (stribog512)
यह निर्धारित करने के लिए कि कौन सा हैश टोकन का समर्थन करता है, हमारे पास फ़ंक्शन pki :: pkcs11 :: listmechs है।

हैश गणना फ़ंक्शन का निम्न रूप है:

 set <> [pki::pkcs11::digest <gostr3411|stribog256|stribog512|sha1> <  > <  >]

ध्यान दें कि गणना का परिणाम हेक्साडेसिमल में प्रस्तुत किया गया है:

 . . . set listparam [dict create pkcs11_handle $pkcs11_handle] dict set listparam pkcs11_slotid $pkcs11_slotid set res_hex [pki::pkcs11::digest stribog256 0123456789 $listparam] puts $res_hex 086f2776f33aae96b9a616416b9d1fe9a049951d766709dbe00888852c9cc021

सत्यापन के लिए, आइए रूसी क्रिप्टोग्राफी के समर्थन के साथ खुलता है :

 $ echo -n "0123456789"|/usr/local/lirssl_csp_64/bin/lirssl_s tatic dgst -md_gost12_256 (stdin)= 086f2776f33aae96b9a616416b9d1fe9a0499 51d766709dbe00888852c9 cc021 $

जैसा कि आप देख सकते हैं, परिणाम समान है।

इलेक्ट्रॉनिक हस्ताक्षर को सत्यापित करने के लिए, चाहे वह प्रमाणपत्र हो या निरस्त प्रमाण पत्र की सूची हो या प्रारूप में हस्ताक्षरित दस्तावेज हो, हमें अब केवल हस्ताक्षर सत्यापन समारोह की आवश्यकता है:

 set result [pki::pkcs11::verify < > < > <  >]]

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

lpkar (pkcs11_handle) = pkcsmod0
lpkar (pkcs11_slotid) = 0
lpkar (pubkeyinfo) = 301f06082a850307010101010101306072a85030202040
006082a8503070101020203430004407d9306687af5a8e63af4b09443ed2e03794be
10eba6627bf5fb3da1bb474a3507d2ce2cd24b63c727a02521897d1dd6edbdc7084d
8886a39289c3f81bdf2e179

ASN1 सार्वजनिक कुंजी संरचना हस्ताक्षर प्रमाणपत्र से ली गई है:

 proc ::pki::x509::parse_cert_pubkeyinfo {cert_hex} { array set ret [list] set wholething [binary format H* $cert_hex] ::asn::asnGetSequence wholething cert ::asn::asnPeekByte cert peek_tag if {$peek_tag != 0x02} { # Version number is optional, if missing assumed to be value of 0 ::asn::asnGetContext cert - asn_version ::asn::asnGetInteger asn_version ret(version) } ::asn::asnGetBigInteger cert ret(serial_number) ::asn::asnGetSequence cert data_signature_algo_seq ::asn::asnGetObjectIdentifier data_signature_algo_seq ret(data_signature_algo) ::asn::asnGetSequence cert issuer ::asn::asnGetSequence cert validity ::asn::asnGetUTCTime validity ret(notBefore) ::asn::asnGetUTCTime validity ret(notAfter) ::asn::asnGetSequence cert subject ::asn::asnGetSequence cert pubkeyinfo binary scan $pubkeyinfo H* ret(pubkeyinfo) return $ret(pubkeyinfo) }

किसी फ़ाइल से प्रमाणपत्रों के इलेक्ट्रॉनिक हस्ताक्षर की पुष्टि करने के लिए स्क्रिप्ट पाठ स्थित है

यहां

 #! /usr/bin/env tclsh package require pki lappend auto_path . package require pki::pkcs11 #     PKCS#11 #set pkcs11_module "/usr/local/lib/libcackey.so" #set pkcs11_module "/usr/local/lib64/librtpkcs11ecp_2.0.so" set pkcs11_module "/usr/local/lib64/libls11sw2016.so" puts "Connect the Token and press Enter" gets stdin yes set handle [pki::pkcs11::loadmodule $pkcs11_module] set slots [pki::pkcs11::listslots $handle] foreach slotinfo $slots { set slotid [lindex $slotinfo 0] set slotlabel [lindex $slotinfo 1] set slotflags [lindex $slotinfo 2] if {[lsearch -exact $slotflags TOKEN_PRESENT] != -1} { set token_slotlabel $slotlabel set token_slotid $slotid #    break } } # PEM  DER proc ::cert_to_der {data} { if {[string first "-----BEGIN CERTIFICATE-----" $data] != -1} { set data [string map {"\r\n" "\n"} $data] } array set parsed_cert [::pki::_parse_pem $data "-----BEGIN CERTIFICATE-----" "-----END CERTIFICATE-----"] if {[string range $parsed_cert(data) 0 0 ] == "0" } { #   DER- "0" == 0x30 set asnblock $parsed_cert(data) } else { set asnblock "" } return $asnblock } proc usage {use error} { puts "Copyright(C) Orlov Vladimir (http://soft.lissi.ru) 2019" if {$use == 1} { puts $error puts "Usage:\nverify_cert_with_pkcs11 <file with certificate> \[<file with CA certificate>\]\n" } } set countcert [llength $argv] if { $countcert < 1 || $countcert > 2 } { usage 1 "Bad usage!" exit } set file [lindex $argv 0] if {![file exists $file]} { usage 1 "File $file not exist" exit } #  cert_user puts "Loading user certificate: $file" set fd [open $file] chan configure $fd -translation binary set cert_user [read $fd] close $fd if {$cert_user == "" } { usage 1 "Bad file with certificate user: $file" exit } set cert_user [cert_to_der $cert_user] if {$cert_user == ""} { puts "User certificate bad" exit } catch {array set cert_parse [::pki::x509::parse_cert $cert_user]} if {![info exists cert_parse]} { puts "User certificate bad" exit } #parray cert_parse if {$countcert == 1} { if {$cert_parse(issuer) != $cert_parse(subject)} { puts "Bad usage: not self signed certificate" } else { set cert_CA $cert_user } } else { set fileca [lindex $argv 1] if {![file exists $fileca]} { usage 1 "File $fileca not exist" exit } #  cert_CA puts "Loading CA certificate: $fileca" set fd [open $fileca] chan configure $fd -translation binary set cert_CA [read $fd] close $fd if {$cert_CA == "" } { usage 1 "Bad file with certificate CA=$fileca" exit } set cert_CA [cert_to_der $cert_CA] if {$cert_CA == ""} { puts "CA certificate bad" exit } } foreach slotinfo $slots { set slotid [lindex $slotinfo 0] set slotlabel [lindex $slotinfo 1] set slotflags [lindex $slotinfo 2] if {[lsearch -exact $slotflags TOKEN_PRESENT] != -1} { set token_slotlabel $slotlabel set token_slotid $slotid } } #    #array set cert_parse_CA [::pki::x509::parse_cert $cert_CA] catch {array set cert_parse_CA [::pki::x509::parse_cert $cert_CA]} #array set cert_parse_CA [::pki::x509::parse_cert $cert_CA_256] #array set cert_parse_CA [::pki::x509::parse_cert $CA_12_512] if {![info exists cert_parse_CA]} { puts "CA certificate bad" exit } ############################### set aa [dict create pkcs11_handle $handle pkcs11_slotid $token_slotid] set tbs_cert [binary format H* $cert_parse(cert)] #puts "SIGN_ALGO1=$cert_parse(signature_algo)" catch {set signature_algo_number [::pki::_oid_name_to_number $cert_parse(signature_algo)]} if {![info exists signature_algo_number]} { set signature_algo_number $cert_parse(signature_algo) } #puts "SIGN_ALGO=$signature_algo_number" switch -- $signature_algo_number { "1.2.643.2.2.3" - "1 2 643 2 2 3" { # "GOST R 34.10-2001 with GOST R 34.11-94" set digest_algo "gostr3411" } "1.2.643.7.1.1.3.2" - "1 2 643 7 1 1 3 2" { # "GOST R 34.10-2012-256 with GOSTR 34.11-2012-256" set digest_algo "stribog256" } "1.2.643.7.1.1.3.3" - "1 2 643 7 1 1 3 3" { # "GOST R 34.10-2012-512 with GOSTR 34.11-2012-512" set digest_algo "stribog512" } default { puts "  :$signature_algo_number" exit } } #   tbs-!!!! set digest_hex [pki::pkcs11::digest $digest_algo $tbs_cert $aa] puts "digest_hex=$digest_hex" puts [string length $digest_hex] # asn-   #    binary scan $cert_CA H* cert_CA_hex array set infopk [pki::pkcs11::pubkeyinfo $cert_CA_hex [list pkcs11_handle $handle pkcs11_slotid $token_slotid]] parray infopk set lpk [dict create pkcs11_handle $handle pkcs11_slotid $token_slotid] # pybkeyinfo     lappend lpk "pubkeyinfo" #lappend lpk $pubinfo lappend lpk $infopk(pubkeyinfo) array set lpkar $lpk parray lpkar puts "Enter PIN user for you token \"$token_slotlabel\":" #set password "01234567" gets stdin password if { [pki::pkcs11::login $handle $token_slotid $password] == 0 } { puts "Bad password" exit } if {[catch {set verify [pki::pkcs11::verify $digest_hex $cert_parse(signature) $lpk]} res] } { puts $res exit } if {$verify != 1} { puts "BAD SIGNATURE=$verify" } else { puts "SIGNATURE OK=$verify" } puts "!" exit

स्क्रिप्ट को किसी फ़ाइल में सहेजें और उसे निष्पादित करने का प्रयास करें:

 $./verify_cert_with_pkcs11.tcl Copyright(C) Orlov Vladimir (http://museum.lissi-crypto.ru/) Usage: verify_cert_with_pkcs11 <file with certificate> <file with CA certificate> $

एक चमत्कार, टोकन पर प्रमाण पत्र के बारे में क्या? सबसे पहले, हमने PKCS # 11 क्रिप्टोग्राफिक मशीनों का उपयोग करने की समस्या को हल किया। हमने उनका उपयोग किया। और एक टोकन के साथ एक प्रमाण पत्र को प्रसारित करने के लिए, pki :: pkcs11 :: listcerderder पैकेज का एक फ़ंक्शन है, जो आपको वांछित प्रमाणपत्र का चयन करने और इसे सत्यापित करने की अनुमति देता है। इसे होमवर्क माना जा सकता है।

TclPKCS11v.1.0.1 पैकेज के नए संस्करण की उपस्थिति एक टोकन के लिए एक प्रमाण पत्र आयात करने, प्रमाणपत्र को हटाने और एक टोकन से संबंधित कुंजियों को जोड़ने, प्रमाण पत्र और कुंजियों के लेबल को बदलने आदि के कार्यों को जोड़कर प्रमाण पत्र देखने की उपयोगिता को परिष्कृत करने की अनुमति दी गई है :

सबसे महत्वपूर्ण विशेषता प्रमाणपत्र का डिजिटल हस्ताक्षर सत्यापन है:

चौकस पाठक ने सही ढंग से नोट किया कि कुंजी जोड़ी की पीढ़ी के बारे में कुछ भी नहीं कहा गया था। यह सुविधा TclPKCS11 पैकेज में भी जोड़ी गई है:

 array set genkey [pki::pkcs11::keypair < > <> <  >]

TclPKCS11 पैकेज से कार्यों का उपयोग कैसे किया जाता है, निश्चित रूप से, उपयोगिता के स्रोत कोड में पाया जा सकता है।

एक कुंजी जोड़ी बनाने के कार्य पर अगले लेख में विस्तार से चर्चा की जाएगी, जब उपयोगिता PKCS # 11 टोकन पर एक प्रमुख जोड़ी की पीढ़ी के साथ एक योग्य प्रमाण पत्र के लिए अनुरोध करेगी, एक प्रमाणन केंद्र ( CA ) में एक प्रमाण पत्र प्राप्त करने के लिए तंत्र और इसे एक टोकन में आयात करेगा:

उसी लेख में, दस्तावेज़ पर हस्ताक्षर करने के कार्य पर विचार किया जाएगा। यह इस श्रृंखला का अंतिम लेख होगा। अगला, रूबी स्क्रिप्टिंग भाषा में रूसी क्रिप्टोग्राफी का समर्थन करने पर लेखों की एक श्रृंखला की योजना बनाई गई है जो अब फैशन में है। जल्द मिलते हैं!

स्क्रिप्टिंग भाषाओं में PKCS # 11 क्रिप्टोग्राफ़िक टोकन तंत्र का उपयोग करना

More articles: