Guide de configuration de la boîte à outils PQC

Ce guide porte sur la boîte à outils PQC. Pour obtenir des instructions sur la mise en place de la boîte à outils dockerisés PQC de DigiCert, consultez le guide de la boîte à outils dockerisés PQC.

Introduction

La boîte à outils de cryptographie post-quantique (PQC) de DigiCert contient tout ce dont vous avez besoin pour créer un certificat TLS hybride. Ce certificat hybride utilise un algorithme de chiffrement post-quantique associé à un algorithme de chiffrement classique. Ainsi, vous pouvez tester la viabilité du déploiement de certificats TLS hybrides post-quantiques tout en bénéficiant d’une rétrocompatibilité complète.

Pour cette première itération, l’algorithme cryptographique post-quantique est associé à l’algorithme cryptographique basé sur les courbes elliptiques.

Le présent guide de configuration vous aide à utiliser la boîte à outils PQC de DigiCert pour exécuter les tâches suivantes :

  • Appliquer le correctif PQC ISARA aux fichiers OpenSSL source.
  • Compiler votre programme OpenSSL modifié.
  • Générer des clés cryptographiques post-quantiques.
  • Créer une chaîne de certificats hybrides complète, comprenant les certificats racine, intermédiaire et serveur.
  • Tester les certificats en exécutant les utilitaires s_server et s_client d’OpenSSL.

La boîte à outils PQC de DigiCert est disponible pour tous les clients Secure Site Pro sous forme de ressource téléchargeable. Découvrez les éléments inclus avec chaque certificat Secure Site Pro.

Contenu de la boîte à outils PQC

La boîte à outils PQC de DigiCert contient les fichiers suivants :

  • ISARA Catalyst OpenSSL Connector
  • Modified openssl.cnf
  • Fichiers de configuration des certificats
  • Exemple de chaîne de certificats hybrides

Conditions préalables

Avant d’utiliser ce guide, assurez-vous que les conditions préalables suivantes sont remplies :

  • Vous avez accès aux fichiers de ressources de la boîte à outils PQC de DigiCert
  • Ubuntu 64 bits 16.04 ou une version ultérieure (le présent guide a été rédigé en utilisant Ubuntu 18.04 LTS)
  • Vous êtes un utilisateur non racine avec accès à sudo

Pour protéger votre système ou votre environnement de production contre les incidents, nous vous recommandons de suivre les étapes suivantes en utilisant un environnement virtuel ou Bac à sable.

Préparer l’environnement

Avant de télécharger des fichiers et d’en effectuer la mise à jour corrective, vous devez préparer votre environnement.

Installez tout d’abord les dépendances et outils nécessaires.

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

Ensuite, créez la structure du répertoire où vous allez télécharger et compiler les fichiers source et les ressources de la boîte à outils.

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

Télécharger et extraire la boîte à outils

À présent, vous pouvez télécharger la boîte à outils PQC de DigiCert et en extraire le contenu.

Télécharger la boîte à outils PQC

  1. Connectez-vous à votre compte CertCentral.

  2. Dans le menu latéral, cliquez sur Certificates > Orders (Certificats > Commandes).

  3. Sur la page « Orders » (Commandes) repérez votre commande de certificat Secure Site Pro et cliquez sur le numéro.

  4. Sur la page de détails de la commande du certificat, cliquez sur PQC toolkit (Boîte à outils PQC).

  5. Sur la page « Post-quantum cryptography (PQC) » (Cryptographie post-quantique, PQC), cliquez sur Download the ISARA PQC toolkit (Télécharger la boîte à outils PQC ISARA) et enregistrez-la dans le répertoire /app/resources.

Extraire le fichiers de la boîte à outils PQC

Ensuite, procédez à l’extraction du contenu de la boîte à outils.

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

La boîte à outils PQC contient l’archive ISARA OpenSSL Connector. Extrayez-la dans /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

Appliquer le correctif et compiler OpenSSL

Après avoir configuré l’environnement et extrait tous les fichiers, appliquez le correctif et compilez OpenSSL.

Pour commencer, téléchargez OpenSSL version 1.0.2r dans le répertoire /app/resources.

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

Extrayez ensuite les fichiers source dans le répertoire /app/digicert-pqc.

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

Maintenant, appliquez le correctif ISARA OpenSSL aux fichiers source extraits. Cette action apporte toutes les modifications nécessaires pour qu’OpenSSL génère et interprète des algorithmes cryptographiques résistants aux menaces quantiques.

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

Une fois la mise à jour corrective terminée, remplacez le fichier openssl.cnf existant par la version modifiée issue de la boîte à outils. Ce fichier de configuration modifié contient une entrée de moteur dynamique qui pointe vers ISARA OpenSSL IQREngine.

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

Vous devez maintenant éditer le fichier de configuration modifié pour qu'il pointe vers l'emplacement du ISARA OpenSSL IQREngine.

  1. Ouvrez le fichier openssl.cnf copié dans votre éditeur de texte préféré.

bash
vi ./apps/openssl.cnf
  1. Localisez l'entrée dynamic_path à la ligne 32.

  2. Modifiez l'entrée comme suit :

bash
dynamic_path = /app/digicert-pqc/connector/lib/libiqre_engine.so
  1. Enregistrez et fermez le fichier.

Comme vous créez une bibliothèque OpenSSL partagée, vous devez configurer les chemins d’accès non standards avant de compiler les fichiers source.

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

Maintenant, exécutez chacune des commandes ci-dessous, l’une après l’autre, pour compiler les fichiers source modifiés.

bash
make depend
make all
sudo make install

Une fois le fichier source OpenSSL modifié, définissez les variables LD_LIBRARY_PATH pour spécifier deux emplacements de bibliothèque dynamique. Cela indique à votre système où trouver vos bibliothèques OpenSSL partagées modifiées ainsi que le moteur PQC ISARA utilisé pour traiter les algorithmes cryptographiques résistants aux menaces quantiques.

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

Si votre système utilise déjà la variable LD_LIBRARY_PATH, vous pouvez ajouter :$LD_LIBRARY_PATH à la commande ci-dessus pour ajouter de nouveaux chemins d’accès de manière non destructive.

Créer une chaîne de certificats hybrides

À présent, vous disposez d’un programme OpenSSL capable de générer et de décoder des algorithmes cryptographiques résistants aux menaces quantiques. Vous êtes prêt à créer une chaîne de certificats hybrides complète (certificats racine, intermédiaire et serveur) pour pouvoir tester sa fonctionnalité.

Commencez par copier les fichiers de configuration du certificat inclus dans la boîte à outils PQC dans le répertoire /app/digicert-pqc/certs. Ces fichiers de configuration contiennent toutes les informations nécessaires pour générer chaque demande de certificat et le certificat.

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

Générer des clés privées et publiques

Ensuite, générez des clés privés résistantes aux menaces quantiques pour chaque certificat de la chaîne, en veillant à bien utiliser le programme OpenSSL modifié ainsi que le moteur IQREngine.

Clé privée racine :

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

Clé privée intermédiaire :

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

Clé privée serveur :

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

Lorsque vous avez généré la clé privée de chaque certificat, extrayez-en les clés publiques.

Clé publique racine :

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

Clé publique intermédiaire :

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

Clé publique serveur :

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

Choisissez une courbe pour le certificat de chaîne mixte ECC.

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

Créer des CSR et générer des certificats

Une fois toutes les clés cryptographiques générées, il vous est possible de créer une CSR pour chaque certificat de la chaîne et à générer les certificats racine, intermédiaire et serveur.

Premièrement, élaborez une CSR pour l'émetteur racine.

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

Vous devez ensuite créer un certificat X509 auto-signé pour la racine.

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

Puis, étendez le certificat racine en un certificat racine hybride.

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

Vous pouvez maintenant créer la CSR pour le certificat intermédiaire.

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

Prolongez la CSR du certificat intermédiaire en une CSR hybride.

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

Ensuite, générez le certificat intermédiaire.

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

Prolongez le certificat intermédiaire en un certificat intermédiaire hybride.

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

Maintenant que les certificats racine et intermédiaire ont été générés, l'étape suivante consiste à générer le certificat du serveur.

Vous devez d'abord créer la CSR pour le certificat du serveur.

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

Ensuite, prolongez la CSR du certificat de serveur en une CSR hybride.

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

Vous pouvez alors générer le certificat de serveur.

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

Pour finir, prolongez le certificat de serveur en un certificat de serveur hybride.

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

Vérifier la chaîne de certificats

Avec tous les certificats créés, vous êtes prêt à vérifier que vous disposez d'une chaîne de certificats hybrides fonctionnelle.

Tout d'abord, vérifiez que la chaîne hybride fonctionne en utilisant la cryptographie existante.

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

Le résultat affiché devrait être le suivant :

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

Ensuite, vérifiez que la chaîne de certificats hybrides fonctionne en utilisant une cryptographie à sécurité quantique.

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

Qui devrait fournir le résultat suivant :

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

Et pour vérifier que tous les fichiers ont été créés, exécutez une commande ls. Si vous avez réussi, vous devriez obtenir un résultat tel que celui-ci :

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

Testez votre chaîne de certificats en utilisant s_server et s_client

Pour tester votre chaîne de certificats hybrides résistants aux menaces quantiques, exécutez les utilitaires s_server et s_client d’OpenSSL. Pour exécuter les deux utilitaires simultanément, ouvrez deux sessions de terminaux, une pour le serveur et l’autre pour le client.

Commencez par ajouter la valeur CN du certificat serveur au fichier de l’hôte.

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

Ensuite, vérifiez que vous êtes bien dans le répertoire /app/digicert-pqc/certs.

bash
cd /app/digicert-pqc/certs

Dans l’un des terminaux ouverts, démarrez le serveur.

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

Après avoir exécuté la commande ci-dessus, vous devriez obtenir le résultat suivant :

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

Ensuite, passez à la fenêtre du deuxième point de terminaison en vérifiant que vous êtes bien dans le répertoire /app/digicert-pqc/certs.

bash
cd /app/digicert-pqc/certs

Exécutez ensuite l’utilitaire s_client pour vous connecter au serveur d’exécution.

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 tout est correctement configuré, dans la fenêtre du point de terminaison qui exécute l’utilitaire s_client, vous devriez obtenir le résultat suivant :

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

Dans la fenêtre du point de terminaison qui exécute l’utilitaire s_server, vous devriez obtenir le résultat suivant :

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

Félicitations ! Vous venez de créer une chaîne de certificats hybrides résistants aux menaces quantiques à l’aide de la boîte à outils PQC de DigiCert et du moteur ISARA Catalyst OpenSSL Connector.