Guía de configuración del kit de herramientas PQC

Esta guía está diseñada para el kit de herramientas de PQC. Para leer instrucciones sobre cómo configurar el kit de herramientas dockerizadas PQC, consulte Guía del kit de herramientas dockerizadas PQC.

Introducción

El kit de herramientas criptográfico poscuántico (PQC) de DigiCert contiene todo lo necesario para crear un certificado TLS híbrido. Este certificado híbrido usa un algoritmo criptográfico poscuántico junto con un algoritmo criptográfico clásico, lo que le permitirá probar la viabilidad de implementar certificados TLS híbridos poscuánticos, al mismo tiempo que también mantiene una compatibilidad con versiones anteriores.

Para esta primera iteración, el algoritmo criptográfico poscuántico se combina con un algoritmo criptográfico de curva elíptica.

Esta guía de configuración lo guiará en el uso del kit de herramientas de PQC de DigiCert para lo siguiente.

  • Aplicar la revisión PQC ISARA a los archivos de código fuente OpenSSL.
  • Compilar su programa OpenSSL modificado.
  • Generar claves criptográficas poscuánticas.
  • Cree una cadena completa de certificados híbrida, incluidos los certificados raíz, intermedio y de servidor.
  • Pruebe los certificados usando las utilidades s_server y s_client de OpenSSL.

El kit de herramientas de PQC de DigiCert está disponible para su descarga para todos los clientes Secure Site Pro. Conozca más sobre qué se incluye con cada certificado Secure Site Pro.

Contenido del kit de herramientas de PQC

El kit de herramientas de PQC de DigiCert contiene estos archivos:

  • Conector OpenSSL catalizador ISARA.
  • Archivo openssl.cnf modificado
  • Archivos de configuración del certificado.
  • Ejemplo de cadena híbrida de certificados.

Requisitos previos

Antes de usar esta guía, vele por satisfacer estos requisitos previos:

  • Acceso a los archivos de recursos del kit de herramientas de PQC de DigiCert
  • Ubuntu 16.04 o posterior de 64 bits (esta guía se confeccionó usando Ubuntu 18.04 LTS)
  • Usuario no raíz con acceso sudo

Para proteger su sistema o su entorno de producción y no tener problemas, le recomendamos seguir estos pasos usando un entorno de pruebas o virtual.

Preparar su entorno

Antes de descargar y revisar los archivos, prepare su entorno.

Primero, instale las dependencias y las herramientas necesarias.

bash
sudo apt-get -y update
sudo apt-get -y upgrade
sudo apt-get -y install curl unzip make cmake gcc wget zlib1g-dev libjansson-dev

Luego, cree la estructura del directorio donde descargará y compilará archivos de código fuente y recursos del kit de herramientas.

bash
mkdir -p /app/digicert-pqc/connector
mkdir -p /app/digicert-pqc/certs/configs
mkdir /app/resources

Descargar y extraer el kit de herramientas

Ahora descargue el kit de herramientas de PQC de DigiCert y extraiga su contenido.

Descargar el kit de herramientas de PQC

  1. Inicie sesión en su cuenta de CertCentral.

  2. En el menú lateral, haga clic en Certificados > Pedidos.

  3. En la página Pedidos, localice su pedido de certificado Secure Site pro y haga clic en su número de pedido.

  4. En la página de detalles del pedido de certificados, haga clic en Kit de herramientas de PQC.

  5. En la página Criptografía poscuántica (PQC), haga clic en Descargar el kit de herramientas de PQC ISARA y guárdelo en el directorio /app/resources.

Extraer archivos del kit de herramientas de PQC

Luego, extraiga el contenido del kit de herramientas.

bash
cd /app/resources
unzip ./DigiCert_PQC_Toolkit.zip

El kit de herramientas de PQC contiene el archivo Conector OpenSSL ISARA. Extráigalo en /app/digicert-pqc/connector.

bash
cd /app/digicert-pqc/connector
tar xzvf /app/resources/digicert-pqc-toolkit_2019-07-26/openssl_connector-Linux-2019-05-27.tgz

Revisar y compilar OpenSSL

Después de que haya configurado el entorno y extraído todos los archivos, revise y compile OpenSSL.

Para comenzar, descargue la versión 1.0.2r de OpenSSL en el directorio /app/resources.

bash
cd /app/resources
wget https://www.openssl.org/source/old/1.0.2/openssl-1.0.2r.tar.gz

Luego, extraiga los archivos de código fuente en el directorio /app/digicert-pqc.

bash
cd /app/digicert-pqc
tar xzvf /app/resources/openssl-1.0.2r.tar.gz

Ahora aplique la revisión OpenSSL ISARA en los archivos de código fuente extraídos. Esto hace todos los cambios necesarios para que OpenSSL genere e interprete los algoritmos criptográficos seguros en términos cuánticos.

bash
cd openssl-1.0.2r/
patch -p2 < ../connector/OpenSSL_1_0_2r_ISARA.patch

Después de que termina la revisión, reemplace el archivo openssl.cnf que ya está por la versión modificada del kit de herramientas. En este archivo de configuración modificado hay una entrada de motor dinámico que apunta a ISARA OpenSSL IQREngine.

bash
cp /app/resources/digicert-pqc-toolkit_2019-07-26/openssl.cnf ./apps

Ahora deberá editar el archivo de configuración modificado para que apunte a la ubicación ISARA OpenSSL IQREngine.

  1. Abra el archivo copiado openssl.cnf en su editor de texto preferido.

bash
vi ./apps/openssl.cnf
  1. Ubique la entrada dynamic_path en la línea 32.

  2. Cambie la entrada a esto:

bash
dynamic_path = /app/digicert-pqc/connector/lib/libiqre_engine.so
  1. Guarde los cambios y cierre el archivo.

Dado que está creando una biblioteca OpenSSL compartida, deberá configurar las rutas no estándares antes de compilar los archivos de código fuente.

bash
./config --prefix=/app/digicert-pqc/pqpki-openssl-1.0.2r --openssldir=/app/digicert-pqc/pqpki-openssl-1.0.2r shared

Ahora ejecute cada uno de los comandos que aparecen a continuación, de a uno a la vez, para compilar los archivos de código fuente modificados.

bash
make depend
make all
sudo make install

Después de compilar correctamente el código fuente modificado de OpenSSL, use la variable LD_LIBRARY_PATH para especificar las dos ubicaciones dinámicas de la biblioteca. Esto le dice a su sistema dónde encontrar tanto sus bibliotecas compartidas OpenSSL modificadas como el motor PQC ISARA usado para manipular algoritmos criptográficos seguros en términos cuánticos.

bash
export LD_LIBRARY_PATH=/app/digicert-pqc/pqpki-openssl-1.0.2r:/app/digicert-pqc/connector/lib

Si su sistema ya usa la variable LD_LIBRARY_PATH, puede anexar :$LD_LIBRARY_PATH al comando antes mencionado para no agregar destructivamente las nuevas rutas.

Crear una cadena híbrida de certificados

Ahora tiene un programa OpenSSL capaz de generar y decodificar algoritmos criptográficos seguros en términos cuánticos. Está listo para crear una cadena híbrida completa de certificados (certificados raíz, intermedio y de servidor), así puede probar su funcionalidad.

Primero, copie los archivos de configuración del certificado que se incluyeron en el kit de herramientas de PQC al directorio /app/digicert-pqc/certs. Estos archivos de configuración contienen toda la información necesaria para generar cada solicitud de certificado y cada certificado.

bash
cd /app/digicert-pqc/certs
cp /app/resources/digicert-pqc-toolkit_2019-07-26/certificates/root_req.cfg ./configs
cp /app/resources/digicert-pqc-toolkit_2019-07-26/certificates/intermediate_req.cfg ./configs
cp /app/resources/digicert-pqc-toolkit_2019-07-26/certificates/server_req.cfg ./configs

Generar claves privadas y públicas

Luego, genere claves privadas seguras en términos cuánticos para cada certificado de la cadena y asegúrese de usar el programa OpenSSL modificado y IQREngine.

Clave privada raíz:

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl genpkey -engine IQREngine -algorithm xmss -pkeyopt tree_height:10 -pkeyopt strategy:cpu_constrained -pkeyopt state_filename:xmss_catalyst_mixed_chain_root_private_key_state.bin -out xmss_catalyst_mixed_chain_root_private_key.pem

Clave privada intermedia:

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl genpkey -engine IQREngine -algorithm dilithium -pkeyopt parameter_set:A -out dilithium_catalyst_mixed_chain_intermediate_private_key.pem

Clave privada de servidor:

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl genpkey -engine IQREngine -algorithm rainbow -pkeyopt parameter_set:A -out rainbow_catalyst_mixed_chain_private_key.pem

Una vez que haya generado la clave privada de cada certificado, extraiga sus claves públicas.

Clave pública raíz:

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl pkey -engine IQREngine -in xmss_catalyst_mixed_chain_root_private_key.pem -pubout -out xmss_catalyst_mixed_chain_root_public_key.pem

Clave pública intermedia:

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl pkey -engine IQREngine -in dilithium_catalyst_mixed_chain_intermediate_private_key.pem -pubout -out dilithium_catalyst_mixed_chain_intermediate_public_key.pem

Clave pública de servidor:

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl pkey -engine IQREngine -in rainbow_catalyst_mixed_chain_private_key.pem -pubout -out rainbow_catalyst_mixed_chain_public_key.pem

Elija una curva para el certificado en cadena mixto ECC.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl ecparam -out ecdsa_catalyst_mixed_chain_parameters.pem -name secp384r1

Crear una CSR y generar certificados

Cuando haya generado todas las claves criptográficas, estará listo para crear una CSR para cada certificado de la cadena y para generar certificados raíz, intermedios y de servidor.

En primer lugar, cree una CSR para el emisor raíz.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl req -new -newkey ec:ecdsa_catalyst_mixed_chain_parameters.pem -keyout ecdsa_without_xmss_catalyst_mixed_chain_root_private_key.pem -out ecdsa_without_xmss_x509_catalyst_mixed_chain_root_req.pem -config ./configs/root_req.cfg -nodes

Luego deberá crear un certificado X509 autofirmado para la raíz.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl x509 -req -set_serial 8026 -extfile ./configs/root_req.cfg -in ecdsa_without_xmss_x509_catalyst_mixed_chain_root_req.pem -signkey ecdsa_without_xmss_catalyst_mixed_chain_root_private_key.pem -out ecdsa_without_xmss_x509_catalyst_mixed_chain_root_certificate.pem

Después de eso, amplíe el certificado raíz a un certificado raíz híbrido.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl x509QSDirectExtend -engine /app/digicert-pqc/connector/lib/libiqre_engine.so -x509in ecdsa_without_xmss_x509_catalyst_mixed_chain_root_certificate.pem -x509out xmss_ecdsa_x509_catalyst_mixed_chain_root_certificate.pem -privin ecdsa_without_xmss_catalyst_mixed_chain_root_private_key.pem -pubqs xmss_catalyst_mixed_chain_root_public_key.pem -privqs xmss_catalyst_mixed_chain_root_private_key.pem::xmss_catalyst_mixed_chain_root_private_key_state.bin -privqs_engine

Ya puede crear una CSR para el certificado intermedio.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl req -new -newkey ec:ecdsa_catalyst_mixed_chain_parameters.pem -keyout ecdsa_without_dilithium_catalyst_mixed_chain_intermediate_private_key.pem -out ecdsa_without_dilithium_x509_catalyst_mixed_chain_intermediate_req.pem -config ./configs/intermediate_req.cfg -nodes

Amplíe la CSR de certificado intermedio a una CSR híbrida.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl reqQSExtend -engine /app/digicert-pqc/connector/lib/libiqre_engine.so -reqin ecdsa_without_dilithium_x509_catalyst_mixed_chain_intermediate_req.pem -reqout dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_req.pem -privin ecdsa_without_dilithium_catalyst_mixed_chain_intermediate_private_key.pem -pubqs dilithium_catalyst_mixed_chain_intermediate_public_key.pem -privqs dilithium_catalyst_mixed_chain_intermediate_private_key.pem

Luego genere el certificado intermedio.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl x509 -req -set_serial 8014 -extfile ./configs/intermediate_req.cfg -in dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_req.pem -CA xmss_ecdsa_x509_catalyst_mixed_chain_root_certificate.pem -CAkey ecdsa_without_xmss_catalyst_mixed_chain_root_private_key.pem -out ecdsa_without_dilithium_x509_catalyst_mixed_chain_intermediate_certificate.pem

Amplíe el certificado intermedio a un certificado intermedio híbrido.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl x509QSExtend -engine /app/digicert-pqc/connector/lib/libiqre_engine.so -x509in ecdsa_without_dilithium_x509_catalyst_mixed_chain_intermediate_certificate.pem -x509out dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_certificate.pem -reqin dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_req.pem -privqs xmss_catalyst_mixed_chain_root_private_key.pem::xmss_catalyst_mixed_chain_root_private_key_state.bin -privqs_engine

Ahora que generó los certificados raíz e intermedio, el siguiente paso es generar el certificado de servidor.

En primer lugar, debe crear una CSR para el certificado de servidor.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl req -new -newkey ec:ecdsa_catalyst_mixed_chain_parameters.pem -keyout ecdsa_without_rainbow_catalyst_mixed_chain_private_key.pem -out ecdsa_without_rainbow_x509_catalyst_mixed_chain_req.pem -config ./configs/server_req.cfg -nodes

Después amplíe la CSR de certificado de servidor a una CSR híbrida.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl reqQSExtend -engine /app/digicert-pqc/connector/lib/libiqre_engine.so -reqin ecdsa_without_rainbow_x509_catalyst_mixed_chain_req.pem -reqout rainbow_ecdsa_x509_catalyst_mixed_chain_server_req.pem -privin ecdsa_without_rainbow_catalyst_mixed_chain_private_key.pem -pubqs rainbow_catalyst_mixed_chain_public_key.pem -privqs rainbow_catalyst_mixed_chain_private_key.pem

Luego de eso, puede generar el certificado de servidor.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl x509 -req -set_serial 8015 -req -extfile ./configs/server_req.cfg -in rainbow_ecdsa_x509_catalyst_mixed_chain_server_req.pem -CA dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_certificate.pem -CAkey ecdsa_without_dilithium_catalyst_mixed_chain_intermediate_private_key.pem -out ecdsa_without_rainbow_x509_catalyst_mixed_chain_certificate.pem

Por último, amplíe el certificado de servidor a un certificado de servidor híbrido.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl x509QSExtend -engine /app/digicert-pqc/connector/lib/libiqre_engine.so -x509in ecdsa_without_rainbow_x509_catalyst_mixed_chain_certificate.pem -x509out rainbow_ecdsa_x509_catalyst_mixed_chain_server_certificate.pem -reqin rainbow_ecdsa_x509_catalyst_mixed_chain_server_req.pem -privqs dilithium_catalyst_mixed_chain_intermediate_private_key.pem

Verificar la cadena de certificados

Una vez que haya creado todos los certificados, estará listo para confirmar que tiene una cadena de certificados híbrida funcional.

En primer lugar, confirme que la cadena híbrida funcione mediante la criptografía de legado.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl verify -engine IQREngine -verbose -CAfile xmss_ecdsa_x509_catalyst_mixed_chain_root_certificate.pem -untrusted dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_certificate.pem rainbow_ecdsa_x509_catalyst_mixed_chain_server_certificate.pem

Debería de ver este resultado:

bash
engine "IQREngine" set.
rainbow_ecdsa_x509_catalyst_mixed_chain_server_certificate.pem: OK

Luego, confirme que la cadena de certificados híbrida funcione mediante la criptografía cuántica segura.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl x509QSVerify -engine /app/digicert-pqc/connector/lib/libiqre_engine.so -root xmss_ecdsa_x509_catalyst_mixed_chain_root_certificate.pem -untrusted dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_certificate.pem -cert rainbow_ecdsa_x509_catalyst_mixed_chain_server_certificate.pem

Lo que debería de generar este resultado:

bash
engine "IQREngine" set.
2 : ok : /C=US/ST=Utah/L=Lehi/O=DigiCert, Inc./OU=DigiCert PQC/CN=DigiCert PQC Root
1 : ok : /C=US/ST=Utah/L=Lehi/O=DigiCert, Inc./OU=DigiCert PQC/CN=DigiCert PQC Test Intermediate CA
0 : ok : /C=US/ST=Utah/L=Lehi/O=DigiCert, Inc./OU=DigiCert PQC/CN=digicert.pqc
Success!!

Y para confirmar que se crearon todos los archivos, ejecute un comando ls. Si tuvo éxito, debería ver un resultado como este:

bash
configs
dilithium_catalyst_mixed_chain_intermediate_private_key.pem
dilithium_catalyst_mixed_chain_intermediate_public_key.pem
dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_certificate.pem
dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_req.pem
ecdsa_catalyst_mixed_chain_parameters.pem
ecdsa_without_dilithium_catalyst_mixed_chain_intermediate_private_key.pem
ecdsa_without_dilithium_x509_catalyst_mixed_chain_intermediate_certificate.pem
ecdsa_without_dilithium_x509_catalyst_mixed_chain_intermediate_req.pem
ecdsa_without_rainbow_catalyst_mixed_chain_private_key.pem
ecdsa_without_rainbow_x509_catalyst_mixed_chain_certificate.pem
ecdsa_without_rainbow_x509_catalyst_mixed_chain_req.pem
ecdsa_without_xmss_catalyst_mixed_chain_root_private_key.pem
ecdsa_without_xmss_x509_catalyst_mixed_chain_root_certificate.pem
ecdsa_without_xmss_x509_catalyst_mixed_chain_root_req.pem
rainbow_catalyst_mixed_chain_private_key.pem
rainbow_catalyst_mixed_chain_public_key.pem
rainbow_ecdsa_x509_catalyst_mixed_chain_server_certificate.pem
rainbow_ecdsa_x509_catalyst_mixed_chain_server_req.pem
xmss_catalyst_mixed_chain_root_private_key.pem
xmss_catalyst_mixed_chain_root_private_key_state.bin
xmss_catalyst_mixed_chain_root_public_key.pem
xmss_ecdsa_x509_catalyst_mixed_chain_root_certificate.pem

Pruebe su cadena de certificados usando s_server y s_client

Para probar su cadena híbrida de certificados seguros en términos cuánticos, use las utilidades s_server y s_client de OpenSSL. Para usar ambas utilidades de forma simultánea, abre dos sesiones de terminal: una para el servidor y otra para el cliente.

Primero, agregue el valor CN del certificado de servidor a su archivo de hosts.

bash
echo "$(hostname -I) digicert.pqc" | sudo tee -a /etc/hosts

Luego, asegúrese de estar en el directorio /app/digicert-pqc/certs.

bash
cd /app/digicert-pqc/certs

Posteriormente, en una de sus terminales abiertas, inicie el servidor.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl s_server -engine IQREngine -cert dilithium_ecdsa_x509_catalyst_mixed_chain_intermediate_certificate.pem -certform PEM -key dilithium_catalyst_mixed_chain_intermediate_private_key.pem -keyform PEM -debug -tls1_2

Después de ejecutar el comando antes mencionado, debería ver este resultado:

bash
engine "IQREngine" set.
Using default temp DH parameters
ACCEPT

Luego, cambiar a la segundo ventana de terminal y asegúrese de estar en el directorio /app/digicert-pqc/certs.

bash
cd /app/digicert-pqc/certs

Posteriormente, use la utilidad s_client para conectarse al servidor que se está ejecutando.

bash
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl s_client -engine IQREngine -CAfile xmss_ecdsa_x509_catalyst_mixed_chain_root_certificate.pem -showcerts -tls1_2 -cipher 'ECDHE-NHDH-DILM-AES256-GCM-SHA384'

Si todo está configurado adecuadamente, en la ventana terminal donde se está ejecutando la utilidad s_client, debería ver este resultado:

bash
engine "IQREngine" set.
CONNECTED(00000003)
depth=1 C = US, ST = Utah, L = Lehi, O = "DigiCert, Inc.", OU = DigiCert PQC, CN = DigiCert PQC Root
verify return:1
depth=0 C = US, ST = Utah, L = Lehi, O = "DigiCert, Inc.", OU = DigiCert PQC, CN = DigiCert PQC Test Intermediate CA
verify return:1
---
Certificate chain
 0 s:/C=US/ST=Utah/L=Lehi/O=DigiCert, Inc./OU=DigiCert PQC/CN=DigiCert PQC Test Intermediate CA
   i:/C=US/ST=Utah/L=Lehi/O=DigiCert, Inc./OU=DigiCert PQC/CN=DigiCert PQC Root
-----BEGIN CERTIFICATE-----
[...]
-----END CERTIFICATE-----
---
Server certificate
subject=/C=US/ST=Utah/L=Lehi/O=DigiCert, Inc./OU=DigiCert PQC/CN=DigiCert PQC Test Intermediate CA
issuer=/C=US/ST=Utah/L=Lehi/O=DigiCert, Inc./OU=DigiCert PQC/CN=DigiCert PQC Root
---
No client certificate CA names sent
Peer signing digest: SHA512
Server Temp Key: ECDH, P-256, 256 bits
---
SSL handshake has read 9868 bytes and written 2331 bytes
---
New, TLSv1/SSLv3, Cipher is ECDHE-NHDH-DILM-AES256-GCM-SHA384
Server public key is 521 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
SSL-Session:
    Protocol  : TLSv1.2
    Cipher    : ECDHE-NHDH-DILM-AES256-GCM-SHA384
    Session-ID: {{Session-ID}}
    Session-ID-ctx: 
    Master-Key: {{Master-Key}}
    Key-Arg   : None
    PSK identity: None
    PSK identity hint: None
    SRP username: None
    TLS session ticket lifetime hint: 7200 (seconds)
    TLS session ticket:
    [...]


    Start Time: 1563994600
    Timeout   : 7200 (sec)
    Verify return code: 0 (ok)
---

En la ventana terminal donde se está ejecutando la utilidad s_server, debería ver este resultado:

bash
read from 0x5581e0750b80 [0x5581e07656f3] (5 bytes => 5 (0x5))
0000 - 16 03 01 00 96                                    .....
read from 0x5581e0750b80 [0x5581e07656f8] (150 bytes => 150 (0x96))
0000 - 01 00 00 92 03 03 d9 c0-5a 73 35 d0 4e f2 31 f6   ........Zs5.N.1.
[...]
write to 0x5581e0750b80 [0x5581e076e100] (71 bytes => 71 (0x47))
0000 - 16 03 03 00 42 02 00 00-3e 03 03 c2 3b df 2f 01   ....B...>...;./.
[...]
write to 0x5581e0750b80 [0x5581e0769c43] (4953 bytes => 4953 (0x1359))
0000 - 16 03 03 13 54 0b 00 13-50 00 13 4d 00 13 4a 30   ....T...P..M..J0
[...]
write to 0x5581e0750b80 [0x5581e0769c43] (4609 bytes => 4609 (0x1201))
0000 - 16 03 03 11 fc 0c 00 11-f8 03 00 17 41 04 0d 97   ............A...
[...]
write to 0x5581e0750b80 [0x5581e076e100] (9 bytes => 9 (0x9))
0000 - 16 03 03 00 04 0e 00 00-00                        .........
read from 0x5581e0750b80 [0x5581e07656f3] (5 bytes => 5 (0x5))
0000 - 16 03 03 08 48                                    ....H
read from 0x5581e0750b80 [0x5581e07656f8] (2120 bytes => 2120 (0x848))
0000 - 10 00 08 44 41 04 29 0a-07 84 0c f3 a4 e4 3e d1   ...DA.).......>.
[...]
read from 0x5581e0750b80 [0x5581e07656f3] (5 bytes => 5 (0x5))
0000 - 14 03 03 00 01                                    .....
read from 0x5581e0750b80 [0x5581e07656f8] (1 bytes => 1 (0x1))
0000 - 01                                                .
read from 0x5581e0750b80 [0x5581e07656f3] (5 bytes => 5 (0x5))
0000 - 16 03 03 00 28                                    ....(
read from 0x5581e0750b80 [0x5581e07656f8] (40 bytes => 40 (0x28))
0000 - e1 d7 30 8b 12 ef d1 dc-31 90 97 d0 0e 54 9c aa   ..0.....1....T..
[...]
write to 0x5581e0750b80 [0x5581e076e100] (175 bytes => 175 (0xAF))
0000 - 16 03 03 00 aa 04 00 00-a6 00 00 1c 20 00 a0 02   ............ ...
[...]
write to 0x5581e0750b80 [0x5581e076e100] (6 bytes => 6 (0x6))
0000 - 14 03 03 00 01 01                                 ......
write to 0x5581e0750b80 [0x5581e076e100] (45 bytes => 45 (0x2D))
0000 - 16 03 03 00 28 d0 99 97-94 6d a1 5c f8 b0 c0 65   ....(....m.\...e
[...]
-----BEGIN SSL SESSION PARAMETERS-----
[...]
-----END SSL SESSION PARAMETERS-----
Shared ciphers:ECDHE-NHDH-DILM-AES256-GCM-SHA384:ECDHE-NHDH-SIDH-DILM-AES256-GCM-SHA384
Signature Algorithms: RSA+SHA512:DSA+SHA512:ECDSA+SHA512:RSA+SHA384:DSA+SHA384:ECDSA+SHA384:RSA+SHA256:DSA+SHA256:ECDSA+SHA256:RSA+SHA224:DSA+SHA224:ECDSA+SHA224:RSA+SHA1:DSA+SHA1:ECDSA+SHA1:HSS+SHA512:XMSS+SHA512:XMSSmt+SHA512:DILITHIUM+SHA512:DILITHIUM+SHA512:0xE0+SHA512
Shared Signature Algorithms: RSA+SHA512:DSA+SHA512:ECDSA+SHA512:RSA+SHA384:DSA+SHA384:ECDSA+SHA384:RSA+SHA256:DSA+SHA256:ECDSA+SHA256:RSA+SHA224:DSA+SHA224:ECDSA+SHA224:RSA+SHA1:DSA+SHA1:ECDSA+SHA1:HSS+SHA512:DILITHIUM+SHA512:DILITHIUM+SHA512
Supported Elliptic Curve Point Formats: uncompressed:ansiX962_compressed_prime:ansiX962_compressed_char2
Supported Elliptic Curves: P-256:P-521:brainpoolP512r1:brainpoolP384r1:P-384:brainpoolP256r1:secp256k1:B-571:K-571:K-409:B-409:K-283:B-283:0xFE01
Shared Elliptic curves: P-256:P-521:brainpoolP512r1:brainpoolP384r1:P-384:brainpoolP256r1:secp256k1:B-571:K-571:K-409:B-409:K-283:B-283:UNDEF
CIPHER is ECDHE-NHDH-DILM-AES256-GCM-SHA384
Secure Renegotiation IS supported

¡Felicitaciones! Ha creado correctamente una cadena híbrida de certificados seguros en términos cuánticos usando el kit de herramientas de PQC de DigiCert y el motor Conector OpenSSL catalizador ISARA.