Usando mecanismos de token criptográfico PKCS # 11 em linguagens de script

Em seus comentários ao artigo “Um utilitário de plataforma cruzada no idioma inglês para exibir certificados x509 qualificados para a Rússia”, o usuário Pas observou corretamente os tokens PKCS # 11 que eles próprios “podem contar”. Sim, os tokens são realmente computadores criptográficos. E é natural querer usar esses computadores em linguagens de script, seja Python, Perl ou Ruby. De alguma forma, já consideramos o uso de tokens PKCS # 11 com suporte para criptografia russa em Python para assinar e criptografar documentos, para criar uma solicitação de certificado:



Aqui continuamos a discussão sobre a linguagem Tcl. No artigo anterior, quando analisamos a exibição e a validação de certificados armazenados nos tokens / cartões inteligentes PKCS # 11, usamos o pacote TclPKCS11 versão 0.9.9 para acessá-los (certificados). Como já foi observado, infelizmente, o pacote foi desenvolvido para criptografia RSA e levando em consideração o padrão PKCS # 11 v.2.20. Hoje, o padrão PKCS # 11 v.2.40 já está sendo usado e é o comitê de criptografia técnica TK-26 que é guiado por ele, emitindo recomendações para fabricantes nacionais de tokens / cartões inteligentes que suportam criptografia russa. E com tudo isso dito, um novo pacote TclPKCS11 versão 1.0.1 apareceu . Faremos uma reserva imediatamente para que todas as interfaces criptográficas para RSA na nova versão do pacote TclPKCS11 v.10.1 sejam salvas. A biblioteca de pacotes está escrita na linguagem C.

Então, o que há de novo no pacote? Primeiro de tudo, foi adicionado um comando que permite obter uma lista de mecanismos criptográficos suportados pelo token conectado:

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

Como obter uma lista de slots com tokens conectados é mostrada aqui (procedure - proc :: slots_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] } 

Pegue um script simples:

 #!/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 

Este script permite obter uma lista dos mecanismos de criptografia GOSTR3410 suportados nos tokens da família RuToken. Para começar, vamos considerar, como Pas escreveu no artigo , "Rutoken Light amado por todos os tipos de EDOs":

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

E, naturalmente, acontece que ele não apóia nenhum mezanismo do GOST, que deveria ser provado. Tomamos outro token Rutoken EDS:

 $ 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 $ 

Sim, esse token suporta criptografia russa, mas apenas a assinatura do GOST R 34.10-2001, que está quase fora de uso . Mas se você usar o token Rutoken EDS-2.0, tudo ficará bem, ele suporta o GOST R 34.10-2012 com chaves de 256 e 512 bits:

 $ 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 $ 

Se falamos sobre o suporte à criptografia russa, incluindo algoritmos de criptografia de gafanhoto e magma, com um ou outro token, ele é totalmente suportado por tokens de software e nuvem , e isso é natural:

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

 $ 

Passamos para o próximo novo recurso adicionado ao pacote:

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

Esta função retorna uma lista de certificados armazenados por nenhum token. A questão surge naturalmente, mas como ela difere da função existente pki :: pkcs11 :: listcerts?

Primeiro de tudo, a nova função não usa o pacote :: pki. Um dos elementos retornados é o elemento cert_der, que contém o certificado completo. Isso é conveniente, por exemplo, ao exportar um certificado ou ao receber sua impressão digital. Antes, eu precisava coletar o certificado completo do certificado tbs e de sua assinatura. Uma lista completa dos itens retornados para cada certificado é claramente visível ao imprimir o conteúdo de um certificado:

 . . . 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 . . . 

O elemento pkcs11_id armazena o atributo CKA_ID no valor do hash SHA-1 da chave pública. O elemento cert_der é o CKA_VALUE do certificado, pkcs11_label é CKA_LABEL.

O elemento pkcs11_id (CKA_ID na terminologia do padrão PKCS # 11) é, junto com a biblioteca pkcs11_handle, e o identificador de slot com o token pkcs11_slotid um elemento-chave para acessar chaves e certificados armazenados em tokens.

Portanto, se queremos alterar o rótulo (pkcs11_label) do certificado ou chaves, executamos um comando do formulário:

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

Para remover um certificado ou chaves de um token, um comando do formulário é executado:

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

A lista de elementos-chave pode ser formada da seguinte maneira:

 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 

etc.
A chamada de função neste caso é semelhante a esta (excluiremos o certificado e as chaves associadas a ele):

 pki::pkcs11::delete all $listparam 

O leitor provavelmente já adivinhou que esta lista pode ser organizada como um dicionário de dict

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

Existem outras maneiras, por exemplo, através de uma matriz.

Mais uma vez, observamos que os elementos pkcs11_handle e pkcs11_slotid devem sempre estar presentes na lista de elementos-chave, que identificam exclusivamente o token conectado. O restante da composição é determinado por uma função específica.

A seguinte função é usada para instalar o certificado no token:

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

A função retorna o valor CKA_ID em hexadecimal. A lista de parâmetros-chave determina o token no qual o certificado estará localizado:

 {pkcs11_handle <handle> pkcs11_slotid <slotid>} 

Em seguida, é o nosso cálculo de hash. Hoje, na criptografia russa, são usados ​​três tipos de funções de hash:
- GOST R 34.11-94
- GOST R 34 .11-2012 com um valor de hash de 256 bits (stribog256)
- GOST R 34 .11-2012 com um valor de hash de 512 bits (stribog512)
Para determinar qual hash suporta o token, temos a função pki :: pkcs11 :: listmechs.

A função de cálculo de hash tem o seguinte formato:

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

Observe que o resultado do cálculo é apresentado em hexadecimal:

 . . . 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 

Para verificação, vamos usar o openssl com suporte para criptografia russa :

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

Como você pode ver, o resultado é idêntico.

Para verificar uma assinatura eletrônica, seja um certificado ou uma lista de certificados revogados ou um documento assinado em um formato, agora precisamos apenas da função de verificação de assinatura:

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

Se a assinatura passou na verificação, 1 é retornado; caso contrário, 0. Para verificar a assinatura eletrônica, a própria assinatura do documento, o hash do documento, determinado pelo tipo de assinatura e a chave pública com a qual a assinatura foi criada, com todos os parâmetros (valor, tipo e parâmetros), são necessários. . Todas as informações sobre a chave na forma da estrutura publickeyinfo asn1 devem ser incluídas na lista de elementos-chave:

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

A estrutura de chave pública ASN1 é retirada do certificado de signatário:

 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) } 

O texto do script para verificar a assinatura eletrônica dos certificados de um arquivo está localizado
Salve o script em um arquivo e tente executá-lo:

 $./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> $ 

Alguém pode se perguntar, e os certificados no token? Primeiro, resolvemos o problema do uso de máquinas criptográficas PKCS # 11. Nós os usamos. E para exibir um certificado com um token, existe uma função do pacote pki :: pkcs11 :: listcertsder, que permite selecionar o certificado desejado e verificá-lo. Isso pode ser considerado como lição de casa.

A aparência da nova versão do pacote TclPKCS11v.1.0.1 permitiu refinar o utilitário de exibição de certificado , adicionando as funções de importar um certificado para um token, excluindo certificados e chaves associadas de um token, alterando os rótulos de certificados e chaves, etc .:



O recurso mais importante adicionado é a verificação de assinatura digital do certificado:



O leitor atento observou corretamente que nada foi dito sobre a geração do par de chaves. Esse recurso também foi adicionado ao pacote TclPKCS11:

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

Como as funções do pacote TclPKCS11 são usadas, é claro, podem ser encontradas no código-fonte do utilitário.

A função de gerar um par de chaves será discutida em detalhes no próximo artigo, quando o utilitário criará uma solicitação para um certificado qualificado com a geração de um par de chaves no token PKCS # 11, o mecanismo para obter um certificado em um centro de certificação ( CA ) e importá-lo para um token:



No mesmo artigo, a função de assinar um documento será considerada. Este será o último artigo desta série. Em seguida, uma série de artigos está planejada para oferecer suporte à criptografia russa na linguagem de script Ruby, que agora está na moda. Até breve!