Guida alla configurazione del toolkit PQC

Questa guida riguarda il toolkit PQC. Per le istruzioni sull’impostazione del toolkit ottimizzato per docker PQC DigiCert, consulta la guida per il toolkit ottimizzato per docker PQC.

Introduzione

Il toolkit crittografico post-quantum (PQC) di DigiCert contiene tutto ciò che serve per creare un certificato TLS ibrido. Questo certificato ibrido utilizza un algoritmo crittografico post-quantum, abbinato ad un algoritmo crittografico classico, che ti consente di testare la possibilità di utilizzare i certificati TLS ibridi post-quantum, mantenendo anche la compatibilità con le versioni precedenti.

Per questa prima iterazione, l’algoritmo crittografico post-quantum viene associato ad un algoritmo crittografico di curva ellittica.

Questa guida alla configurazione ti illustra come usare il toolkit PQC DigiCert per:

  • Applicare la patch ISARA PQC ai file sorgente OpenSSL.
  • Compilare il tuo programma OpenSSL modificato.
  • Generare chiavi crittografiche post-quantum.
  • Creare una catena completa di certificati ibridi, fra cui certificati principali, intermedi e server.
  • Testare i certificati usando le utilità s_server e s_client di OpenSSL.

Il toolkit PQC DigiCert è disponibile per il download per tutti i clienti Secure Site Pro. Scopri ulteriori informazioni su ciò che è incluso con ciascun certificato Secure Site Pro.

Contenuto del toolkit PQC

Il toolkit PQC DigiCert contiene questi file:

  • ISARA Catalyst OpenSSL Connector
  • File openssl.cnf modificato
  • File di configurazione certificato
  • Esempio di catena di certificati ibridi

Prerequisiti

Prima di usare questa guida, verifica che questi prerequisiti vengano soddisfatti:

  • Accedi ai file di risorsa del toolkit PQC DigiCert
  • Ubuntu 16.04 o successiva 64 bit (questa guida è stata scritta usando Ubuntu 18.04 LTS)
  • Utente non principale con accesso sudo

Per proteggere il sistema o l’ambiente di produzione dai problemi, ti raccomandiamo di seguire questa procedura usando una sandbox o un ambiente virtuale.

Prepara il tuo ambiente

Prima di scaricare ed eseguire la patch dei file, prepara il tuo ambiente.

Prima di tutto, installa le dipendenze e gli strumenti necessari.

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

Dopodiché, crea la struttura della directory in cui scaricherai e compilerai i file sorgente e le risorse del toolkit.

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

Scarica ed estrai il toolkit

Adesso, scarica il toolkit PQC DigiCert ed estraine il contenuto.

Scarica il toolkit PQC

  1. Accedi al tuo account CertCentral.

  2. Nel menu della barra laterale, fai clic su Certificati > Ordini.

  3. Nella pagina Ordini, individua il tuo ordine di certificato Secure Site Pro e fai clic sul suo numero d’ordine.

  4. Nella pagina dei dettagli dell’ordine certificato, fai clic su Toolkit PQC.

  5. Nella pagina Crittografia post-quantum (PQC), fai clic su Scarica il toolkit ISARA PQC e salva il toolkit nella directory /app/resources.

Estrai i file del toolkit PQC

Dopodiché, estrai il contenuto dal toolkit.

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

Il toolkit PQC contiene l’archivio ISARA OpenSSL Connector. Estrailo in /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

Esegui la patch e compila OpenSSL

Dopo aver configurato l’ambiente ed estratto tutti i file, esegui la patch e compila OpenSSL.

Per iniziare, scarica OpenSSL versione 1.0.2r nella directory /app/resources.

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

Dopodiché, estrai i file sorgente nella directory /app/digicert-pqc.

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

Adesso, applica la patch ISARA OpenSSL ai file sorgente estratti. Tale operazione apporta tutte le modifiche necessarie per OpenSSL per generare e interpretare gli algoritmi crittografici sicuri da un punto di vista quantistico.

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

Al termine della patch, sostituisci il file openssl.cnf esistente con la versione modificata dal toolkit. Questo file di configurazione modificato contiene una voce a motore dinamico che punta ad ISARA OpenSSL IQREngine.

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

Ora devi modificare il file config modificato che punta alla posizione dell’ISARA OpenSSL IQREngine.

  1. Apri il file openssl.cnf copiato ne tuo editor di testo preferito.

bash
vi ./apps/openssl.cnf
  1. Individua la voce dynamic_path sulla riga 32.

  2. Cambia la voce in:

bash
dynamic_path = /app/digicert-pqc/connector/lib/libiqre_engine.so
  1. Salva e chiudi il file.

Poiché stai creando una libreria OpenSSL condivisa, dovrai configurare i percorsi non standard prima di compilare i file sorgente.

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

Adesso, esegui ciascun comando riportato di seguito, uno alla volta, per compilare i file sorgente modificati.

bash
make depend
make all
sudo make install

Dopo aver compilato correttamente la sorgente OpenSSL modificata, usa la variabile LD_LIBRARY_PATH per specificare due posizioni libreria dinamiche. Questa indica al sistema dove trovare sia le librerie condivise OpenSSL modificate che il motore ISARA PQC usato per gestire gli algoritmi crittografici sicuri da un punto di vista quantistico.

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

Se il sistema utilizza già la variabile LD_LIBRARY_PATH, puoi aggiungere :$LD_LIBRARY_PATH al comando sopra descritto per aggiungere i nuovi percorsi in modo non distruttivo.

Crea una catena di certificati ibridi

Adesso, hai un programma OpenSSL in grado di generare e decodificare gli algoritmi crittografici sicuri da un punto di vista quantistico. Sei pronto per creare una catena completa di certificati ibridi (certificati principali, intermedi e server) in modo da poterne testare la funzionalità.

Prima di tutto, copia i file di configurazione certificato inclusi nel toolkit PQC nella directory /app/digicert-pqc/certs. Questi file di configurazione contengono tutte le informazioni necessarie per generare ogni richiesta di certificato e ogni certificato.

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

Genera chiavi private e pubbliche

Dopodiché, genera chiavi private sicure da un punto di vista quantistico per ciascun certificato nella catena, accertandoti di usare il programma OpenSSL modificato e IQREngine.

Chiave privata principale:

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

Chiave privata 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

Chiave privata server:

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 volta che hai generato ciascuna chiave privata del certificato, estrai le relative chiavi pubbliche.

Chiave pubblica principale:

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

Chiave pubblica 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

Chiave pubblica server:

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

Scegli una curva per il certificato a catena mista ECC.

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

Crea CSR e genera certificati

Con tutte le chiavi crittografiche generate, sei pronto per creare una CSR per ciascun certificato nella catena e generare i certificati principale, intermedio e server.

Prima di tutto, crea una CSR per l’emittente principale.

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

Dopodiché, devi creare un certificato X509 autofirmato per il principale.

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

Poi, estendi il certificato principale ad un certificato principale ibrido.

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

Ora puoi creare la CSR per il certificato 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

Estendi la CSR di certificato intermedio ad una CSR ibrida.

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

Dopodiché, genera il certificato 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

Estendi il certificato intermedio ad un certificato intermedio ibrido.

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

Ora che i certificati principale e intermedio sono stati generati, la fase successiva è generare il certificato server.

Prima devi creare la CSR per il certificato server.

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

Dopodiché, estendi la CSR di certificato server ad una CSR ibrida.

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

Poi puoi generare il certificato server.

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

Infine, estendi il certificato server ad un certificato server ibrido.

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

Verifica la catena dei certificati

Con tutti i certificati creati, sei pronto per verificare di avere una catena dei certificati ibrida funzionale.

Prima di tutto, verifica che la catena ibrida funzioni usando la crittografia precedente.

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

Dovresti vedere questo output:

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

Poi, verifica che la catena dei certificati ibrida funzioni usando la crittografia sicura da un punto di vista quantistico.

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

Questa dovrebbe fornire questo output:

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 per verificare che tutti i file sono stati creati, esegui un comando ls. Se tutto è corretto, dovresti vedere un risultato come questo:

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

Testa la tua catena di certificati usando s_server e s_client

Per testare la tua catena di certificati ibridi sicura da un punto di vista quantistico, usa le utilità s_server e s_client di OpenSSL. Per usare entrambe le utilità contemporaneamente, apri due sessioni terminali: una per il server e l’altra per il client.

Prima di tutto, aggiungi il valore CN del certificato server al file host.

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

Dopodiché, verifica di essere nella directory /app/digicert-pqc/certs.

bash
cd /app/digicert-pqc/certs

Poi, in uno dei tuoi terminali aperti, avvia il server.

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

Dopo aver eseguito il comando sopra descritto, dovresti vedere questo risultato:

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

Dopodiché, passa alla finestra del secondo terminale, verificando di essere nella directory /app/digicert-pqc/certs.

bash
cd /app/digicert-pqc/certs

Poi, usa l’utilità s_client per collegarti al server in esecuzione.

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 tutto è configurato correttamente, nella finestra terminale che esegue l’utilità s_client, dovresti vedere questo risultato:

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

Nella finestra terminale che esegue l’utilità s_server, dovresti vedere questo risultato:

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

Congratulazioni! Hai creato correttamente una catena di certificati ibridi sicura da un punto di vista quantistico, usando il toolkit PQC di DigiCert e il motore ISARA Catalyst OpenSSL Connector.