Guia de configuração do kit de ferramentas PQC

Este guia é para o kit de ferramentas PQC. Para obter instruções sobre como configurar o kit de ferramentas dockerizadas DigiCert PQC, consulte o guia do kit de ferramentas dockerizadas PQC.

Introdução

O kit de ferramentas criptográficas pós-quânticas (PQC) da DigiCert possui tudo que é necessário para criar um certificado TLS híbrido. Este certificado híbrido usa um algoritmo criptográfico pós-quântico emparelhado com um algoritmo criptográfico clássico, permitindo testar a viabilidade de implantação de certificados TLS híbridos e pós-quânticos enquanto também mantém compatibilidade regressiva.

Para esta primeira iteração, o algoritmo criptográfico pós-quântico é emparelhado com um algoritmo criptográfico da curva elíptica.

Este guia de configuração mostra o uso do kit de ferramentas DigiCert PQC para:

  • Aplicar o ISARA PQC Patch a arquivos de origem do OpenSSL.
  • Compilar seu programa OpenSSL modificado.
  • Gerar chaves criptográficas pós-quânticas.
  • Criar uma cadeia completa de certificados híbridos, incluindo certificados raiz, intermediários e de servidor.
  • Testar os certificados usando utilitários s_server e s_client do OpenSSL.

O kit de ferramentas PQC da DigiCert está disponível para download para todos os clientes Secure Site Pro. Saiba mais sobre o que foi incluído com cada certificado Secure Site Pro.

Conteúdo do kit de ferramentas PQC

O kit de ferramentas PQC da DigiCert possui estes arquivos:

  • ISARA Catalyst OpenSSL Connector
  • openssl.cnf modificado
  • Arquivos de configuração do certificado
  • Cadeia de certificados híbridos de exemplo

Pré-requisitos

Antes de usar este guia, certifique-se de que os pré-requisitos foram cumpridos:

  • Acesso aos arquivos de recurso do kit de ferramentas PQC da DigiCert
  • Ubuntu 16.04 de 64 bits ou superior (este guia foi escrito usando Ubuntu 18.04 LTS)
  • Usuário não raiz com acesso sudo

Para proteger seu sistema ou ambiente de produção contra problemas, recomendamos que você siga estas etapas usando uma sandbox ou ambiente virtual.

Preparar seu ambiente

Antes de baixar e aplicar patch nos arquivos, prepare o seu ambiente.

Primeiro, instale as dependências e ferramentas necessárias.

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

Depois, crie a estrutura de diretório em que você baixará e compilará arquivos de origem e recursos de kit de ferramentas.

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

Baixar e extrair kit de ferramentas

Agora, baixe o kit de ferramentas PQC da DigiCert e extraia seu conteúdo.

Baixar kit de ferramentas PQC

  1. Entre na sua conta da CertCentral.

  2. No menu da barra lateral, clique em Certificados > Pedidos.

  3. Na página Pedidos, localize o seu pedido de certificado Secure Site Pro e clique no seu número de pedido.

  4. Na página de detalhes do pedido do certificado, clique em kit de ferramentas PQC.

  5. Na página criptografia pós-quântica (PQC), clique em Baixar o kit de ferramentas ISARA PQC e salve o kit de ferramentas no diretório /app/resources.

Extrair arquivos do kit de ferramentas PQC

Depois, extraia o conteúdo do kit de ferramentas.

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

O kit de ferramentas PQC possui o arquivo ISARA OpenSSL Connector. Extraia isso para /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

Aplique patch e compile OpenSSL

Depois de configurar o ambiente e extrair todos os arquivos, faça patch e compile OpenSSL.

Para começar, baixe a versão OpenSSL 1.0.2r ao diretório /app/resources.

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

Depois, extraia os arquivos de origem para o diretório /app/digicert-pqc.

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

Agora, aplique o patch ISARA OpenSSL aos arquivos de origem extraídos. Isso faz todas as modificações necessárias para o OpenSSL gerar e interpretar algoritmos criptográficos seguros à tecnologia quântica.

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

Após a conclusão do patch, substitua o arquivo openssl.cnf existente pela versão modificada do kit de ferramentas. Este arquivo de configuração modificado contém uma entrada de mecanismo dinâmico que aponta para o ISARA OpenSSL IQREngine.

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

Agora você precisa editar o arquivo de configuração modificado para que ele aponte para o local do ISARA OpenSSL IQREngine.

  1. Abra o arquivo openssl.cnf copiado no seu editor de texto preferido.

bash
vi ./apps/openssl.cnf
  1. Localize a dynamic_pathentrada na linha 32.

  2. Mude a entrada para isso:

bash
dynamic_path = /app/digicert-pqc/connector/lib/libiqre_engine.so
  1. Salve e feche o arquivo.

Como você está criando uma biblioteca compartilhada OpenSSL, será necessário configurar os caminhos não padrão antes de compilar os arquivos de origem.

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

Agora, execute cada um dos comandos abaixo, um por vez, para compilar os arquivos de origem modificados.

bash
make depend
make all
sudo make install

Após compilar com êxito a origem OpenSSL modificada, use a variável LD_LIBRARY_PATH para especificar duas localizações dinâmicas de biblioteca. Isso diz para o seu sistema onde encontrar bibliotecas compartilhadas OpenSSL modificadas e o motor ISARA PQC usado para lidar com algoritmos criptográficos seguros à tecnologia quântica.

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

Se o seu sistema já usa a variável LD_LIBRARY_PATH, é possível anexar a :$LD_LIBRARY_PATH ao comando acima para adicionar os novos caminhos de forma não destrutiva.

Criar uma cadeia de certificados híbridos

Agora que você tem um programa OpenSSL capaz de gerar e decodificar algoritmos criptográficos seguros contra ameaça quântica. Você está pronto para criar uma cadeia completa de certificados híbridos (certificados raiz, intermediário e servidor), então já é possível testar sua funcionalidade.

Primeiro, copie os arquivos de configuração do certificado que foram incluídos no kit de ferramentas PQC no diretório /app/digicert-pqc/certs. Estes arquivos de configuração possuem todas as informações necessárias para gerar cada solicitação de certificado e 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

Gere chaves públicas e privadas

Depois, gere chaves particulares seguras contra tecnologia quântica para cada certificado na cadeia, certificando-se de usar o programa OpenSSL modificado e o IQREngine.

Chave privada raiz:

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

Chave privada intermediária:

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

Chave privada do 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

Depois de gerar a chave particular de cada certificado, extraia suas chaves públicas.

Chave pública raiz:

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

Chave pública intermediária:

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

Chave pública do 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

Escolha uma curva para o certificado de cadeia mista ECC.

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

Crie CSRs e gere certificados

Com todas as chaves criptográficas geradas, você está pronto para criar um CSR para cada certificado na cadeia e gerar os certificados raiz, intermediário e de servidor.

Primeiro, crie um CSR para o emissor raiz.

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

Em seguida, você precisa criar um certificado X509 autoassinado para a raiz.

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

Depois disso, estenda o certificado raiz para um certificado raiz 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

Agora você pode criar o CSR para o certificado intermediário.

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

Estenda o CSR do certificado intermediário em um CSR híbrido.

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

Em seguida, gere o certificado intermediário.

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

Estenda o certificado intermediário em um certificado intermediário 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

Agora que os certificados raiz e intermediário foram gerados, a próxima etapa é gerar o certificado do servidor.

Primeiro, você precisa criar o CSR para o certificado do 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

Em seguida, estenda o CSR do certificado do servidor para um CSR híbrido.

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

Depois disso, você pode gerar o certificado do 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

E, finalmente, estenda o certificado do servidor para um 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

Verifique a cadeia de certificados

Com todos os certificados criados, você está pronto para verificar se possui uma cadeia de certificados híbridos funcional.

Primeiro, verifique se a cadeia híbrida funciona usando criptografia herdada.

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

Você deve ver esta saída:

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

Em seguida, verifique se a cadeia de certificados híbridos funciona usando criptografia quâ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

O que deve fornecer esta saída:

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

E para verificar se todos os arquivos foram criados, execute um ls comando. Se foi bem-sucedido, você deve ver uma saída assim:

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

Teste sua cadeia de certificados usando s_server e s_client

Para testar a sua cadeia de certificados híbridos seguros contra tecnologia quântica, use os utilitários s_server e s_client do OpenSSL. Para usar ambos os utilitários simultaneamente, abra duas sessões de terminal: uma para o servidor e uma para o cliente.

Primeiro, adicione o valor CN do certificado do servidor ao seu arquivo de host.

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

Depois, certifique-se de estar no diretório /app/digicert-pqc/certs.

bash
cd /app/digicert-pqc/certs

Depois, em um dos seus terminais abertos, inicie o 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

Após executar o comando acima, você deve ver esta saída:

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

Depois, alterne para a janela do segundo terminal, certificando-se de estar no diretório /app/digicert-pqc/certs.

bash
cd /app/digicert-pqc/certs

Depois, use o utilitário s_client para se conectar ao servidor em execução.

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'

Se tudo estiver configurado corretamente, na janela do terminal rodando o utilitário s_client, você deve ver esta saída:

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

Na janela do terminal rodando o utilitário s_server, você deve ver esta saída:

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

Parabéns! Você criou com êxito uma cadeia de certificados híbridos seguros contra tecnologia quântica usando o kit de ferramentas PQC da DigiCert e o motor ISARA Catalyst OpenSSL Connector.