PQC-Toolkit-Setup

Diese Anleitung ist für das PQC-Toolkit. Anweisungen zum Einrichten des DigiCert PQC-dockerized Toolkits, siehe PQC-dockerized Toolkit-Anleitung.

Einführung

Das PQC-Toolkit (Post-Quantum-Kryptographie) von DigiCert enthält alles, was notwendig ist, um ein hybrides TLS-Zertifikat zu erstellen. Dieses hybride Zertifikat verwendet einen PQC-Algorithmus gepaart mit einem klassischen kryptografischen Algorithmus, sodass Sie die Funktionsfähigkeit hybrider Post-Quantum-TLS-Zertifikate testen können und gleichzeitig abwärtskompatibel bleiben.

Für diese erste Iteration, wird der PQC-Algorithmus mit einem ECC-Algorithmus (Elliptical Curve Cryptographic) gekoppelt.

Diese Setup-Anleitung führt Sie durch die Verwendung des DigiCert PQC-Toolkits:

  • Wenden Sie den ISARA-PQC-Patch auf OpenSSL-Quelldateien an.
  • Kompilieren Sie Ihr geändertes OpenSSL-Programm.
  • Generieren Sie PQC-Schlüssel.
  • Erstellen Sie eine vollständige hybride Zertifikatskette, einschließlich Stamm-, Zwischen- und Serverzertifikaten.
  • Testen Sie die Zertifikate anhand der OpenSSL-s_server- und -s_client-Dienstprogramme.

Das DigiCert-PQC-Toolkit steht für alle Secure Site Pro-Kunden zum Download bereit. Erfahren Sie mehr darüber, was zu jedem Secure Site Pro-Zertifikat gehört.

PQC-Toolkit-Contents

Das DigiCert-PQC-Toolkit enthält die folgenden Dateien:

  • ISARA Catalyst OpenSSL Connector
  • Die modifizierte openssl.cnf
  • Zertifikatskonfigurationsdateien
  • Ein Beispiel einer hybriden Zertifikatskette

Voraussetzungen

Sorgen Sie dafür, dass diese Voraussetzungen erfüllt sind, bevor Sie diese Anleitung benutzen:

  • Zugriff auf die Ressourcendateien des DigiCert-PQC-Toolkits
  • 64-Bit Ubuntu 16.04 oder später (diese Anleitung wurde für Ubuntu 18.04 LTS geschrieben)
  • Nicht-Root-Benutzer mit sudo-Zugriff

Um Ihr System oder Ihre Produktionsumgebung vor Problemen zu schützen, empfehlen wir, diese Schritte in einer Sandbox oder virtuellen Umgebung zu befolgen.

Die Umgebung vorbereiten

Bereiten Sie vor dem Herunterladen und Patchen der Dateien Ihre Umgebung vor.

Installieren Sie zunächst die erforderlichen Abhängigkeiten und Tools.

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

Erstellen Sie als Nächstes die Verzeichnisstruktur, in der Sie die Quelldateien und Toolkit-Ressourcen herunterladen und kompilieren.

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

Toolkit herunterladen und extrahieren

Laden Sie nun das DigiCert-PQC-Toolkit herunter und extrahieren Sie seinen Inhalt.

PQC-Toolkit herunterladen

  1. Melden Sie sich bei Ihrem CertCentral-Konto an.

  2. Klicken Sie im Menü der Seitenleiste auf Zertifikate > Aufträge.

  3. Suchen Sie auf der Seite „Aufträge“ Ihren Secure Site Pro-Zertifikatsauftrag, und klicken Sie auf die Auftragsnummer.

  4. Klicken Sie auf der Detailseite des Zertifikatsauftrags auf PQC-Toolkit.

  5. Klicken Sie auf der PQC-Seite (Post-Quantum Cryptography) auf ISARA PQC-Toolkit herunterladen, und speichern Sie das Toolkit im Verzeichnis /app/resources.

Extrahieren der PQC-Toolkit-Dateien

Extrahieren Sie als Nächstes den Inhalt des Toolkits.

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

Das PQC-Toolkit enthält das ISARA OpenSSL Connector-Archiv. Extrahieren Sie dieses nach /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

Patchen und kompilieren von OpenSSL

Nachdem Sie die Umgebung eingerichtet und alle Dateien extrahiert haben, patchen und kompilieren Sie OpenSSL.

Beginnen Sie damit, die OpenSSL-Version 1.0.2r in das Verzeichnis /app/resources herunterzuladen.

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

Extrahieren Sie als Nächstes die Quelldateien ins Verzeichnis /app/digicert-pqc.

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

Wenden Sie nun den ISARA OpenSSL-Patch auf die extrahierten Quelldateien an. Dies sorgt alle erforderlichen Modifikationen an OpenSSL, um quantum-sichere kryptografische Algorithmen zu generieren und zu interpretieren.

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

Ersetzen Sie nach Beendigung des Patchs die vorhandene openssl.cnf-Datei durch die modifizierte Version aus dem Toolkit. Diese modifizierte config-Datei enthält einen dynamischen Engine-Eintrag der auf die ISARA OpenSSL IQREngine verweist.

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

Jetzt müssen Sie die modifizierte config-Datei so ändern, dass sie auf den Ort der ISARA OpenSSL IQREngine verweist.

  1. Öffnen Sie die kopierte openssl.cnf-Datei in Ihrem bevorzugten Texteditor.

bash
vi ./apps/openssl.cnf
  1. Suchen Sie den dynamic_path-Eintrag in Zeile 32.

  2. Ändern Sie den Eintrag, wie folgt:

bash
dynamic_path = /app/digicert-pqc/connector/lib/libiqre_engine.so
  1. Speichern und schließen Sie die Datei.

Da Sie eine gemeinsam genutzte OpenSSL-Bibliothek erstellen, müssen Sie vor dem Kompilieren der Quelldateien die vom Standard abweichenden Pfade konfigurieren.

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

Führen Sie nun die folgenden Befehle einzeln aus, um die modifizierten Quelldateien zu kompilieren.

bash
make depend
make all
sudo make install

Nach der erfolgreichen Kompilierung der modifizierte OpenSSL-Quelle verwenden Sie die LD_LIBRARY_PATH-Variable, um zwei dynamische Bibliotheksstandorte zu bestimmen. So weiß Ihr System, sowohl wo sich Ihre modifizierten gemeinsam benutzten OpenSSL-Bibliotheken als auch die ISARA PQC-Engine für den Umgang mit quantum-sicheren kryptografischen Algorithmen befinden.

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

Falls Ihr System bereits die LD_LIBRARY_PATH-Variable verwendet, können Sie :$LD_LIBRARY_PATH an den obigen Befehl anhängen, um die neuen Pfade hinzuzufügen, ohne Schaden anzurichten.

Erstellen einer hybriden Zertifikatskette

Sie haben nun ein OpenSSL-Programm zum Generieren und Dekodieren von quantum-sicheren kryptografischen Algorithmen. Sie können jetzt eine vollständige hybride Zertifikatskette erstellen (Stamm-, Zwischen- und Serverzertifikate), um ihre Funktionalität zu testen.

Kopieren Sie zunächst die Zertifikatskonfigurationsdateien aus dem PQC-Toolkit in das Verzeichnis /app/digicert-pqc/certs. Diese Konfigurationsdateien enthalten alle notwendigen Informationen zur Generierung jedes Zertifikatsantrags und Zertifikats.

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

Generieren privater und öffentlicher Schlüssel

Generieren Sie anschließend quantum-sichere private Schlüssel für jedes Zertifikat in der Kette unter Verwendung des modifizierten OpenSSL-Programms sowie der IQREngine.

Privater Stammschlüssel:

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

Privater Zwischenschlüssel:

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

Privater Serverschlüssel:

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

Sobald Sie für jedes Zertifikat einen privaten Schlüsse generiert haben, extrahieren Sie ihre öffentlichen Schlüssel.

Öffentlicher Stammschlüssel:

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

Öffentlicher Zwischenschlüssel:

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

Öffentlicher Serverschlüssel:

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

Wählen Sie eine Kurve für das ECC-gemischte Kettenzertifikat.

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

Erstellen von CSRs und Generieren von Zertifikaten

Wenn alle kryptografischen Schlüssel generiert sind, sind Sie bereit, einen CSR für jedes Zertifikat in der Kette zu erstellen und das Stamm-, Zwischen- und Serverzertifikat zu generieren.

Erstellen Sie zuerst einen CSR für den Root-Aussteller.

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

Danach müssen Sie ein selbstsigniertes X.509-Zertifikat für Root erstellen.

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

Erweitern Sie dann das Stammzertifikat zu einem Hybrid-Stammzertifikat.

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

Jetzt können Sie den CSR für das Zwischenzertifikat erstellen.

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

Erweitern Sie den Zwischenzertifikat-CSR zu einem Hybrid-CSR.

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

Generieren Sie anschließend das Zwischenzertifikat.

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

Erweitern Sie das Zwischenzertifikat zu einem Hybrid-Zwischenzertifikat.

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

Nun, da das Stamm- und das Zwischenzertifikat erzeugt wurden, ist der nächste Schritt die Generierung des Serverzertifikats.

Sie müssen zuerst den CSR für das Serverzertifikat erstellen.

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

Erweitern Sie dann den Serverzertifikat-CSR zu einem Hybrid-CSR.

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

Danach können Sie das Serverzertifikat generieren.

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

Abschließend erweitern Sie dann das Serverzertifikat zu einem Hybrid-Serverzertifikat.

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

Verifizieren der Zertifikatskette

Sobald alle Zertifikate erstellt sind, können Sie verifizieren, ob Sie über eine funktionsfähige hybride Zertifikatskette verfügen.

Überprüfen Sie zunächst, ob die Hybrid-Kette mit älterer Kryptographie funktioniert.

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

Sie sollten diese Ausgabe sehen:

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

Prüfen Sie als Nächstes, ob die hybride Zertifikatskette funktioniert, wenn Sie quantumsichere Kryptographie verwenden.

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

Sie sollte diese Ausgabe zeigen:

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

Und um alle Dateien, die erstellt wurden, zu überprüfen, führen Sie einen ls-Befehl aus. Im Erfolgsfall sollten Sie eine Ausgabe wie diese sehen:

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

Testen ihrer Zertifikatskette mit s_server und s_client

Verwenden Sie zum Testen ihrer quantum-sicheren hybriden Zertifikatskette die OpenSSL-s_server- und -s_client-Dienstprogramme. Um beide Dienstprogramme gleichzeitig zu nutzen, öffnen Sie zwei Terminalsessions: eine für den Server und eine für den Client.

Fügen Sie zuerst den CN-Wert des Serverzertifikats zu Ihrer Hosts-Datei hinzu.

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

Stellen Sie als Nächstes sicher, dass Sie sich im Verzeichnis /app/digicert-pqc/certs befinden.

bash
cd /app/digicert-pqc/certs

Starten Sie dann in einer Ihrer offenen Terminalsessions den 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

Nach Ausführung des obigen Befehls sollten Sie diese Ausgabe sehen:

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

Gehen Sie nun in das zweite Terminalfenster, und stellen Sie sicher, dass Sie sich im Verzeichnis /app/digicert-pqc/certs befinden.

bash
cd /app/digicert-pqc/certs

Verwenden Sie dann das s_client-Dienstprogramm, um eine Verbindung zu dem laufenden Server herzustellen.

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'

Falls alles richtig konfiguriert ist, sollten Sie im Terminalfenster des laufenden s_client-Dienstprogramms diese Ausgabe sehen:

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

Im Terminalfenster in dem das s_server-Dienstprogramm ausgeführt wird, sollten Sie diese Ausgabe sehen:

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

Congratulations! You've successfully created a quantum-safe hybrid certificate chain using DigiCert's PQC toolkit and the ISARA Catalyst OpenSSL Connector engine.