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.
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:
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.
Il toolkit PQC DigiCert contiene questi file:
Prima di usare questa guida, verifica che questi prerequisiti vengano soddisfatti:
Per proteggere il sistema o l’ambiente di produzione dai problemi, ti raccomandiamo di seguire questa procedura usando una sandbox o un ambiente virtuale.
Prima di scaricare ed eseguire la patch dei file, prepara il tuo ambiente.
Prima di tutto, installa le dipendenze e gli strumenti necessari.
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.
mkdir -p /app/digicert-pqc/connector
mkdir -p /app/digicert-pqc/certs/configs
mkdir /app/resources
Adesso, scarica il toolkit PQC DigiCert ed estraine il contenuto.
Accedi al tuo account CertCentral.
Nel menu della barra laterale, fai clic su Certificati > Ordini.
Nella pagina Ordini, individua il tuo ordine di certificato Secure Site Pro e fai clic sul suo numero d’ordine.
Nella pagina dei dettagli dell’ordine certificato, fai clic su Toolkit PQC.
Nella pagina Crittografia post-quantum (PQC), fai clic su Scarica il toolkit ISARA PQC e salva il toolkit nella directory /app/resources.
Dopodiché, estrai il contenuto dal toolkit.
cd /app/resources
unzip ./DigiCert_PQC_Toolkit.zip
Il toolkit PQC contiene l’archivio ISARA OpenSSL Connector. Estrailo in /app/digicert-pqc/connector.
cd /app/digicert-pqc/connector
tar xzvf /app/resources/digicert-pqc-toolkit_2019-07-26/openssl_connector-Linux-2019-05-27.tgz
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.
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.
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.
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.
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.
Apri il file openssl.cnf copiato ne tuo editor di testo preferito.
vi ./apps/openssl.cnf
Individua la voce dynamic_path
sulla riga 32.
Cambia la voce in:
dynamic_path = /app/digicert-pqc/connector/lib/libiqre_engine.so
Salva e chiudi il file.
Poiché stai creando una libreria OpenSSL condivisa, dovrai configurare i percorsi non standard prima di compilare i file sorgente.
./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.
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.
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.
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.
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
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:
/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:
/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:
/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:
/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:
/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:
/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.
/app/digicert-pqc/pqpki-openssl-1.0.2r/bin/openssl ecparam -out ecdsa_catalyst_mixed_chain_parameters.pem -name secp384r1
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.
/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.
/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.
/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.
/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.
/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.
/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.
/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.
/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.
/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.
/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.
/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
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.
/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:
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.
/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:
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:
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
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.
echo "$(hostname -I) digicert.pqc" | sudo tee -a /etc/hosts
Dopodiché, verifica di essere nella directory /app/digicert-pqc/certs.
cd /app/digicert-pqc/certs
Poi, in uno dei tuoi terminali aperti, avvia il server.
/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:
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.
cd /app/digicert-pqc/certs
Poi, usa l’utilità s_client
per collegarti al server in esecuzione.
/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:
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:
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.