🏆 📭 🥝 Infraestructura de clave pública basada en la criptografía rusa: GnuTLS como alternativa a OpenSSL 🤾🏻 🤠 🔄

La infraestructura de clave pública ( PKI / PKI ) incluye muchos objetos y mecanismos diferentes para trabajar con ellos, así como protocolos para la interacción de objetos entre sí (por ejemplo, TLS, OCSP). Los objetos PKI incluyen solicitudes de certificados (PKCS # 10) y los propios certificados x509, pares de claves (claves privadas y públicas), documentos firmados y cifrados (PKCS # 7, CMS), contenedores seguros para almacenar claves privadas (PKCS # 8) y certificados personales con claves (PKCS # 12), etc. Los mecanismos incluyen no solo funciones criptográficas que le permiten cifrar y firmar documentos utilizando varios algoritmos, sino también funciones que forman los objetos PKI finales. de acuerdo con los estándares (certificados, solicitudes, documentos firmados / encriptados, paquetes de protocolos, etc., etc.). Sí, y cómo no recordar el objeto central IEC / PKI - CA .

Hoy es difícil imaginar una vida empresarial del país sin PKI , sin certificado x509 (sin certificados calificados), sin los servicios de los servicios públicos y el Servicio de Impuestos Federales, donde los documentos se aceptan en formato electrónico con firma electrónica. Y cada vez se devuelven más documentos al ciudadano también en formato electrónico con firma electrónica. Ya no es posible presentar procedimientos judiciales sin firma electrónica.

La herramienta más avanzada para crear herramientas de software que trabajen con objetos PKI es OpenSSL.

OpenSSL es un conjunto completo de bibliotecas y utilidades criptográficas de código abierto que admite casi todos los algoritmos de hash, cifrado y firma digital de bajo nivel, e implementa la mayoría de los estándares criptográficos populares. Sin embargo, estos estándares criptográficos no incluyen la criptografía rusa. Para un trabajo completo con criptografía rusa en OpenSSL, es necesario conectar adicionalmente el motor gost .

Ya escribimos que la biblioteca gcrypt puede ser una alternativa a openssl .... Y ahora se ha implementado soporte para criptografía rusa y mecanismos criptográficos en el proyecto GnuTLS . GnuTLS admite tanto algoritmos criptográficos antiguos como nuevos: GOST R 34.10-2012 (firma electrónica), GOST R 34.11-2012 (hash), GOST R 34.12-2015 y GOST R 34.13-2015 (algoritmos de cifrado Grasshopper y Magma).

Por analogía con la utilidad openssl en el proyecto OpenSSL, el proyecto GnuTLS tiene una utilidad certtool, que en términos de funcionalidad no es inferior a la utilidad openssl.

Se trata de esta utilidad y sus capacidades que se discutirán.

Información general sobre la utilidad certtool

Como se señaló, la utilidad certtool tiene mucho en común con la utilidad openssl.

El primer parámetro de la utilidad certtool, como regla, es una bandera que determina qué función se debe realizar. Por ejemplo, el indicador "--certificate-info" indica que es necesario analizar el certificado y el indicador "--generate-privkey" indica que se genere una clave privada. Los datos de entrada, que son objetos PKI (claves, certificados, listas de revocación de certificados, etc.) necesarios para la ejecución del comando, se introducen como estructuras ASN1 en formato PEM (base64) o DER. El formato predeterminado es PEM.

Si los datos se recibirán en formato DER, entonces se debe especificar la opción "--inder".

El resultado de ejecutar la función correspondiente es una estructura ASN1 (el mismo certificado, por ejemplo). De forma predeterminada, la estructura de salida ASN1 está en formato PEM. Si necesita obtenerlo en formato DER, agregue la opción "--outder". Junto con la estructura ASN1 predeterminada (opción "--text"), su contenido también se muestra en forma de texto. Si no es necesario mostrar la vista de texto, se especifica la opción "--no-text".

Todo esto se puede demostrar con el ejemplo de conversión de archivos de certificado de formato PEM a DER y viceversa:

#      PEM  DER
#   --outder,   --no-text   .
$certtool --certificate-info --infile certPEM.pem --outder --outfile certDER.der
#      DER  PEM
$certtool --certificate-info --inder --infile certDER.der --no-text  --outfile certPEM_new.pem
$

Para obtener ayuda sobre la utilidad certtool, ejecute el comando:

$ certtool --help

Ayuda de la utilidad Certtool

certtool - GnuTLS certificate tool
Usage:  certtool [ -<flag> [<val>] | --<name>[{=| }<val>] ]...

   -d, --debug=num            Enable debugging
				- it must be in the range:
				  0 to 9999
   -V, --verbose              More verbose output
				- may appear multiple times
       --infile=file          Input file
				- file must pre-exist
       --outfile=str          Output file

Certificate related options:

   -i, --certificate-info     Print information on the given certificate
       --pubkey-info          Print information on a public key
   -s, --generate-self-signed  Generate a self-signed certificate
   -c, --generate-certificate  Generate a signed certificate
       --generate-proxy       Generates a proxy certificate
   -u, --update-certificate   Update a signed certificate
       --fingerprint          Print the fingerprint of the given certificate
       --key-id               Print the key ID of the given certificate
       --v1                   Generate an X.509 version 1 certificate (with no extensions)
       --sign-params=str      Sign a certificate with a specific signature algorithm

Certificate request related options:

       --crq-info             Print information on the given certificate request
   -q, --generate-request     Generate a PKCS #10 certificate request
				- prohibits the option 'infile'
       --no-crq-extensions    Do not use extensions in certificate requests

PKCS#12 file related options:

       --p12-info             Print information on a PKCS #12 structure
       --p12-name=str         The PKCS #12 friendly name to use
       --to-p12               Generate a PKCS #12 structure

Private key related options:

   -k, --key-info             Print information on a private key
       --p8-info              Print information on a PKCS #8 structure
       --to-rsa               Convert an RSA-PSS key to raw RSA format
   -p, --generate-privkey     Generate a private key
       --key-type=str         Specify the key type to use on key generation
       --bits=num             Specify the number of bits for key generation
       --curve=str            Specify the curve used for EC key generation
       --sec-param=str        Specify the security level [low, legacy, medium, high, ultra]
       --to-p8                Convert a given key to a PKCS #8 structure
   -8, --pkcs8                Use PKCS #8 format for private keys
       --provable             Generate a private key or parameters from a seed using a provable method
       --verify-provable-privkey  Verify a private key generated from a seed using a provable method
       --seed=str             When generating a private key use the given hex-encoded seed

CRL related options:

   -l, --crl-info             Print information on the given CRL structure
       --generate-crl         Generate a CRL
       --verify-crl           Verify a Certificate Revocation List using a trusted list
				- requires the option 'load-ca-certificate'

Certificate verification related options:

   -e, --verify-chain         Verify a PEM encoded certificate chain
       --verify               Verify a PEM encoded certificate (chain) against a trusted set
       --verify-hostname=str  Specify a hostname to be used for certificate chain verification
       --verify-email=str     Specify a email to be used for certificate chain verification
				- prohibits the option 'verify-hostname'
       --verify-purpose=str   Specify a purpose OID to be used for certificate chain verification
       --verify-allow-broken  Allow broken algorithms, such as MD5 for verification
       --verify-profile=str   Specify a security level profile to be used for verification

PKCS#7 structure options:

       --p7-generate          Generate a PKCS #7 structure
       --p7-sign              Signs using a PKCS #7 structure
       --p7-detached-sign     Signs using a detached PKCS #7 structure
       --p7-include-cert      The signer's certificate will be included in the cert list.
				- disabled as '--no-p7-include-cert'
				- enabled by default
       --p7-time              Will include a timestamp in the PKCS #7 structure
				- disabled as '--no-p7-time'
       --p7-show-data         Will show the embedded data in the PKCS #7 structure
				- disabled as '--no-p7-show-data'
       --p7-info              Print information on a PKCS #7 structure
       --p7-verify            Verify the provided PKCS #7 structure
       --smime-to-p7          Convert S/MIME to PKCS #7 structure

Other options:

       --get-dh-params        List the included PKCS #3 encoded Diffie-Hellman parameters
       --dh-info              Print information PKCS #3 encoded Diffie-Hellman parameters
       --load-privkey=str     Loads a private key file
       --load-pubkey=str      Loads a public key file
       --load-request=str     Loads a certificate request file
       --load-certificate=str Loads a certificate file
       --load-ca-privkey=str  Loads the certificate authority's private key file
       --load-ca-certificate=str Loads the certificate authority's certificate file
       --load-crl=str         Loads the provided CRL
       --load-data=str        Loads auxiliary data
       --password=str         Password to use
       --null-password        Enforce a NULL password
       --empty-password       Enforce an empty password
       --hex-numbers          Print big number in an easier format to parse
       --cprint               In certain operations it prints the information in C-friendly format
       --hash=str             Hash algorithm to use for signing
       --salt-size=num        Specify the RSA-PSS key default salt size
       --inder                Use DER format for input certificates, private keys, and DH parameters
				- disabled as '--no-inder'
       --inraw                an alias for the 'inder' option
       --outder               Use DER format for output certificates, private keys, and DH parameters
				- disabled as '--no-outder'
       --outraw               an alias for the 'outder' option
       --template=str         Template file to use for non-interactive operation
       --stdout-info          Print information to stdout instead of stderr
       --ask-pass             Enable interaction for entering password when in batch mode.
       --pkcs-cipher=str      Cipher to use for PKCS #8 and #12 operations
       --provider=str         Specify the PKCS #11 provider library
       --text                 Output textual information before PEM-encoded certificates, private
keys, etc
				- disabled as '--no-text'
				- enabled by default

Version, usage and configuration options:

   -v, --version[=arg]        output version information and exit
   -h, --help                 display extended usage information and exit
   -!, --more-help            extended usage information passed thru pager

Options are specified by doubled hyphens and their name or by a single
hyphen and the flag character.

Tool to parse and generate X.509 certificates, requests and private keys.
It can be used interactively or non interactively by specifying the
template command line option.

The tool accepts files or supported URIs via the --infile option.  In case
PIN is required for URI access you can provide it using the environment
variables GNUTLS_PIN and GNUTLS_SO_PIN.

Please send bug reports to:  <bugs@gnutls.org>

Ahora pasemos a las funciones principales de la utilidad certtool.

Generando y visualizando un par

Para generar una clave privada utilizando el algoritmo GOST R 34.10 2012, se utiliza el siguiente comando:

$certtool --generate-privkey --key-type [gost12-256 | gost12-512] --curve < > [--no-text] [--outder] [--outfile <   >]
$

Los OID establecen los parámetros criptográficos (--curve) al generar un par de claves. Actualmente, TK-26 ha definido los siguientes oid-s para los criptoparámetros del algoritmo de firma GOST R 34.10-2012 con una clave de 256:

1.2.643.7.1.2.1.1.1 (id-tc26-gost-3410-12-256-paramSetA) [TC26-256-A];

1.2.643.7.1.2.1.1.2 (id-tc26-gost-3410-12-256-paramSetB) [TC26-256-B];

1.2.643.7.1.2.1.1.3 (id-tc26-gost-3410-12-256-paramSetC) [TC26-256-C];

1.2.643.7.1.2.1.1.4 (id-tc26-gost-3410-12-256-paramSetD) [TC26-256-D].

Al mismo tiempo, siguen funcionando los denominados parámetros OID de CryptoPro:

1.2.643.2.2.35.1 (id-GostR3410-2001-CryptoPro-A-ParamSet) [CryptoPro-A];

1.2.643.2.2.35.2 (d-GostR3410-2001-CryptoPro-B-ParamSet) [CryptoPro-B];

1.2.643.2.2.35.3 (id-GostR3410-2001-CryptoPro-C-ParamSet) [CryptoPro-C];

1.2.643.2.2.36.0 (id-GostR3410-2001-CryptoPro-XchA-ParamSet) [CryptoPro-XchA];

1.2.643.2.2.36.1 (id-GostR3410-2001-CryptoPro-XchB-ParamSet) [CryptoPro-XchB].

Recuerde que los parámetros de CryptoPro con OIDs 1.2.643.2.2.35.1, 1.2.643.2.2.35.2, 1.2.643.2.2.35.3 corresponden a los parámetros de TC-26 con OIDs 1.2.643.7.1.2.1.1.1 , 1.2.643.7.1.2.1.1.2, 1.2.643.7.1.2.1.1.3 respectivamente.

Con los parámetros criptográficos para el algoritmo de firma GOST R 34.10-2012 con una clave 512, es más fácil:

1.2.643.7.1.2.1.2.1 (id-tc26-gost-3410-2012-512-paramSetA) [TC26-512-A];

1.2.643.7.1.2.1.2.2 (id-tc26-gost-3410-2012-512-paramSetB) [TC26-512-B];

1.2.643.7.1.2.1.2.3 (id-tc26-gost-3410-2012-512-paramSetC) [TC26-512-C];

GnuTLS tiene su propia notación para los parámetros criptográficos y se indican entre corchetes, por ejemplo [TC26-256-B]. Desafortunadamente, al generar una clave, los parámetros criptográficos solo se pueden establecer mediante su designación simbólica. Los OID punteados se descartan.

Pero este no es el mayor inconveniente. Actualmente, GnuTLS solo admite dos parámetros criptográficos. Para las llaves GOST 34.10-2012-256 (opción --key-type gost12-256) este es un parámetro con oid 1.2.643.7.1.2.1.1.2 (opción --curve TC26-256), y para llaves con una longitud de 512 bits este es un parámetro con oid 1.2.643.7.1.2.1.2.1 (opción --curve TC26-512-A).

Por lo tanto, cree una clave privada (indicador --generate-privkey) y vea información sobre la clave (indicador --key-info):

#    --key-type gost12-256 --curve TC26-256-B
$certtool --generate-privkey --key-type gost12-256 --curve TC26-256-B --no-text --outder --outfile key256.der
Generating a 256 bit GOST R 34.10-2012-256 private key (TC26-256-B)...
#  
$certtool --key-info --inder --infile key256.der
Public Key Info:
   Public Key Algorithm: GOST R 34.10-2012-256
   Key Security Level: High (256 bits)

curve:   TC26-256-B
digest:  STREEBOG-256
paramset:   TC26-Z
private key:
   4b:df:cb:9e:cc:49:c5:a2:70:36:c9:d8:df:55:97:f5
   8b:be:ae:06:7b:34:76:39:b6:aa:57:af:3f:2d:98:36
x:
   0d:71:29:56:d2:39:59:6f:14:d3:4b:75:44:85:91:a9
   5d:fa:83:4a:93:9a:2c:20:b0:6b:5c:74:8c:76:5f:a5
y:
   2d:ac:da:23:f3:2f:45:d9:47:c4:a3:c1:d7:65:bd:46
   1d:ba:12:cd:15:e1:b0:8f:5a:99:f2:35:ea:fc:33:fc
   
Public Key PIN:
   pin-sha256:nrftlmdCrSf11N+ivohfuGXSQixa4Scnhl7GTsUTE2E=
Public Key ID:
   sha256:9eb7ed966742ad27f5d4dfa2be885fb865d2422c5ae12727865ec64ec5131361
   sha1:25927018f3775ed86996c625a99b7db86b2d0a7e
-----BEGIN PRIVATE KEY-----
MEACAQAwFwYIKoUDBwEBAQEwCwYJKoUDBwECAQECBCIEIDaYLT+vV6q2OXY0ewau
vov1l1Xf2Mk2cKLFScyey99L
-----END PRIVATE KEY-----
$

En la información sobre la clave, tenemos información completa sobre la clave privada (cerrada), incluida su estructura asn1, y la clave pública, incluido su valor (xey).

Ahora veamos la estructura de la clave privada asn1. Para hacer esto, usaremos la utilidad cryptoarmpkcs :

No encontrarás el valor de la clave pública en esta estructura. El valor de la clave pública se calcula mediante la clave privada. ¡Pero la clave privada no se puede calcular a partir de la pública, por supuesto! Aún así, es una pena que la estructura asn1 de la clave pública no esté disponible cuando se visualiza la clave privada (indicador --key-info). Sería posible ingresar la opción --pubkey-info (existe una opción de este tipo para el certificado), que mostraría la estructura asn1 de la clave pública.

Por supuesto, la clave privada debe almacenarse de forma segura, al menos cifrada con una contraseña. Se utiliza un contenedor PKCS8 para almacenar de forma segura la clave privada, lo que proporciona la capacidad de cifrar la clave privada mediante cifrado basado en la contraseña del usuario. Dado que aquí estamos hablando del uso de la criptografía rusa y las recomendaciones de TK-26, el comando para generar una clave privada en un contenedor PKCS8 seguro se verá así:

$certtool --generate-privkey --pkcs8 --pkcs-cipher gost28147-tc26z [--password <>] --key-type [gost12-256 | gost12-512] --curve < > [--no-text] [--outder] [--outfile <   >]
$

Si no se especifica la opción "--password", se solicitará la contraseña para cifrar la clave privada en la línea de comando:

bash-5.1$ ./generate_key_parse_password.sh 
#    --key-type gost12-256 --curve TC26-256-B
$certtool --generate-privkey --pkcs8 --pkcs-cipher gost28147-tc26z --password 01234567  --key-type gost12-256 --curve TC26-256-B --no-text --outder --outfile key256_pkcs8.der
Generating a 256 bit GOST R 34.10-2012-256 private key (TC26-256-B)...
#   
$certtool --key-info --inder --infile key256.der
Encrypted structure detected...
Enter password: < >
PKCS #8 information:
   Cipher: GOST28147-TC26Z-CFB
   Schema: PBES2-GOST28147-89-TC26Z (1.2.643.7.1.2.5.1.1)
   Salt: 32b2798c23a5d0ab8c3144daf273745bdb
   Salt size: 17
   Iteration count: 5333

Public Key Info:
   Public Key Algorithm: GOST R 34.10-2012-256
   Key Security Level: High (256 bits)

curve:   TC26-256-B
digest:  STREEBOG-256
paramset:   TC26-Z
private key:
   05:20:c3:7a:93:a2:e1:b4:64:50:a4:fb:db:cc:74:43
   1a:14:d9:00:c4:82:dc:f5:94:8a:8a:65:a4:76:47:76   
x:
   1b:3e:0b:e0:3b:fc:1d:ee:62:10:63:66:72:fc:66:a6
   d5:b8:94:b1:fe:a4:ec:d6:d8:f1:18:63:95:a9:30:15   
y:
   fb:c0:24:10:41:12:98:7f:aa:15:cd:3b:7e:e7:64:bd
   c4:97:3d:18:04:82:f0:80:61:8e:ff:48:eb:d6:97:d5  
Public Key PIN:
   pin-sha256:eD6s4BQl4R0WY6H8KJZKDA6zuzd6A7JcNCh4FpUH1Rg=
Public Key ID:
   sha256:783eace01425e11d1663a1fc28964a0c0eb3bb377a03b25c342878169507d518
   sha1:62afc2d7c8bf77f1ac0820324170cd2262a63091

-----BEGIN PRIVATE KEY-----
MEACAQAwFwYIKoUDBwEBAQEwCwYJKoUDBwECAQECBCIEIHZHdqRlioqU9dyCxADZ
FBpDdMzb+6RQZLThopN6wyAF
-----END PRIVATE KEY-----
#    openssl  
/usr/local/lirssl_csp_64/bin/lirssl pkcs8 -inform DER -in key256_pkcs8.der  -outform PEM
-----BEGIN PRIVATE KEY-----
MEACAQAwFwYIKoUDBwEBAQEwCwYJKoUDBwECAQECBCIEIHZHdqRlioqU9dyCxADZ
FBpDdMzb+6RQZLThopN6wyAF
-----END PRIVATE KEY-----
bash-5.1$

Crea una solicitud de certificado

Con la clave privada en su lugar, puede comenzar a crear su solicitud de certificado.

La marca --generate-request se usa para crear una solicitud:

certtool --generate-request --load-privkey <   > --template <   > [--no-text]

Consideremos la posibilidad de crear una solicitud de certificado para una persona. Está previsto que el certificado se utilice para generar y verificar una firma electrónica. En este caso, el archivo con la plantilla de solicitud solo puede contener el nombre distinguido (DN) del propietario del certificado, que incluye los siguientes tipos de atributos / oids y sus valores:

# - oid=2.5.4.6
#country = RU
# 
dn_oid = "2.5.4.6 RU"
# - 2.5.4.8
state = "50  "
# 
#dn_oid = "2.5.4.6 RU"
#,  - 2.5.4.7
locality = ". "
# - 2.5.4.9
#street = "  ,    "
# 
#dn_oid = "2.5.4.9   ,    "
# - 2.5.4.10
#organization = "  "
# surname 2.5.4.4
#sn = ""
dn_oid = "2.5.4.4 "
#,  givenname - 2.5.4.42
#ginenName = " "
dn_oid = "2.5.4.42  "
#  commonName - 2.5.4.3
cn = " "

Como puede ver en la plantilla, los atributos para un DN (nombre distinguido) se pueden especificar usando el nombre simbólico del atributo aceptado en GnuTLS (por ejemplo, país = RU), o usando el oid del atributo:

dn_oid = "<oid > < >"

...

En este caso, puede especificar el país así:

dn_oid = "2.5.4.6 RU"

Si queremos que el nombre distinguido en la solicitud tenga en cuenta los "Requisitos para la forma del certificado calificado de la clave de verificación de firma electrónica" , entonces tendremos que agregarle TIN y SNILS , si estamos hablando de un particular. :

#   - /INN
dn_oid = "1.2.643.3.131.1.1  123456789012"
#     - /SNILS
dn_oid = "1.2.643.100.3 12345678901"

Digamos que la clave privada está almacenada en el archivo privkey.pem y la plantilla está en el archivo templateP10.txt. Luego, la solicitud se puede generar y ver con el siguiente comando:

$certtool --generate-request --load-privkey privkey.pem --template templateP10.txt
Generating a PKCS #10 certificate request...
PKCS #10 Certificate Request Information:
   Version: 1
   Subject: EMAIL=gnutls@aa.ru,SNILS=12345678909,INN=123456789098,givenName=  ,surName=,street=  \,    ,C=RU,ST= ,L=. ,CN= 
   Subject Public Key Algorithm: GOST R 34.10-2012-256
   Algorithm Security Level: High (256 bits)
      Curve:   TC26-256-B
      Digest:  STREEBOG-256
      ParamSet: TC26-Z
      X:
         23:63:5c:72:6f:ac:bb:76:59:a6:65:d0:45:9b:29:ad
         3c:87:59:15:52:21:e2:91:5c:ca:da:16:3e:b9:f7:fa
      Y:
         4d:84:a0:79:a4:02:d4:20:b4:01:e6:4c:9b:da:5e:6a
         4a:cd:b4:7e:c0:01:7e:8d:29:0c:f4:a6:d7:b3:07:a0
   Signature Algorithm: GOSTR341012-256
   Attributes:
      Extensions:
         Subject Signing Tool(not critical):
            GnuTLS
         Basic Constraints (critical):
            Certificate Authority (CA): FALSE
         Key Usage (critical):
            Digital signature.
Other Information:
   Public Key ID:
      sha1:c0e53bf1cc35f14dce4b7e05ee091c90f497dadf
      sha256:eb3dc1375ea60f165b51a9349b32a1a4eab1614e5d49fd02bdf66785095984ea
   Public Key PIN:
      pin-sha256:6z3BN16mDxZbUak0mzKhpOqxYU5dSf0CvfZnhQlZhOo=

Self signature: verified

-----BEGIN NEW CERTIFICATE REQUEST-----
MIICajCCAhcCAQAwggFrMSQwIgYDVQQDDBvQqNGD0YDQsCDQkdCw0LvQsNCz0LDQ
vdC+0LIxHTAbBgNVBAcMFNCzLiDQmtC+0LfQtdC70YzRgdC6MSwwKgYDVQQIDCPQ
nNC+0YHQutC+0LLRgdC60LDRjyDQvtCx0LvQsNGB0YLRjDELMAkGA1UEBhMCUlUx
SDBGBgNVBAkMP9CS0L7RgiDQvNC+0Y8g0LTQtdGA0LXQstC90Y8sINCy0L7RgiDQ
vNC+0Lkg0LTQvtC8INGA0L7QtNC90L7QuTEbMBkGA1UEBAwS0JHQsNC70LDQs9Cw
0L3QvtCyMTEwLwYDVQQqDCjRgdGL0L0g0LvQtdC50YLQtdC90LDQvdGC0LAg0KjQ
vNC40LTRgtCwMRowGAYIKoUDA4EDAQESDDEyMzQ1Njc4OTA5ODEWMBQGBSqFA2QD
EgsxMjM0NTY3ODkwOTEbMBkGCSqGSIb3DQEJARYMZ251dGxzQGFhLnJ1MF4wFwYI
KoUDBwEBAQEwCwYJKoUDBwECAQECA0MABED697k+FtrKXJHiIVIVWYc8rSmbRdBl
pll2u6xvclxjI6AHs9em9AwpjX4BwH60zUpqXtqbTOYBtCDUAqR5oIRNoEMwQQYJ
KoZIhvcNAQkOMTQwMjARBgUqhQNkbwQIDAZHbnVUTFMwDAYDVR0TAQH/BAIwADAP
BgNVHQ8BAf8EBQMDB4AAMAoGCCqFAwcBAQMCA0EARPHu9P2dPb2GrhQTeOBkmbA0
Fw5I0HDF1S5YI7g0jJmdz70rv80XpozmkNKpARN9yYQx9t82fUXUGqwJK9A4RA==
-----END NEW CERTIFICATE REQUEST-----

$

Guardemos la solicitud de un certificado en el archivo request.pem y vayamos con ella a la CA para obtener un certificado.

En aras de la justicia, debe tenerse en cuenta que la utilidad certtool tiene grandes capacidades para generar no solo solicitudes de certificado, sino también los propios certificados. Estas capacidades no son de ninguna manera inferiores a las capacidades de openssl o nss.

Obtención, visualización y verificación de certificados

Para emitir un certificado, todavía usaremos la utilidad CAFL63 :

Supongamos que el certificado emitido se almacena en el archivo certfromreq.pem. Junto con el certificado, los usuarios, por regla general, reciben un certificado de la propia autoridad de certificación, es decir, certificado, cuya clave privada firmó el certificado recibido. La presencia del certificado CA le permite verificar el certificado de usuario:

$certtool --verify --verify-profile normal   [--inder] --load-ca-certificate <   > --infile <   >

Por ejemplo, si hay un certificado de usuario guardado en el archivo certfromreq.pem y el certificado CA en el archivo rootca_12_256_TC26.pem, para verificarlo, simplemente ejecute el siguiente comando:

bash-5.1$ certtool --verify --verify-profile normal  --load-ca-certificate rootca_12_256_TC26.pem  --infile certfromreq.pem 
Loaded CAs (1 available)
        Subject: EMAIL=gnutls@aa.ru,SNILS=12345678909,INN=123456789098,givenName=  ,surName=,street=  \,    ,C=RU,ST= ,L=. ,CN= 
        Issuer: EMAIL=cafl63@mail.ru,OGRN=1234567890123,INN=001234567890,CN=  CAFL63,OU= ,O=  CAFL63,street=. \, . 4,L=. ,ST= ,C=RU
        Checked against: EMAIL=cafl63@mail.ru,OGRN=1234567890123,INN=001234567890,CN=  CAFL63,OU= ,O=  CAFL63,street=. \, . 4,L=. ,ST= ,C=RU
        Signature algorithm: GOSTR341012-256
        Output: Verified. The certificate is trusted. 

Chain verification output: Verified. The certificate is trusted. 

bash-5.1$

Para ver el certificado recibido, debe usar la marca --certificate-info:

bash-5.1$ certtool --certificate-info --infile CertFromReqGnuTLS_2.pem

Información del certificado X.509:


   Version: 3
   Serial Number (hex): 1022
   Issuer: EMAIL=cafl63@mail.ru,OGRN=1234567890123,INN=001234567890,CN=  CAFL63,OU= ,O=  CAFL63,street=. \, . 4,L=. ,ST= ,C=RU
   Validity:
      Not Before: Tue Apr 27 11:50:00 UTC 2021
      Not After: Thu Apr 28 11:50:00 UTC 2022
   Subject: EMAIL=gnutls@aa.ru,SNILS=12345678909,INN=123456789098,givenName=  ,surName=,street=  \,    ,C=RU,ST= ,L=. ,CN= 
   Subject Public Key Algorithm: GOST R 34.10-2012-256
   Algorithm Security Level: High (256 bits)
      Curve:   TC26-256-B
      Digest:  STREEBOG-256
      ParamSet: TC26-Z
      X:
         23:63:5c:72:6f:ac:bb:76:59:a6:65:d0:45:9b:29:ad
         3c:87:59:15:52:21:e2:91:5c:ca:da:16:3e:b9:f7:fa
      Y:
         4d:84:a0:79:a4:02:d4:20:b4:01:e6:4c:9b:da:5e:6a
         4a:cd:b4:7e:c0:01:7e:8d:29:0c:f4:a6:d7:b3:07:a0
   Extensions:
      Basic Constraints (critical):
         Certificate Authority (CA): FALSE
      Issuer Signing Tool(not critical):
         SignTool:  -CSP
         CATool:   CAFL63
         SignToolCert: № -124/3917   29  2020 .
         CAToolCert:   №
      Subject Signing Tool(not critical):
         GnuTLS
      Certificate Policies (not critical):
         1.2.643.100.113.1 (Russian security class KC1)
         1.2.643.100.113.2 (Russian security class KC2)
      Key Usage (not critical):
         Digital signature.
      Key Purpose (not critical):
         1.2.643.6.3.1.2.2
         TLS WWW Client.
         Email protection.
         1.3.6.1.4.1.311.20.2.2
         1.2.643.5.1.28.2
         1.2.643.5.1.28.3
         TLS WWW Client.
         Email protection.
      Subject Key Identifier (not critical):
         ddc80c1857a797dd540b70825e251c2180f585d5
      Authority Key Identifier (not critical):
         directoryName: EMAIL=cafl63@mail.ru,OGRN=1234567890123,INN=001234567890,CN=  CAFL63,OU= ,O=  CAFL63,street=. \, . 4,L=. ,ST= ,C=RU
         serial: 00c79588557040f04e
         70c016b99db59d8466316ea4a51ee0d1026b5cfe
      Subject Alternative Name (not critical):
         RFC822Name: gnutls@aa.ru
      Issuer Alternative Name (not critical):
      Authority Information Access (not critical):
         Access Method: 1.3.6.1.5.5.7.48.2 (id-ad-caIssuers)
         Access Location URI: http://museum.lissi-crypto.ru/docs/ucfz_63/CAFL63.crt
   Signature Algorithm: GOSTR341012-256
   Signature:
      0b:51:a3:d9:77:9f:9e:7d:91:e0:d8:4d:d9:82:a9:71
      91:be:82:ee:5a:6c:c6:79:af:34:1d:30:69:d1:ae:4f
      a5:79:18:6d:46:08:8c:44:65:6f:2c:24:74:8c:09:7f
      30:52:dc:65:9c:f9:b6:46:81:14:a9:83:2a:c0:80:d3
Other Information:
   Fingerprint:
      sha1:d53b007e3d1c3880cb7f92b7e29263cf9c5605c3
      sha256:14bbeeeaeb4219147048dae551eceb2e62de5d00571c6c0ee862161ca2260755
   Public Key ID:
      sha1:c0e53bf1cc35f14dce4b7e05ee091c90f497dadf
      sha256:eb3dc1375ea60f165b51a9349b32a1a4eab1614e5d49fd02bdf66785095984ea
   Public Key PIN:
      pin-sha256:6z3BN16mDxZbUak0mzKhpOqxYU5dSf0CvfZnhQlZhOo=

-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----

bash-5.1$

Y si en lugar del indicador --certificate-info especificamos el indicador --pubkey - info, recibiremos no solo información sobre la clave pública, sino también su estructura asn1:

bash-5.1$ certtool --pubkey-info  --infile CertFromReqGnuTLS_2.pem |expand -3
Public Key Information:
   Public Key Algorithm: GOST R 34.10-2012-256
   Algorithm Security Level: High (256 bits)
      Curve:   TC26-256-B
      Digest:  STREEBOG-256
      ParamSet: TC26-Z
      X:
         23:63:5c:72:6f:ac:bb:76:59:a6:65:d0:45:9b:29:ad
         3c:87:59:15:52:21:e2:91:5c:ca:da:16:3e:b9:f7:fa
      Y:
         4d:84:a0:79:a4:02:d4:20:b4:01:e6:4c:9b:da:5e:6a
         4a:cd:b4:7e:c0:01:7e:8d:29:0c:f4:a6:d7:b3:07:a0
Public Key Usage:
   Digital signature.
   Key encipherment.
   Key agreement.
Public Key ID:
   sha1:c0e53bf1cc35f14dce4b7e05ee091c90f497dadf
   sha256:eb3dc1375ea60f165b51a9349b32a1a4eab1614e5d49fd02bdf66785095984ea
Public Key PIN:
   pin-sha256:6z3BN16mDxZbUak0mzKhpOqxYU5dSf0CvfZnhQlZhOo=
#ASN1-    PEM-
-----BEGIN PUBLIC KEY-----
MF4wFwYIKoUDBwEBAQEwCwYJKoUDBwECAQECA0MABED697k+FtrKXJHiIVIVWYc8
rSmbRdBlpll2u6xvclxjI6AHs9em9AwpjX4BwH60zUpqXtqbTOYBtCDUAqR5oIRN
-----END PUBLIC KEY-----
bash-5.1$

Ahora que tiene el certificado y su clave privada, así como el certificado de CA, puede ponerlos todos juntos en un contenedor PKCS # 12 seguro.

Trabajar con un contenedor PKCS # 12 seguro

Trabajando con criptografía rusa, al crear un contenedor PKCS # 12 seguro, por supuesto, guíese por las Recomendaciones TK-26 , que describen la formación de contenedores de claves de transporte para claves creadas de acuerdo con GOST R 34.10.

En base a esto, el comando para crear un contenedor PKCS # 12 se vería así:

certtool --to-p12  --pkcs-cipher=gost28147-tc26z --hash streebog-512 [--inder] [--ask-pass | --password <  >]  [--p12-name "<friendly name>"]  --load-certificate <  > --load-privkey <    >  --load-ca-certificate <   > [--outder] [--outfile <   >]

Tenga en cuenta que si no se especifican las opciones --password y / o --p12-name, se le solicitarán en la línea de comando.

Creemos un contenedor PKCS # 12:

$ certtool --to-p12  --pkcs-cipher=gost28147-tc26z --hash streebog-512  --load-certificate certUser.pem  --load-privkey privkeyUser.pem  --load-ca-certificate certCA.pem --p12-name "TectP12GnuTLS" --password "01234567"        
Generating a PKCS #12 structure...
Loading private key list...
Loaded 1 private keys.

Contenedor PKCS # 12 en formato PEM

bash-5.1$

Cabe señalar que hoy en día el contenedor seguro PKCS # 12 es popular.

El contenedor PKCS # 12 creado por la utilidad certtool ha sido analizado exitosamente por la utilidad openssl con soporte GOST. Después de eso, decidimos usar la utilidad cryptoarmpkcs , que le permite extraer el certificado y su clave privada del contenedor PKCS # 12 e instalarlos en el token PKCS # 11, así como, usando el propio contenedor, firmar documentos.

Y luego tuve que enfrentar una sorpresa desagradable: la

sorpresa es que, al crear un contenedor PKCS # 12, GnuTLS no tiene en cuenta los últimos requisitos de TK-26, que dicen:

La integridad del TCC se garantiza mediante el algoritmo HMAC_GOSTR3411_2012_512 de acuerdo con R 50.1.113— 2016.

La utilidad certtool utiliza el algoritmo HMAC_GOSTR3411_2012_256, que está codificado en el código de la biblioteca. Pero este es un error que se puede solucionar fácilmente. Para hacer esto, basta con cambiar la línea en la función _gnutls_pkcs_generate_key (archivo ~ / gnutls-xxx / lib / x509 / pkcs7-crypt.c)

kdf_param->mac = GNUTLS_MAC_STREEBOG_256;

por línea

kdf_param->mac = GNUTLS_MAC_STREEBOG_512;

Después de realizar este cambio, todo encajó y el contenedor PKCS # 12 de GnuTLS fue adoptado por la utilidad cryptoarmpkcs:

El ejemplo anterior de un contenedor PKCS # 12 (----- BEGIN PKCS12 ----- ... - ---- END PKCS12- ----) se formó teniendo en cuenta los requisitos de TC-26.

Entonces, al tener un contenedor PKCS # 12 y la utilidad cryptoarmpkcs, puede generar varios tipos de firmas para documentos (ver captura de pantalla). Pero ahora estamos interesados en la formación de una firma electrónica utilizando la utilidad certtool.

Firma electrónica PKCS # 7

El comando para generar una firma electrónica se ve así:

$certtool --p7-sign [--p7-time] [--inder] --load-privkey <   > --load-certificate <  > --infile <  > [--outder] [--outfile <  >]

Solo la opción --p7-time requiere una aclaración, cuya presencia indica que se incluya en la propia firma (estructura PKCS # 7) el momento de generar la firma electrónica.

Por cierto, para probar la formación de una firma electrónica, el certificado y su clave privada se pueden tomar del contenedor PKCS # 12 dado en la sección anterior:

$certtool --p12-info --no-text --infile <,     PKCS#12>

Si el certificado de clave privada del usuario se guardó en el archivo privkey.pem y el certificado de usuario en el archivo usercert.pem, entonces firmar el documento desde el archivo doc.txt con la firma guardada en el archivo signdoc.sig se verá así :

$certtool --p7-sign --loadcertificate usercert.pem --load-privkey privkey.pem --infile doc.txt --outfile signdoc.sig
Enter password
$

Si la firma está adjunta (y por defecto es la que se crea), entonces puede extraer el documento firmado con el siguiente comando:

$certtool --p7-info --p7-show-data [--inder] --infile <  >

Para ver información sobre una firma electrónica, use la marca --p7-info:

$certtool --p7-info [--inder]

Para verificar la propia firma electrónica, se requiere un certificado de firmante:

$certtool --p7-verify [--inder] --load-certificate <   > --infile <   >

Sí, la opción --p7-detached-sign se usa para generar una firma separada

Epílogo

No tenía la intención de dar una descripción completa de la utilidad certtool, y mucho menos escribir la documentación de GnuTLS. Los autores lo hicieron bien sin mí.

El objetivo era mostrar que existe una herramienta como GnuTLS y que se puede utilizar junto con OpenSSL o GCrypt para trabajar con PKI basada en criptografía rusa. Hasta qué punto fue posible esto, lo juzgará el lector.

Infraestructura de clave pública basada en la criptografía rusa: GnuTLS como alternativa a OpenSSL