Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Integration von Drittanbieteranwendungen mit AWS CloudHSM Einige der [Anwendungsfälle](use-cases.md) für AWS CloudHSM beinhalten die Integration von Softwareanwendungen von Drittanbietern mit dem HSM in Ihrem AWS CloudHSM Cluster. Durch die Integration von Software von Drittanbietern können Sie eine Vielzahl von sicherheitsrelevanten Zielen erreichen. AWS CloudHSM In den folgenden Themen wird beschrieben, wie Sie einige dieser Ziele umsetzen. **Topics** + [SSL/TLS-Auslagerung](ssl-offload.md) + [Windows Server-CA](third-ca-toplevel.md) + [Oracle Database-Verschlüsselung](oracle-tde.md) + [Microsoft SignTool](third-signtool-toplevel.md) + [Java Keytool und Jarsigner](third_java-sdk_integration.md) + [Tool zur Generierung und Bearbeitung von Microsoft-Manifests](third-magetool.md) + [Weitere Integrationen von Drittanbietern](other-integrations.md) # Verbessern Sie die Sicherheit Ihres Webservers mit SSL/TLS Offload in AWS CloudHSM Webserver und ihre Clients (Webbrowser) können die Protokolle Secure Sockets Layer (SSL) oder Transport Layer Security (TLS) verwenden, um die Identität des Webservers zu bestätigen und eine sichere Verbindung herzustellen, die Webseiten oder andere Daten über das Internet sendet und empfängt. Dies wird allgemein als HTTPS bezeichnet. Der Webserver verwendet ein öffentlich-privates key pair und ein SSL/TLS öffentliches Schlüsselzertifikat, um eine HTTPS-Sitzung mit jedem Client einzurichten. Dieser Prozess erfordert eine Menge Rechenleistung für Webserver, aber Sie können einen Teil davon auf Ihren AWS CloudHSM Cluster auslagern, was als SSL-Beschleunigung bezeichnet wird. Das Auslagern reduziert den Rechenaufwand auf Ihren Webservern und bietet zusätzliche Sicherheit, da die privaten Schlüssel der Server darin gespeichert werden. HSMs Die folgenden Themen bieten einen Überblick über die AWS CloudHSM Funktionsweise von SSL/TLS Offload with sowie Tutorials zur Einrichtung von SSL/TLS Offload With auf den folgenden Plattformen. AWS CloudHSM Für **Linux** verwenden Sie OpenSSL Dynamic Engine auf der [NGINX](https://nginx.org/en/)- oder [Apache-HTTP-Server](https://httpd.apache.org/)-Webserversoftware Für **Windows** verwenden Sie die Webserver-Software [Internet Information Services (IIS) für Windows Server](https://www.iis.net/). **Topics** + [So SSL/TLS funktioniert Offload mit AWS CloudHSM](ssl-offload-overview.md) + [AWS CloudHSM SSL/TLS-Offload unter Linux mit NGINX oder Apache mit OpenSSL](third-offload-linux-openssl.md) + [AWS CloudHSM SSL/TLS-Offload unter Linux mit NGINX oder mit OpenSSL Provider HAProxy](third-offload-linux-openssl-provider.md) + [AWS CloudHSM SSL/TLS-Offload unter Linux mit Tomcat mit JSSE](third-offload-linux-jsse.md) + [AWS CloudHSM SSL/TLS-Offload unter Windows mithilfe von IIS mit KSP](ssl-offload-windows.md) + [Einen Load Balancer mit Elastic Load Balancing hinzufügen für AWS CloudHSM(optional)](third-offload-add-lb.md) # So SSL/TLS funktioniert Offload mit AWS CloudHSM Um eine HTTPS-Verbindung aufzubauen, führt Ihr Webserver einen Handshake-Prozess mit Clients durch. Im Rahmen dieses Prozesses verlagert der Server einen Teil der kryptografischen Verarbeitung auf den AWS CloudHSM Cluster, wie HSMs in der folgenden Abbildung dargestellt. Jeder Schritt des Prozesses wird im Folgenden erläutert. **Anmerkung** Das folgende Bild und der Prozess gehen davon aus, dass RSA für die Serververifikation und den Schlüsselaustausch verwendet wird. Der Prozess sieht etwas anders aus, wenn Diffie–Hellman anstelle von RSA verwendet wird. ![\[Eine Illustration des TLS-Handshake-Prozesses zwischen Client und Server inklusive kryptographischem Offload an einen HSM.\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/images/ssl-offload-handshake-process.png) 1. Der Client sendet eine Hello-Nachricht an den Server. 1. Der Server antwortet mit einer Hello-Nachricht und sendet das Zertifikat des Servers. 1. Der Client führt die folgenden Aktionen durch: 1. Überprüft, ob das SSL/TLS Serverzertifikat mit einem Stammzertifikat signiert ist, dem der Client vertraut. 1. Er extrahiert den öffentlichen Schlüssel aus dem Zertifikat des Servers. 1. Generiert ein Pre-Master-Secret und verschlüsselt es mit dem öffentlichen Schlüssel des Servers. 1. Sendet das verschlüsselte Pre-Master-Secret an den Server. 1. Um das Pre-Master-Secret des Clients zu entschlüsseln, sendet der Server es an das HSM. Das HSM verwendet den privaten Schlüssel im HSM, um das Pre-Master-Secret zu entschlüsseln, und sendet dann das Pre-Master-Secret an den Server. Unabhängig davon verwenden Client und Server jeweils das Pre-Master-Secret und einige Informationen aus den Hello-Nachrichten, um ein Master-Secret zu berechnen. 1. Der Handshake-Vorgang ist beendet. Für den Rest der Sitzung werden alle Nachrichten, die zwischen dem Client und dem Server gesendet werden, mit Derivaten des Master-Geheimnisses verschlüsselt. Informationen zur Konfiguration von SSL/TLS Offload mit AWS CloudHSM finden Sie in einem der folgenden Themen: + [AWS CloudHSM SSL/TLS-Offload unter Linux mit NGINX oder Apache mit OpenSSL](third-offload-linux-openssl.md) + [AWS CloudHSM SSL/TLS-Offload unter Linux mit Tomcat mit JSSE](third-offload-linux-jsse.md) + [AWS CloudHSM SSL/TLS-Offload unter Windows mithilfe von IIS mit KSP](ssl-offload-windows.md) # AWS CloudHSM SSL/TLS-Offload unter Linux mit NGINX oder Apache mit OpenSSL Dieses Thema enthält step-by-step Anweisungen zum Einrichten von SSL/TLS Offload mit AWS CloudHSM auf einem Linux-Webserver. **Topics** + [-Übersicht](#ssl-offload-linux-openssl-overview) + [Schritt 1: Einrichten der Voraussetzungen](#ssl-offload-prerequisites) + [Schritt 2: Generieren Sie den privaten Schlüssel und das Zertifikat SSL/TLS](#ssl-offload-import-or-generate-private-key-and-certificate) + [Schritt 3: Konfigurieren des Webservers](#ssl-offload-configure-web-server) + [Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats](#ssl-offload-enable-traffic-and-verify-certificate) ## -Übersicht Die [NGINX](https://nginx.org/en/)- und [Apache HTTP Server](https://httpd.apache.org/)-Webserver-Software unter Linux ist nativ mit [OpenSSL](https://www.openssl.org/) integriert, um HTTPS zu unterstützen. Die [AWS CloudHSM dynamische Engine für OpenSSL](openssl-library.md) bietet eine Schnittstelle, die es der Webserver-Software ermöglicht, die HSMs in Ihrem Cluster für kryptografisches Offloading und Schlüsselspeicherung zu verwenden. Die OpenSSL-Engine ist eine Brücke, die den Webserver mit dem AWS CloudHSM -Cluster verbindet. Um diese Anleitung abzuschließen, müssen Sie zuerst entscheiden, ob Sie unter Linux die NGINX- oder Apache Webserver-Software verwenden möchten. Dann erfahren Sie, wie Sie folgende Aufgaben ausführen: + Installieren der Web-Server-Software auf einer Amazon EC2-Instance + Konfigurieren Sie die Webserver-Software so, dass sie HTTPS mit einem privaten Schlüssel unterstützt, der in Ihrem AWS CloudHSM -Cluster gespeichert ist. + (Optional) Verwenden Sie Amazon EC2, um eine zweite Webserver-Instance zu erstellen, und Elastic Load Balancing, um einen Load Balancer zu erstellen. Mit einem Load Balancer kann die Leistung durch Verteilung der Arbeitslast auf mehrere Server gesteigert werden. Sie kann auch für Redundanz und eine höhere Verfügbarkeit sorgen, falls ein oder mehrere Webserver ausfallen. Wenn Sie bereit sind, sehen Sie sich [Schritt 1: Einrichten der Voraussetzungen](#ssl-offload-prerequisites) an. ## Schritt 1: Einrichten der Voraussetzungen Verschiedene Plattformen erfordern unterschiedliche Voraussetzungen. Verwenden Sie den Abschnitt mit den Voraussetzungen unten, der zu Ihrer Plattform passt. ### Voraussetzungen für das Client-SDK 5 Um das SSL/TLS Webserver-Offload mit dem Client SDK 5 einzurichten, benötigen Sie Folgendes: + Ein aktiver AWS CloudHSM Cluster mit mindestens zwei Hardware-Sicherheitsmodulen (HSM) **Anmerkung** Sie können einen einzelnen HSM-Cluster verwenden, müssen aber zuerst die Haltbarkeit der Client-Schlüssel deaktivieren. Weitere Informationen finden Sie unter [Einstellungen für die Haltbarkeit von Client-Schlüsseln verwalten](working-client-sync.md#client-sync-sdk8) und [Client-SDK 5 Configure Tool](configure-sdk-5.md). + Eine Amazon EC2-Instance, auf der ein Linux-Betriebssystem ausgeführt wird und die folgende Software installiert ist: + Ein Webserver (entweder NGINX oder Apache) + Die OpenSSL Dynamic Engine für Client-SDK 5 + Ein [Crypto-Benutzer](understanding-users.md#crypto-user-chsm-cli) (CU), der den privaten Schlüssel des Webservers auf dem HSM besitzen und verwalten soll. **So richten Sie eine Linux-Webserver-Instance auf dem HSM ein und erstellen einen CU** 1. Installieren und konfigurieren Sie die OpenSSL Dynamic Engine für AWS CloudHSM. Weitere Informationen zur Installation der OpenSSL Dynamic Engine finden Sie unter [OpenSSL Dynamic Engine für Client-SDK 5.](openssl5-install.md) 1. Installieren Sie auf einer EC2-Linux-Instance, die Zugriff auf Ihren Cluster hat, entweder den NGINX- oder den Apache-Webserver: ------ #### [ Amazon Linux 2 ] + Informationen zum Herunterladen der neuesten Version von NGINX auf Amazon Linux 2 finden Sie auf der [NGINX-Website](https://nginx.org/en/linux_packages.html). Die neueste Version von NGINX, die für Amazon Linux 2 verfügbar ist, verwendet eine Version von OpenSSL, die neuer ist als die Systemversion von OpenSSL. Nach der Installation von NGINX müssen Sie einen symbolischen Link von der AWS CloudHSM OpenSSL Dynamic Engine-Bibliothek zu dem Speicherort erstellen, den diese Version von OpenSSL erwartet ``` $ sudo ln -sf /opt/cloudhsm/lib/libcloudhsm_openssl_engine.so /usr/lib64/engines-1.1/cloudhsm.so ``` + Apache ``` $ sudo yum install httpd mod_ssl ``` ------ #### [ Amazon Linux 2023 ] + NGINX ``` $ sudo yum install nginx ``` + Apache ``` $ sudo yum install httpd mod_ssl ``` ------ #### [ Red Hat 8 ] + NGINX ``` $ sudo yum install nginx ``` + Apache ``` $ sudo yum install httpd mod_ssl ``` ------ #### [ Red Hat 9 ] + NGINX ``` $ sudo yum install nginx ``` + Apache ``` $ sudo yum install httpd mod_ssl ``` ------ #### [ Ubuntu 22.04 ] + NGINX ``` $ sudo apt install nginx ``` + Apache ``` $ sudo apt install apache2 ``` ------ #### [ Ubuntu 24.04 ] + NGINX ``` $ sudo apt install nginx ``` + Apache ``` $ sudo apt install apache2 ``` ------ 1. Verwenden Sie die CloudHSM-CLI, um einen [Crypto-Benutzer](understanding-users.md#crypto-user-chsm-cli) zu erstellen. Weitere Informationen zur Verwaltung von HSM-Benutzern finden Sie unter [HSM-Benutzer mit der CloudHSM-CLI verwalten](manage-hsm-users-chsm-cli.md). **Tipp** Merken Sie sich den CU-Benutzernamen und das Passwort. Sie benötigen sie später beim Generieren oder Importieren des privaten HTTPS-Schlüssels und -Zertifikats für Ihren Webserver. Nachdem Sie diese Schritte abgeschlossen haben, fahren Sie mit [Schritt 2: Generieren Sie den privaten Schlüssel und das Zertifikat SSL/TLS](#ssl-offload-import-or-generate-private-key-and-certificate) fort. #### Hinweise + Um Security-Enhanced Linux (SELinux) und Webserver zu verwenden, müssen Sie ausgehende TCP-Verbindungen auf Port 2223 zulassen, dem Port, den Client SDK 5 für die Kommunikation mit dem HSM verwendet. + Um einen Cluster zu erstellen und zu aktivieren und einer EC2-Instance Zugriff auf den Cluster zu gewähren, führen Sie die Schritte unter [Erste Schritte mit AWS CloudHSM](getting-started.md) aus. Die ersten Schritte bieten step-by-step Anweisungen zum Erstellen eines aktiven Clusters mit einem HSM und einer Amazon EC2 EC2-Client-Instance. Sie können diese Client-Instance als Ihren Webserver verwenden. + Um zu vermeiden, dass die Haltbarkeit von Client-Schlüsseln deaktiviert wird, fügen Sie Ihrem Cluster mehr als ein HSM hinzu. Weitere Informationen finden Sie unter [Hinzufügen eines HSM zu einem Cluster AWS CloudHSM](add-hsm.md). + Um sich mit Ihrer Client-Instance zu verbinden, können Sie SSH oder PuTTY verwenden. Weitere Informationen finden Sie unter [Herstellung einer Verbindung zu Ihrer Linux-Instance mit SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html) oder [Herstellung einer Verbindung zu Ihrer Linux-Instance von Windows mit PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html) in der Amazon EC2-Dokumentation. ## Schritt 2: Generieren Sie den privaten Schlüssel und das Zertifikat SSL/TLS Um HTTPS zu aktivieren, benötigt Ihre Webserver-Anwendung (NGINX oder Apache) einen privaten Schlüssel und ein entsprechendes Zertifikat. SSL/TLS Um das SSL/TLS Webserver-Offload mit verwenden zu können AWS CloudHSM, müssen Sie den privaten Schlüssel in einem HSM in Ihrem Cluster speichern. AWS CloudHSM Sie generieren zunächst einen privaten Schlüssel und verwenden diesen Schlüssel, um eine Certificate Signing Request (CSR) zu erstellen. Anschließend exportieren Sie einen *gefälschten privaten PEM-Schlüssel* aus dem HSM. Dabei handelt es sich um eine private Schlüsseldatei im PEM-Format, die einen Verweis auf den privaten Schlüssel enthält, der auf dem HSM gespeichert ist (es ist nicht der eigentliche private Schlüssel). Ihr Webserver verwendet die gefälschte private PEM-Schlüsseldatei, um den privaten Schlüssel auf dem HSM beim Ausladen zu identifizieren. SSL/TLS ### Generieren eines privaten Schlüssels und Zertifikats #### Generieren eines privaten Schlüssels In diesem Abschnitt erfahren Sie, wie Sie mithilfe der [CloudHSM-CLI](cloudhsm_cli.md) ein Schlüsselpaar generieren. Sobald Sie ein key pair im HSM generiert haben, können Sie es als gefälschte PEM-Datei exportieren und das entsprechende Zertifikat generieren. **Installieren und konfigurieren Sie die CloudHSM-CLI** 1. [Installieren und konfigurieren Sie](cloudhsm_cli-getting-started.md) die CloudHSM-CLI. 1. Verwenden Sie den folgenden Befehl, um die CloudHSM-CLI zu starten. ``` $ /opt/cloudhsm/bin/cloudhsm-cli interactive ``` 1. Führen Sie den folgenden Befehl aus, um sich beim HSM anzumelden. Ersetzen Sie es ** durch den Benutzernamen Ihres Krypto-Benutzers ``` Command: login --username --role crypto-user ``` **Generieren eines privaten Schlüssels** Je nach Anwendungsfall können Sie entweder ein RSA- oder ein EC-Schlüsselpaar generieren. Führen Sie eine der folgenden Aktionen aus: + So erstellen Sie einen privaten RSA-Schlüssel in einem HSM Verwenden Sie den [`key generate-asymmetric-pair rsa`](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)-Befehl, um ein RSA-Schlüsselpaar zu erzeugen. In diesem Beispiel wird ein RSA-Schlüsselpaar mit einem Modul von 2048, einem öffentlichen Exponenten von 65537, der Bezeichnung des öffentlichen Schlüssels von und der Bezeichnung des privaten Schlüssels von *tls\$1rsa\$1pub* generiert. *tls\$1rsa\$1private* ``` aws-cloudhsm > key generate-asymmetric-pair rsa \ --public-exponent 65537 \ --modulus-size-bits 2048 \ --public-label tls_rsa_pub \ --private-label tls_rsa_private \ --private-attributes sign=true { "error_code": 0, "data": { "public_key": { "key-reference": "0x0000000000280cc8", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "full" }, "attributes": { "key-type": "rsa", "label": "tls_rsa_pub", "id": "", "check-value": "0x01fe6e", "class": "public-key", "encrypt": true, "decrypt": false, "token": true, "always-sensitive": false, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": false, "sign": false, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 512, "public-exponent": "0x010001", "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c 73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634d f6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc 133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0ac ac3160f0ca9725d38318b7", "modulus-size-bits": 2048 } }, "private_key": { "key-reference": "0x0000000000280cc7", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "full" }, "attributes": { "key-type": "rsa", "label": "tls_rsa_private", "id": "", "check-value": "0x01fe6e", "class": "private-key", "encrypt": false, "decrypt": true, "token": true, "always-sensitive": true, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": true, "sign": true, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 1217, "public-exponent": "0x010001", "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7", "modulus-size-bits": 2048 } } } } ``` + So erstellen Sie einen privaten EC-Schlüssel in einem HSM Verwenden Sie den [`key generate-asymmetric-pair ec`](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)-Befehl, um ein EC-Schlüsselpaar zu generieren. In diesem Beispiel wird ein EC-Schlüsselpaar mit der `prime256v1` Kurve (die der `NID_X9_62_prime256v1` Kurve entspricht), einem öffentlichen Schlüssellabel von *tls\$1ec\$1pub* und einem privaten Schlüssellabel von generiert*tls\$1ec\$1private*. ``` aws-cloudhsm > key generate-asymmetric-pair ec \ --curve prime256v1 \ --public-label tls_ec_pub \ --private-label tls_ec_private \ --private-attributes sign=true { "error_code": 0, "data": { "public_key": { "key-reference": "0x000000000012000b", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "session" }, "attributes": { "key-type": "ec", "label": "tls_ec_pub", "id": "", "check-value": "0xd7c1a7", "class": "public-key", "encrypt": false, "decrypt": false, "token": false, "always-sensitive": false, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": false, "sign": false, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 57, "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c", "curve": "secp224r1" } }, "private_key": { "key-reference": "0x000000000012000c", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "session" }, "attributes": { "key-type": "ec", "label": "tls_ec_private", "id": "", "check-value": "0xd7c1a7", "class": "private-key", "encrypt": false, "decrypt": false, "token": false, "always-sensitive": true, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": true, "sign": true, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 122, "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c", "curve": "secp224r1" } } } } ``` **Exportieren einer gefälschten privaten PEM-Schlüsseldatei** Sobald Sie einen privaten Schlüssel auf dem HSM haben, müssen Sie eine gefälschte private PEM-Schlüsseldatei exportieren. Diese Datei enthält nicht die eigentlichen Schlüsseldaten, ermöglicht es der OpenSSL Dynamic Engine jedoch, den privaten Schlüssel auf dem HSM zu identifizieren. Sie können dann den privaten Schlüssel verwenden, um eine Zertifikatsignierungsanforderung (CSR) zu erstellen und die CSR zu signieren, um das Zertifikat zu erstellen. Verwenden Sie den [`key generate-file`](cloudhsm_cli-key-generate-file.md)Befehl, um den privaten Schlüssel im falschen PEM-Format zu exportieren und in einer Datei zu speichern. Ersetzen Sie die folgenden Werte durch Ihre eigenen. + **— Bezeichnung des privaten Schlüssels, den Sie im vorherigen Schritt generiert haben. + **— Name der Datei, in die Ihr gefälschter PEM-Schlüssel geschrieben wird. ``` aws-cloudhsm > key generate-file --encoding reference-pem --path --filter attr.label= { "error_code": 0, "data": { "message": "Successfully generated key file" } } ``` **Beenden Sie die CloudHSM-CLI** Führen Sie den folgenden Befehl aus, um die CloudHSM-CLI zu beenden. ``` aws-cloudhsm > quit ``` Sie sollten jetzt eine neue Datei auf Ihrem System haben, die sich unter dem ** im vorherigen Befehl angegebenen Pfad befindet. Diese Datei ist die gefälschte private PEM-Schlüsseldatei. #### Generieren eines selbstsignierten Zertifikats Sobald Sie einen gefälschten privaten PEM-Schlüssel generiert haben, können Sie diese Datei verwenden, um eine Zertifikatssignieranforderung (CSR) und ein Zertifikat zu generieren. In einer Produktionsumgebung verwenden Sie in der Regel eine Zertifikatsstelle (CA) zum Erstellen eines Zertifikats aus einer CSR. Für eine Testumgebung ist keine CA erforderlich. Wenn Sie eine Zertifizierungsstelle verwenden, senden Sie ihnen die CSR-Datei und verwenden Sie ein signiertes SSL/TLS Zertifikat, das sie Ihnen auf Ihrem Webserver für HTTPS zur Verfügung stellen. Als Alternative zur Verwendung einer CA können Sie die AWS CloudHSM OpenSSL Dynamic Engine verwenden, um ein selbstsigniertes Zertifikat zu erstellen. Selbstsignierte Zertifikate sind nicht vertrauenswürdig für Browser und sollten in Produktionsumgebungen nicht verwendet werden. Sie können in Testumgebungen verwendet werden. **Warnung** Selbstsignierte Zertifikate sollten nur in einer Testumgebung verwendet werden. Für eine Produktionsumgebung, verwenden Sie eine sicherere Methode, wie z. B. eine Zertifikatstelle, um ein Zertifikat zu erstellen. **Installieren und konfigurieren Sie die OpenSSL Dynamic Engine** 1. Stellen Sie eine Verbindung mit Ihrer Client-Instance her. 1. [Installieren Sie die OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5](openssl5-install.md) **Generieren eines Zertifikats** 1. Besorgen Sie sich eine Kopie Ihrer gefälschten PEM-Datei, die in einem früheren Schritt generiert wurde. 1. Erstellen einer CSR Führen Sie den folgenden Befehl aus, um mit der AWS CloudHSM OpenSSL Dynamic Engine eine Certificate Signing Request (CSR) zu erstellen. **Ersetzen Sie ihn durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. **Ersetzen Sie es durch den Namen der Datei, die Ihre CSR enthält. Der Befehl `req` ist interaktiv. Füllen Sie jedes Feld aus. Die Feldinformationen werden in Ihr SSL/TLS Zertifikat kopiert. ``` $ openssl req -engine cloudhsm -new -key -out ``` 1. Erstellen eines selbstsignierten Zertifikats Führen Sie den folgenden Befehl aus, um die AWS CloudHSM OpenSSL Dynamic Engine zu verwenden, um Ihre CSR mit Ihrem privaten Schlüssel auf Ihrem HSM zu signieren. Dadurch wird ein selbstsigniertes Zertifikat erstellt. Ersetzen Sie die folgenden Werte in dem Befehl durch Ihre eigenen. + **— Name der Datei, die die CSR enthält. + **— Name der Datei, die den gefälschten privaten PEM-Schlüssel enthält. + **— Name der Datei, die Ihr Webserver-Zertifikat enthalten wird. ``` $ openssl x509 -engine cloudhsm -req -days 365 -in -signkey -out ``` Nachdem Sie diese Schritte abgeschlossen haben, fahren Sie mit [Schritt 3: Konfigurieren des Webservers](#ssl-offload-configure-web-server) fort. ## Schritt 3: Konfigurieren des Webservers Aktualisieren Sie die Konfiguration Ihrer Webserver-Software, um das HTTPS-Zertifikat und den zugehörigen gefälschten privaten PEM-Schlüssel zu verwenden, die Sie im [vorherigen Schritt](#ssl-offload-import-or-generate-private-key-and-certificate) erstellt haben. Denken Sie daran, Ihre vorhandenen Zertifikate und Schlüssel zu sichern, bevor Sie beginnen. Damit ist die Einrichtung Ihrer Linux-Webserver-Software für das SSL/TLS Offload mit abgeschlossen. AWS CloudHSM Führen Sie die Schritte aus einem der folgenden Abschnitte aus. **Topics** + [Konfigurieren eines NGINX-Webservers](#ssl-offload-nginx) + [Konfigurieren des Apache-Webservers](#ssl-offload-apache) ### Konfigurieren eines NGINX-Webservers Verwenden Sie diesen Abschnitt, um NGINX auf unterstützten Plattformen zu konfigurieren. **So aktualisieren Sie die Webserverkonfiguration für NGINX** 1. Stellen Sie eine Verbindung mit Ihrer Client-Instance her. 1. Führen Sie den folgenden Befehl aus, um die erforderlichen Verzeichnisse für das Webserverzertifikat und den gefälschten privaten PEM-Schlüssel zu erstellen. ``` $ sudo mkdir -p /etc/pki/nginx/private ``` 1. Führen Sie den folgenden Befehl aus, um Ihr Webserverzertifikat an die erforderliche Stelle zu kopieren. **Ersetzen Sie es durch den Namen Ihres Webserver-Zertifikats. ``` $ sudo cp /etc/pki/nginx/server.crt ``` 1. Führen Sie den folgenden Befehl aus, um den gefälschten privaten PEM-Schlüssel an die erforderliche Stelle zu kopieren. **Ersetzen Sie es durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. ``` $ sudo cp /etc/pki/nginx/private/server.key ``` 1. Führen Sie den folgenden Befehl aus, um die Eigentümerschaft für diese Dateien zu ändern, sodass der Benutzer mit dem Namen *nginx* diese lesen kann. ``` $ sudo chown nginx /etc/pki/nginx/server.crt /etc/pki/nginx/private/server.key ``` 1. Führen Sie den folgenden Befehl aus, um die Datei `/etc/nginx/nginx.conf` zu sichern. ``` $ sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup ``` 1. Aktualisieren Sie die NGINX-Konfiguration. **Anmerkung** Jeder Cluster kann maximal 1000 NGINX-Worker-Prozesse auf allen NGINX-Webservern unterstützen. ------ #### [ Amazon Linux 2 ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` ssl_engine cloudhsm; env CLOUDHSM_PIN; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 #ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA"; ssl_prefer_server_ciphers on; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ Amazon Linux 2023 ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` ssl_engine cloudhsm; env CLOUDHSM_PIN; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 #ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA"; ssl_prefer_server_ciphers on; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ Red Hat 8 ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` ssl_engine cloudhsm; env CLOUDHSM_PIN; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 #ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA"; ssl_prefer_server_ciphers on; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ Red Hat 9 ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` ssl_engine cloudhsm; env CLOUDHSM_PIN; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 #ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA"; ssl_prefer_server_ciphers on; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ Ubuntu 22.04 LTS ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` ssl_engine cloudhsm; env CLOUDHSM_PIN; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 #ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA"; ssl_prefer_server_ciphers on; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ Ubuntu 24.04 LTS ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` ssl_engine cloudhsm; env CLOUDHSM_PIN; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 #ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA"; ssl_prefer_server_ciphers on; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ Speichern Sie die Datei. 1. Sichern Sie die `systemd`-Konfigurationsdatei und legen Sie dann den `EnvironmentFile`-Pfad fest. ------ #### [ Amazon Linux 2 ] 1. Sichern Sie die Datei `nginx.service`. ``` $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie die Datei `/lib/systemd/system/nginx.service` in einem Texteditor. Fügen Sie dann im Abschnitt [Service] den folgenden Pfad hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ Amazon Linux 2023 ] 1. Sichern Sie die Datei `nginx.service`. ``` $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie die `/lib/systemd/system/nginx.service` Datei in einem Texteditor und fügen Sie dann im Abschnitt [Service] den folgenden Pfad hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ Red Hat 8 ] 1. Sichern Sie die Datei `nginx.service`. ``` $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie die Datei `/lib/systemd/system/nginx.service` in einem Texteditor. Fügen Sie dann im Abschnitt [Service] den folgenden Pfad hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ Red Hat 9 ] 1. Sichern Sie die Datei `nginx.service`. ``` $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie die Datei `/lib/systemd/system/nginx.service` in einem Texteditor. Fügen Sie dann im Abschnitt [Service] den folgenden Pfad hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ Ubuntu 22.04 LTS ] 1. Sichern Sie die Datei `nginx.service`. ``` $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie die Datei `/lib/systemd/system/nginx.service` in einem Texteditor. Fügen Sie dann im Abschnitt [Service] den folgenden Pfad hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ Ubuntu 24.04 LTS ] 1. Sichern Sie die Datei `nginx.service`. ``` $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie die Datei `/lib/systemd/system/nginx.service` in einem Texteditor. Fügen Sie dann im Abschnitt [Service] den folgenden Pfad hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ 1. Überprüfen Sie, ob die Datei `/etc/sysconfig/nginx` vorhanden ist, und führen Sie dann einen der folgenden Schritte aus: + Wenn die Datei vorhanden ist, sichern Sie die Datei, indem Sie den folgenden Befehl ausführen: ``` $ sudo cp /etc/sysconfig/nginx /etc/sysconfig/nginx.backup ``` + Öffnen Sie einen Texteditor und erstellen Sie im Ordner `/etc/sysconfig/` eine Datei mit dem Namen `nginx`, wenn die Datei nicht vorhanden ist. 1. Konfigurieren Sie die NGINX-Umgebung. **Anmerkung** Das Client-SDK 5 führt die `CLOUDHSM_PIN`-Umgebungsvariable zum Speichern der Anmeldeinformationen der CU ein. ------ #### [ Amazon Linux 2 ] Öffnen Sie die Datei `/etc/sysconfig/nginx` in einem Text-Editor. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie die Anmeldeinformationen für den Crypto-Benutzer (CU) hinzu: ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. Speichern Sie die Datei. ------ #### [ Amazon Linux 2023 ] Öffnen Sie die Datei `/etc/sysconfig/nginx` in einem Text-Editor. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie die Anmeldeinformationen für den Crypto-Benutzer (CU) hinzu: ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. Speichern Sie die Datei. ------ #### [ Red Hat 8 ] Öffnen Sie die Datei `/etc/sysconfig/nginx` in einem Text-Editor. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie die Anmeldeinformationen für den Crypto-Benutzer (CU) hinzu: ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. Speichern Sie die Datei. ------ #### [ Red Hat 9 ] Öffnen Sie die Datei `/etc/sysconfig/nginx` in einem Text-Editor. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie die Anmeldeinformationen für den Crypto-Benutzer (CU) hinzu: ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. Speichern Sie die Datei. ------ #### [ Ubuntu 22.04 LTS ] Öffnen Sie die Datei `/etc/sysconfig/nginx` in einem Text-Editor. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie die Anmeldeinformationen für den Crypto-Benutzer (CU) hinzu: ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. Speichern Sie die Datei. ------ #### [ Ubuntu 24.04 LTS ] Öffnen Sie die Datei `/etc/sysconfig/nginx` in einem Text-Editor. Dies erfordert Linux-Root-Berechtigungen. Fügen Sie die Anmeldeinformationen für den Crypto-Benutzer (CU) hinzu: ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. Speichern Sie die Datei. ------ 1. Starten Sie den NGINX-Webserver. ------ #### [ Amazon Linux 2 ] Stoppen Sie alle laufenden NGINX-Prozesse ``` $ sudo systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ sudo systemctl daemon-reload ``` Starten Sie den NGINX-Prozess ``` $ sudo systemctl start nginx ``` ------ #### [ Amazon Linux 2023 ] Stoppen Sie alle NGINX-Prozesse ``` $ sudo systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ sudo systemctl daemon-reload ``` Starten Sie NGINX ``` $ sudo systemctl start nginx ``` ------ #### [ Red Hat 8 ] Stoppen Sie alle laufenden NGINX-Prozesse ``` $ sudo systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ sudo systemctl daemon-reload ``` Starten Sie den NGINX-Prozess ``` $ sudo systemctl start nginx ``` ------ #### [ Red Hat 9 ] Stoppen Sie alle laufenden NGINX-Prozesse ``` $ sudo systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ sudo systemctl daemon-reload ``` Starten Sie den NGINX-Prozess ``` $ sudo systemctl start nginx ``` ------ #### [ Ubuntu 22.04 LTS ] Stoppen Sie alle laufenden NGINX-Prozesse ``` $ sudo systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ sudo systemctl daemon-reload ``` Starten Sie den NGINX-Prozess ``` $ sudo systemctl start nginx ``` ------ #### [ Ubuntu 24.04 LTS ] Stoppen Sie alle laufenden NGINX-Prozesse ``` $ sudo systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ sudo systemctl daemon-reload ``` Starten Sie den NGINX-Prozess ``` $ sudo systemctl start nginx ``` ------ 1. (Optional) Konfigurieren Sie Ihre Plattform so, dass NGINX beim Start gestartet wird. ------ #### [ Amazon Linux 2 ] ``` $ sudo systemctl enable nginx ``` ------ #### [ Amazon Linux 2023 ] ``` $ sudo systemctl enable nginx ``` ------ #### [ Red Hat 8 ] ``` $ sudo systemctl enable nginx ``` ------ #### [ Red Hat 9 ] ``` $ sudo systemctl enable nginx ``` ------ #### [ Ubuntu 22.04 LTS ] ``` $ sudo systemctl enable nginx ``` ------ #### [ Ubuntu 24.04 LTS ] ``` $ sudo systemctl enable nginx ``` ------ Nachdem Sie Ihre Webserverkonfiguration aktualisiert haben, gehen Sie zu [Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats](#ssl-offload-enable-traffic-and-verify-certificate). ### Konfigurieren des Apache-Webservers Verwenden Sie diesen Abschnitt, um Apache auf unterstützten Plattformen zu konfigurieren. **So aktualisieren Sie die Webserverkonfiguration für Apache** 1. Stellen Sie eine Verbindung zu Ihrer Amazon-EC2-Client-Instance her. 1. Definieren Sie Standardspeicherorte für Zertifikate und private Schlüssel für Ihre Plattform. ------ #### [ Amazon Linux 2 ] Stellen Sie sicher, dass in der `/etc/httpd/conf.d/ssl.conf`-Datei die folgenden Werte vorhanden sind: ``` SSLCertificateFile /etc/pki/tls/certs/localhost.crt SSLCertificateKeyFile /etc/pki/tls/private/localhost.key ``` ------ #### [ Amazon Linux 2023 ] In der `/etc/httpd/conf.d/ssl.conf` Datei. Stellen Sie sicher, dass diese Werte existieren: ``` SSLCertificateFile /etc/pki/tls/certs/localhost.crt SSLCertificateKeyFile /etc/pki/tls/private/localhost.key ``` ------ #### [ Red Hat 8 ] Stellen Sie sicher, dass in der `/etc/httpd/conf.d/ssl.conf`-Datei die folgenden Werte vorhanden sind: ``` SSLCertificateFile /etc/pki/tls/certs/localhost.crt SSLCertificateKeyFile /etc/pki/tls/private/localhost.key ``` ------ #### [ Red Hat 9 ] Stellen Sie sicher, dass in der `/etc/httpd/conf.d/ssl.conf`-Datei die folgenden Werte vorhanden sind: ``` SSLCertificateFile /etc/pki/tls/certs/localhost.crt SSLCertificateKeyFile /etc/pki/tls/private/localhost.key ``` ------ #### [ Ubuntu 22.04 LTS ] Stellen Sie sicher, dass in der `/etc/apache2/sites-available/default-ssl.conf`-Datei die folgenden Werte vorhanden sind: ``` SSLCertificateFile /etc/ssl/certs/localhost.crt SSLCertificateKeyFile /etc/ssl/private/localhost.key ``` ------ #### [ Ubuntu 24.04 LTS ] Stellen Sie sicher, dass in der `/etc/apache2/sites-available/default-ssl.conf`-Datei die folgenden Werte vorhanden sind: ``` SSLCertificateFile /etc/ssl/certs/localhost.crt SSLCertificateKeyFile /etc/ssl/private/localhost.key ``` ------ 1. Kopieren Sie Ihr Webserver-Zertifikat an den für Ihre Plattform erforderlichen Speicherort. ------ #### [ Amazon Linux 2 ] ``` $ sudo cp /etc/pki/tls/certs/localhost.crt ``` **Ersetzen Sie es durch den Namen Ihres Webserver-Zertifikats. ------ #### [ Amazon Linux 2023 ] ``` $ sudo cp /etc/pki/tls/certs/localhost.crt ``` **Ersetzen Sie es durch den Namen Ihres Webserver-Zertifikats. ------ #### [ Red Hat 8 ] ``` $ sudo cp /etc/pki/tls/certs/localhost.crt ``` **Ersetzen Sie es durch den Namen Ihres Webserver-Zertifikats. ------ #### [ Red Hat 9 ] ``` $ sudo cp /etc/pki/tls/certs/localhost.crt ``` **Ersetzen Sie es durch den Namen Ihres Webserver-Zertifikats. ------ #### [ Ubuntu 22.04 LTS ] ``` $ sudo cp /etc/ssl/certs/localhost.crt ``` **Ersetzen Sie es durch den Namen Ihres Webserver-Zertifikats. ------ #### [ Ubuntu 24.04 LTS ] ``` $ sudo cp /etc/ssl/certs/localhost.crt ``` **Ersetzen Sie es durch den Namen Ihres Webserver-Zertifikats. ------ 1. Kopieren Sie Ihren gefälschten privaten PEM-Schlüssel an den für Ihre Plattform erforderlichen Speicherort. ------ #### [ Amazon Linux 2 ] ``` $ sudo cp /etc/pki/tls/private/localhost.key ``` **Ersetzen Sie es durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. ------ #### [ Amazon Linux 2023 ] ``` $ sudo cp /etc/pki/tls/private/localhost.key ``` **Ersetzen Sie es durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. ------ #### [ Red Hat 8 ] ``` $ sudo cp /etc/pki/tls/private/localhost.key ``` **Ersetzen Sie es durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. ------ #### [ Red Hat 9 ] ``` $ sudo cp /etc/pki/tls/private/localhost.key ``` **Ersetzen Sie es durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. ------ #### [ Ubuntu 22.04 LTS ] ``` $ sudo cp /etc/ssl/private/localhost.key ``` **Ersetzen Sie es durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. ------ #### [ Ubuntu 24.04 LTS ] ``` $ sudo cp /etc/ssl/private/localhost.key ``` **Ersetzen Sie es durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. ------ 1. Ändern Sie den Besitz dieser Dateien, falls Ihre Plattform dies erfordert. ------ #### [ Amazon Linux 2 ] ``` $ sudo chown apache /etc/pki/tls/certs/localhost.crt /etc/pki/tls/private/localhost.key ``` Gewährt dem Benutzer mit dem Namen *Apache* Leseberechtigung. ------ #### [ Amazon Linux 2023 ] ``` $ sudo chown apache /etc/pki/tls/certs/localhost.crt /etc/pki/tls/private/localhost.key ``` Gewährt dem Benutzer mit dem Namen *Apache* Leseberechtigung. ------ #### [ Red Hat 8 ] ``` $ sudo chown apache /etc/pki/tls/certs/localhost.crt /etc/pki/tls/private/localhost.key ``` Gewährt dem Benutzer mit dem Namen *Apache* Leseberechtigung. ------ #### [ Red Hat 9 ] ``` $ sudo chown apache /etc/pki/tls/certs/localhost.crt /etc/pki/tls/private/localhost.key ``` Gewährt dem Benutzer mit dem Namen *Apache* Leseberechtigung. ------ #### [ Ubuntu 22.04 LTS ] Es ist keine Aktion erforderlich. ------ #### [ Ubuntu 24.04 LTS ] Es ist keine Aktion erforderlich. ------ 1. Konfigurieren Sie Apache-Direktiven für Ihre Plattform. ------ #### [ Amazon Linux 2 ] Suchen Sie die SSL-Datei für diese Plattform: ``` /etc/httpd/conf.d/ssl.conf ``` Diese Datei enthält Apache-Direktiven, die definieren, wie Ihr Server laufen soll. Direktiven erscheinen auf der linken Seite, gefolgt von einem Wert. Verwenden Sie einen Texteditor, um diese Datei zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Aktualisieren Sie die folgenden Direktiven oder geben Sie sie mit diesen Werten ein: ``` SSLCryptoDevice cloudhsm SSLCipherSuite ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA ``` Speichern Sie die Datei. ------ #### [ Amazon Linux 2023 ] Suchen Sie die SSL-Datei für diese Plattform: ``` /etc/httpd/conf.d/ssl.conf ``` Diese Datei enthält Apache-Direktiven, die definieren, wie Ihr Server laufen soll. Direktiven erscheinen auf der linken Seite, gefolgt von einem Wert. Verwenden Sie einen Texteditor, um diese Datei zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Aktualisieren Sie die folgenden Direktiven oder geben Sie sie mit diesen Werten ein: ``` SSLCryptoDevice cloudhsm SSLCipherSuite ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA ``` Speichern Sie die Datei. ------ #### [ Red Hat 8 ] Suchen Sie die SSL-Datei für diese Plattform: ``` /etc/httpd/conf.d/ssl.conf ``` Diese Datei enthält Apache-Direktiven, die definieren, wie Ihr Server laufen soll. Direktiven erscheinen auf der linken Seite, gefolgt von einem Wert. Verwenden Sie einen Texteditor, um diese Datei zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Aktualisieren Sie die folgenden Direktiven oder geben Sie sie mit diesen Werten ein: ``` SSLCryptoDevice cloudhsm SSLProtocol TLSv1.2 TLSv1.3 SSLCipherSuite ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA SSLProxyCipherSuite HIGH:!aNULL ``` Speichern Sie die Datei. ------ #### [ Red Hat 9 ] Suchen Sie die SSL-Datei für diese Plattform: ``` /etc/httpd/conf.d/ssl.conf ``` Diese Datei enthält Apache-Direktiven, die definieren, wie Ihr Server laufen soll. Direktiven erscheinen auf der linken Seite, gefolgt von einem Wert. Verwenden Sie einen Texteditor, um diese Datei zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Aktualisieren Sie die folgenden Direktiven oder geben Sie sie mit diesen Werten ein: ``` SSLCryptoDevice cloudhsm SSLProtocol TLSv1.2 TLSv1.3 SSLCipherSuite ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA SSLProxyCipherSuite HIGH:!aNULL ``` Speichern Sie die Datei. ------ #### [ Ubuntu 22.04 LTS ] Suchen Sie die SSL-Datei für diese Plattform: ``` /etc/apache2/mods-available/ssl.conf ``` Diese Datei enthält Apache-Direktiven, die definieren, wie Ihr Server laufen soll. Direktiven erscheinen auf der linken Seite, gefolgt von einem Wert. Verwenden Sie einen Texteditor, um diese Datei zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Aktualisieren Sie die folgenden Direktiven oder geben Sie sie mit diesen Werten ein: ``` SSLCryptoDevice cloudhsm SSLCipherSuite ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA SSLProtocol TLSv1.2 TLSv1.3 ``` Speichern Sie die Datei. Aktivieren Sie das SSL-Modul und die standardmäßige SSL-Site-Konfiguration: ``` $ sudo a2enmod ssl $ sudo a2ensite default-ssl ``` ------ #### [ Ubuntu 24.04 LTS ] Suchen Sie die SSL-Datei für diese Plattform: ``` /etc/apache2/mods-available/ssl.conf ``` Diese Datei enthält Apache-Direktiven, die definieren, wie Ihr Server laufen soll. Direktiven erscheinen auf der linken Seite, gefolgt von einem Wert. Verwenden Sie einen Texteditor, um diese Datei zu bearbeiten. Dies erfordert Linux-Root-Berechtigungen. Aktualisieren Sie die folgenden Direktiven oder geben Sie sie mit diesen Werten ein: ``` SSLCryptoDevice cloudhsm SSLCipherSuite ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA SSLProtocol TLSv1.2 TLSv1.3 ``` Speichern Sie die Datei. Aktivieren Sie das SSL-Modul und die standardmäßige SSL-Site-Konfiguration: ``` $ sudo a2enmod ssl $ sudo a2ensite default-ssl ``` ------ 1. Konfigurieren Sie eine Datei mit Umgebungswerten für Ihre Plattform. ------ #### [ Amazon Linux 2 ] Öffnen Sie die HTTPD-Servicedatei: ``` /lib/systemd/system/httpd.service ``` Fügen Sie unter dem Abschnitt `[Service]` Folgendes hinzu: ``` EnvironmentFile=/etc/sysconfig/httpd ``` ------ #### [ Amazon Linux 2023 ] Öffnen Sie die HTTPD-Servicedatei: ``` /lib/systemd/system/httpd.service ``` Fügen Sie unter dem Abschnitt `[Service]` Folgendes hinzu: ``` EnvironmentFile=/etc/sysconfig/httpd ``` ------ #### [ Red Hat 8 ] Öffnen Sie die HTTPD-Servicedatei: ``` /lib/systemd/system/httpd.service ``` Fügen Sie unter dem Abschnitt `[Service]` Folgendes hinzu: ``` EnvironmentFile=/etc/sysconfig/httpd ``` ------ #### [ Red Hat 9 ] Öffnen Sie die HTTPD-Servicedatei: ``` /lib/systemd/system/httpd.service ``` Fügen Sie unter dem Abschnitt `[Service]` Folgendes hinzu: ``` EnvironmentFile=/etc/sysconfig/httpd ``` ------ #### [ Ubuntu 22.04 LTS ] Es ist keine Aktion erforderlich. Umgebungswerte werden gehen zu `/etc/sysconfig/httpd` ------ #### [ Ubuntu 24.04 LTS ] Es ist keine Aktion erforderlich. Umgebungswerte werden gehen zu `/etc/sysconfig/httpd` ------ 1. Legen Sie in der Datei, in der Umgebungsvariablen für Ihre Plattform gespeichert sind, eine Umgebungsvariable fest, die die Anmeldeinformationen für den Crypto-Benutzer (CU) enthält: ------ #### [ Amazon Linux 2 ] Verwenden Sie einen Texteditor, um `/etc/sysconfig/httpd` zu bearbeiten. ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. ------ #### [ Amazon Linux 2023 ] Verwenden Sie einen Texteditor, um `/etc/sysconfig/httpd` zu bearbeiten. ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. ------ #### [ Red Hat 8 ] Verwenden Sie einen Texteditor, um `/etc/sysconfig/httpd` zu bearbeiten. ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. **Anmerkung** Das Client-SDK 5 führt die `CLOUDHSM_PIN`-Umgebungsvariable zum Speichern der Anmeldeinformationen der CU ein. ------ #### [ Red Hat 9 ] Verwenden Sie einen Texteditor, um `/etc/sysconfig/httpd` zu bearbeiten. ``` CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. **Anmerkung** Das Client-SDK 5 führt die `CLOUDHSM_PIN`-Umgebungsvariable zum Speichern der Anmeldeinformationen der CU ein. ------ #### [ Ubuntu 22.04 LTS ] Verwenden Sie einen Texteditor, um `/etc/apache2/envvars` zu bearbeiten. ``` export CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. **Anmerkung** Das Client-SDK 5 führt die `CLOUDHSM_PIN`-Umgebungsvariable zum Speichern der Anmeldeinformationen der CU ein. Im Client-SDK 3 speichern Sie die CU-Anmeldeinformationen in der `n3fips_password`-Umgebungsvariable. Client-SDK 5 unterstützt beide Umgebungsvariablen, wir empfehlen jedoch, `CLOUDHSM_PIN` zu verwenden. ------ #### [ Ubuntu 24.04 LTS ] Verwenden Sie einen Texteditor, um `/etc/apache2/envvars` zu bearbeiten. ``` export CLOUDHSM_PIN=: ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. **Anmerkung** Das Client-SDK 5 führt die `CLOUDHSM_PIN`-Umgebungsvariable zum Speichern der Anmeldeinformationen der CU ein. Im Client-SDK 3 speichern Sie die CU-Anmeldeinformationen in der `n3fips_password`-Umgebungsvariable. Client-SDK 5 unterstützt beide Umgebungsvariablen, wir empfehlen jedoch, `CLOUDHSM_PIN` zu verwenden. ------ 1. Starten Sie den Apache-Webserver. ------ #### [ Amazon Linux 2 ] ``` $ sudo systemctl daemon-reload $ sudo service httpd start ``` ------ #### [ Amazon Linux 2023 ] ``` $ sudo systemctl daemon-reload $ sudo service httpd start ``` ------ #### [ Red Hat 8 ] ``` $ sudo systemctl daemon-reload $ sudo service httpd start ``` ------ #### [ Red Hat 9 ] ``` $ sudo systemctl daemon-reload $ sudo service httpd start ``` ------ #### [ Ubuntu 22.04 LTS ] ``` $ sudo service apache2 start ``` ------ #### [ Ubuntu 24.04 LTS ] ``` $ sudo service apache2 start ``` ------ 1. (Optional) Konfigurieren Sie Ihre Plattform so, dass Apache beim Start gestartet wird. ------ #### [ Amazon Linux 2 ] ``` $ sudo chkconfig httpd on ``` ------ #### [ Amazon Linux 2023 ] ``` $ sudo chkconfig httpd on ``` ------ #### [ Red Hat 8 ] ``` $ systemctl enable httpd ``` ------ #### [ Red Hat 9 ] ``` $ systemctl enable httpd ``` ------ #### [ Ubuntu 22.04 LTS ] ``` $ sudo systemctl enable apache2 ``` ------ #### [ Ubuntu 24.04 LTS ] ``` $ sudo systemctl enable apache2 ``` ------ Nachdem Sie Ihre Webserverkonfiguration aktualisiert haben, gehen Sie zu [Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats](#ssl-offload-enable-traffic-and-verify-certificate). ## Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats Nachdem Sie Ihren Webserver für SSL/TLS Offload mit konfiguriert haben AWS CloudHSM, fügen Sie Ihre Webserver-Instanz einer Sicherheitsgruppe hinzu, die eingehenden HTTPS-Verkehr zulässt. Dadurch können Clients, wie z. B. Webbrowser, eine HTTPS-Verbindung mit Ihrem Webserver herstellen. Stellen Sie dann eine HTTPS-Verbindung zu Ihrem Webserver her und stellen Sie sicher, dass er das Zertifikat verwendet, mit dem Sie das SSL/TLS Offload konfiguriert haben. AWS CloudHSM **Topics** + [Aktivieren von eingehenden HTTPS-Verbindungen](#ssl-offload-add-security-group-linux) + [Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet](#ssl-offload-verify-https-connection-linux-enable) ### Aktivieren von eingehenden HTTPS-Verbindungen Zum Herstellen einer Verbindung zu Ihrem Webserver von einem Client (z. B. ein Webbrowser) aus, erstellen Sie eine Sicherheitsgruppe, die eingehende HTTPS-Verbindungen zulässt. Insbesondere sollten eingehende TCP-Verbindungen auf Port 443 erlaubt werden. Weisen Sie diese Sicherheitsgruppe Ihrem Webserver zu. **So erstellen Sie eine Sicherheitsgruppe für HTTPS und weisen sie Ihrem Webserver zu** 1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. Wählen Sie im Navigationsbereich **Sicherheitsgruppen** aus. 1. Wählen Sie **Sicherheitsgruppe erstellen**. 1. Führen Sie für **Sicherheitsgruppe erstellen** die folgenden Schritte aus: 1. Geben Sie in das Feld **Sicherheitsgruppenname** einen Namen für die Sicherheitsgruppe ein, die Sie erstellen. 1. (Optional) Geben Sie eine Beschreibung der Sicherheitsgruppe ein, die Sie erstellen. 1. Wählen Sie für **VPC** die VPC aus, die Ihre Amazon-EC2-Instance enthält. 1. Wählen Sie **Regel hinzufügen** aus. 1. Wählen Sie im Drop-down-Fenster für **Typ** die Option **HTTPS** aus. 1. Geben Sie für **Quelle** einen Quellspeicherort ein. 1. Wählen Sie **Sicherheitsgruppe erstellen** aus. 1. Wählen Sie im Navigationsbereich **Instances** aus. 1. Aktivieren Sie das Kontrollkästchen neben Ihrer Webserver-Instance. 1. Wählen Sie das Drop-down-Menü **Aktionen** oben auf der Seite. Wählen Sie **Sicherheit** und dann **Sicherheitsgruppen ändern** aus. 1. Wählen Sie unter **Zugeordnete Sicherheitsgruppen** das Suchfeld aus und wählen Sie die Sicherheitsgruppe, die Sie für HTTPS erstellt haben, aus. Wählen Sie dann **Sicherheitsgruppen hinzufügen** aus. 1. Wählen Sie **Speichern**. ### Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet Nachdem Sie den Webserver zu einer Sicherheitsgruppe hinzugefügt haben, können Sie überprüfen, ob für den SSL/TLS Offload Ihr selbstsigniertes Zertifikat verwendet wird. Sie können dazu einen Webbrowser oder ein Tool wie [OpenSSL s\$1client](https://www.openssl.org/docs/manmaster/man1/s_client.html) nutzen. **Um den SSL/TLS Offload mit einem Webbrowser zu überprüfen** 1. Verwenden Sie einen Web-Browser, um eine Verbindung zum Webserver unter Verwendung des öffentlichen DNS-Namen oder der IP-Adresse des Servers herzustellen. Stellen Sie sicher, dass die URL in die Adresszeile mit https:// beginnt. Beispiel, **https://ec2-52-14-212-67.us-east-2.compute.amazonaws.com/**. **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Zeigen Sie das Webserverzertifikat mit Ihrem Webbrowser an. Weitere Informationen finden Sie hier: + Wenn Sie Mozilla Firefox nutzen, sehen Sie sich die Informationen auf der Mozilla Support-Website unter [Zertifikat anzeigen](https://support.mozilla.org/en-US/kb/secure-website-certificate#w_view-a-certificate) an. + Wenn Sie Google Chrome verwenden, sehen Sie sich die Informationen auf der „Google Tools für Web Developers“-Website unter [Sicherheitsprobleme verstehen](https://developers.google.com/web/tools/chrome-devtools/security) an. Andere Webbrowser unterstützen möglicherweise ähnliche Funktionen, über die Sie das Webserverzertifikat anzeigen können. 1. Stellen Sie sicher, dass es sich bei dem SSL/TLS Zertifikat um das Zertifikat handelt, für dessen Verwendung Sie Ihren Webserver konfiguriert haben. **Um den SSL/TLS Offload mit OpenSSL s\$1client zu überprüfen** 1. Führen Sie den folgenden OpenSSL-Befehl aus, um mittels HTTPS eine Verbindung zu Ihrem Webserver herzustellen. **Ersetzen Sie es durch den öffentlichen DNS-Namen oder die IP-Adresse Ihres Webservers. ``` openssl s_client -connect :443 ``` **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Stellen Sie sicher, dass es sich bei dem SSL/TLS Zertifikat um das Zertifikat handelt, für dessen Verwendung Sie Ihren Webserver konfiguriert haben. Sie verfügen jetzt über eine mit HTTPS gesicherte Website. Der private Schlüssel für den Webserver wird in einem HSM in Ihrem AWS CloudHSM Cluster gespeichert. Informationen zum Hinzufügen eines Load Balancers finden Sie unter [Einen Load Balancer mit Elastic Load Balancing hinzufügen für AWS CloudHSM(optional)](third-offload-add-lb.md). # AWS CloudHSM SSL/TLS-Offload unter Linux mit NGINX oder mit OpenSSL Provider HAProxy Dieses Thema enthält step-by-step Anweisungen zum Einrichten des SSL/TLS Server-Identity-Offloads AWS CloudHSM auf einem Linux-Webserver mit NGINX oder HAProxy mit dem OpenSSL Provider. **Topics** + [-Übersicht](#ssl-offload-linux-openssl-provider-overview) + [Schritt 1: Einrichten der Voraussetzungen](#ssl-offload-provider-prerequisites) + [Schritt 2: Generieren oder importieren Sie einen privaten Schlüssel und holen Sie sich ein Zertifikat](#ssl-offload-provider-generate-key-and-certificate) + [Schritt 3: Konfigurieren des Webservers](#ssl-offload-provider-configure-web-server) + [Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats](#ssl-offload-enable-traffic-and-verify-certificate-provider) ## -Übersicht Unter Linux sind [NGINX](https://nginx.org/en/) und die [HAProxy](https://www.haproxy.org/)Webserver-Software in [OpenSSL integriert, um HTTPS zu unterstützen](https://www.openssl.org/). Der [AWS CloudHSM OpenSSL Provider](openssl-provider-library.md) stellt eine Schnittstelle bereit, die es der Webserver-Software ermöglicht, die HSMs in Ihrem Cluster für kryptografisches Offloading und Schlüsselspeicherung zu verwenden. Der OpenSSL Provider ist die Brücke, die den Webserver mit Ihrem AWS CloudHSM Cluster verbindet. Um dieses Tutorial abzuschließen, müssen Sie NGINX konfigurieren oder HAProxy den AWS CloudHSM OpenSSL Provider verwenden. Das Tutorial zeigt Ihnen, wie Sie Folgendes tun können: + Installieren der Web-Server-Software auf einer Amazon EC2-Instance + Konfigurieren Sie die Webserver-Software so, dass sie HTTPS mit einem privaten Schlüssel unterstützt, der in Ihrem AWS CloudHSM -Cluster gespeichert ist. + (Optional) Verwenden Sie Amazon EC2, um eine zweite Webserver-Instance zu erstellen, und Elastic Load Balancing, um einen Load Balancer zu erstellen. Mit einem Load Balancer kann die Leistung durch Verteilung der Arbeitslast auf mehrere Server gesteigert werden. Sie kann auch für Redundanz und eine höhere Verfügbarkeit sorgen, falls ein oder mehrere Webserver ausfallen. Wenn Sie bereit sind, sehen Sie sich [Schritt 1: Einrichten der Voraussetzungen](#ssl-offload-provider-prerequisites) an. ## Schritt 1: Einrichten der Voraussetzungen Verschiedene Plattformen erfordern unterschiedliche Voraussetzungen. Verwenden Sie den Abschnitt mit den Voraussetzungen unten, der zu Ihrer Plattform passt. ### Voraussetzungen für AWS CloudHSM OpenSSL Provider Um das Offload von SSL/TLS Webserver-Serveridentitäten mit AWS CloudHSM OpenSSL Provider for Client SDK 5 einzurichten, benötigen Sie Folgendes: + Ein aktiver AWS CloudHSM Cluster mit mindestens zwei Hardware-Sicherheitsmodulen (HSM) **Anmerkung** Sie können einen einzelnen HSM-Cluster verwenden, müssen aber zuerst die Haltbarkeit der Client-Schlüssel deaktivieren. Weitere Informationen finden Sie unter [Einstellungen für die Haltbarkeit von Client-Schlüsseln verwalten](working-client-sync.md#client-sync-sdk8) und [Client-SDK 5 Configure Tool](configure-sdk-5.md). + Eine Amazon EC2-Instance, auf der ein Linux-Betriebssystem ausgeführt wird und die folgende Software installiert ist: + Ein Webserver (entweder NGINX oder) HAProxy + Der AWS CloudHSM OpenSSL-Anbieter für Client SDK 5 + Ein [Crypto-Benutzer](understanding-users.md#crypto-user-chsm-cli) (CU), der den privaten Schlüssel des Webservers auf dem HSM besitzen und verwalten soll. **So richten Sie eine Linux-Webserver-Instance auf dem HSM ein und erstellen einen CU** **Anmerkung** Viele der Befehle in diesem Verfahren erfordern erhöhte Rechte. Abhängig von Ihrer Systemkonfiguration müssen Sie möglicherweise Befehle mit `sudo` oder als Root-Benutzer ausführen. 1. Installieren und konfigurieren Sie den AWS CloudHSM OpenSSL Provider für Client SDK 5. Weitere Informationen zur Installation des OpenSSL Providers finden Sie unter [AWS CloudHSM OpenSSL Provider for Client SDK 5.](openssl-provider-install.md) 1. Installieren Sie auf einer EC2-Linux-Instance, die Zugriff auf Ihren Cluster hat, entweder NGINX oder einen Webserver: HAProxy ------ #### [ Amazon Linux 2023 ] + NGINX ``` $ yum install nginx ``` + HAProxy ``` $ yum install haproxy ``` ------ #### [ RHEL 9 (9.2\$1) ] + NGINX ``` $ yum install nginx ``` + HAProxy ``` $ yum install haproxy ``` ------ #### [ RHEL 10 (10.0\$1) ] + NGINX ``` $ yum install nginx ``` + HAProxy ``` $ yum install haproxy ``` ------ #### [ Ubuntu 24.04 ] + NGINX ``` $ apt install nginx ``` + HAProxy ``` $ apt install haproxy ``` ------ 1. Verwenden Sie die CloudHSM-CLI, um einen [Crypto-Benutzer](understanding-users.md#crypto-user-chsm-cli) zu erstellen. Weitere Informationen zur Verwaltung von HSM-Benutzern finden Sie unter [HSM-Benutzer mit der CloudHSM-CLI verwalten](manage-hsm-users-chsm-cli.md). **Tipp** Merken Sie sich den CU-Benutzernamen und das Passwort. Sie benötigen sie später beim Generieren oder Importieren des privaten HTTPS-Schlüssels und -Zertifikats für Ihren Webserver. Nachdem Sie diese Schritte abgeschlossen haben, fahren Sie mit [Schritt 2: Generieren oder importieren Sie einen privaten Schlüssel und holen Sie sich ein Zertifikat](#ssl-offload-provider-generate-key-and-certificate) fort. #### Hinweise + Um Security-Enhanced Linux (SELinux) und Webserver zu verwenden, müssen Sie ausgehende TCP-Verbindungen auf Port 2223 zulassen, dem Port, den Client SDK 5 für die Kommunikation mit dem HSM verwendet. + Um einen Cluster zu erstellen und zu aktivieren und einer EC2-Instance Zugriff auf den Cluster zu gewähren, führen Sie die Schritte unter [Erste Schritte mit AWS CloudHSM](getting-started.md) aus. Die ersten Schritte bieten step-by-step Anweisungen zum Erstellen eines aktiven Clusters mit einem HSM und einer Amazon EC2 EC2-Client-Instance. Sie können diese Client-Instance als Ihren Webserver verwenden. + Um zu vermeiden, dass die Haltbarkeit von Client-Schlüsseln deaktiviert wird, fügen Sie Ihrem Cluster mehr als ein HSM hinzu. Weitere Informationen finden Sie unter [Hinzufügen eines HSM zu einem Cluster AWS CloudHSM](add-hsm.md). + Um sich mit Ihrer Client-Instance zu verbinden, können Sie SSH oder PuTTY verwenden. Weitere Informationen finden Sie unter [Herstellung einer Verbindung zu Ihrer Linux-Instance mit SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html) oder [Herstellung einer Verbindung zu Ihrer Linux-Instance von Windows mit PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html) in der Amazon EC2-Dokumentation. ## Schritt 2: Generieren oder importieren Sie einen privaten Schlüssel und holen Sie sich ein Zertifikat Um HTTPS zu aktivieren, benötigt Ihre Webserver-Anwendung (NGINX oder HAProxy) einen privaten Schlüssel und ein entsprechendes SSL/TLS Zertifikat. Um das Auslagern von SSL/TLS Webserver-Serveridentitäten mit verwenden zu können AWS CloudHSM, müssen Sie den privaten Schlüssel in einem HSM in Ihrem Cluster speichern. AWS CloudHSM Sie generieren zunächst einen privaten Schlüssel und verwenden diesen Schlüssel, um eine Certificate Signing Request (CSR) zu erstellen. Anschließend exportieren Sie einen *gefälschten privaten PEM-Schlüssel* aus dem HSM. Dabei handelt es sich um eine private Schlüsseldatei im PEM-Format, die einen Verweis auf den privaten Schlüssel enthält, der auf dem HSM gespeichert ist (es ist nicht der eigentliche private Schlüssel). Ihr Webserver verwendet die gefälschte private PEM-Schlüsseldatei, um den privaten Schlüssel auf dem HSM beim Auslagern der Serveridentität zu identifizieren. SSL/TLS ### Generieren eines privaten Schlüssels In diesem Abschnitt erfahren Sie, wie Sie mithilfe der [CloudHSM-CLI](cloudhsm_cli.md) ein Schlüsselpaar generieren. Sobald Sie ein key pair im HSM generiert haben, können Sie es als gefälschte PEM-Datei exportieren und das entsprechende Zertifikat generieren. **Installieren und konfigurieren Sie die CloudHSM-CLI** 1. [Installieren und konfigurieren Sie](cloudhsm_cli-getting-started.md) die CloudHSM-CLI. 1. Verwenden Sie den folgenden Befehl, um die CloudHSM-CLI zu starten. ``` $ /opt/cloudhsm/bin/cloudhsm-cli interactive ``` 1. Führen Sie den folgenden Befehl aus, um sich beim HSM anzumelden. Ersetzen Sie es ** durch den Benutzernamen Ihres Krypto-Benutzers ``` aws-cloudhsm>login --username --role crypto-user ``` **Generieren eines privaten Schlüssels** Je nach Anwendungsfall können Sie entweder ein RSA- oder ein EC-Schlüsselpaar generieren. Führen Sie eine der folgenden Aktionen aus: + So erstellen Sie einen privaten RSA-Schlüssel in einem HSM Verwenden Sie den [`key generate-asymmetric-pair rsa`](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)-Befehl, um ein RSA-Schlüsselpaar zu erzeugen. In diesem Beispiel wird ein RSA-Schlüsselpaar mit einem Modul von 2048, einem öffentlichen Exponenten von 65537, der Bezeichnung des öffentlichen Schlüssels von und der Bezeichnung des privaten Schlüssels von *tls\$1rsa\$1pub* generiert. *tls\$1rsa\$1private* ``` aws-cloudhsm > key generate-asymmetric-pair rsa \ --public-exponent 65537 \ --modulus-size-bits 2048 \ --public-label tls_rsa_pub \ --private-label tls_rsa_private \ --private-attributes sign=true { "error_code": 0, "data": { "public_key": { "key-reference": "0x0000000000280cc8", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "full" }, "attributes": { "key-type": "rsa", "label": "tls_rsa_pub", "id": "", "check-value": "0x01fe6e", "class": "public-key", "encrypt": true, "decrypt": false, "token": true, "always-sensitive": false, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": false, "sign": false, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 512, "public-exponent": "0x010001", "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7", "modulus-size-bits": 2048 } }, "private_key": { "key-reference": "0x0000000000280cc7", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "full" }, "attributes": { "key-type": "rsa", "label": "tls_rsa_private", "id": "", "check-value": "0x01fe6e", "class": "private-key", "encrypt": false, "decrypt": true, "token": true, "always-sensitive": true, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": true, "sign": true, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 1217, "public-exponent": "0x010001", "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7", "modulus-size-bits": 2048 } } } } ``` + So erstellen Sie einen privaten EC-Schlüssel in einem HSM Verwenden Sie den [`key generate-asymmetric-pair ec`](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)-Befehl, um ein EC-Schlüsselpaar zu generieren. In diesem Beispiel wird ein EC-Schlüsselpaar mit der `prime256v1` Kurve (die der `NID_X9_62_prime256v1` Kurve entspricht), einem öffentlichen Schlüssellabel von *tls\$1ec\$1pub* und einem privaten Schlüssellabel von generiert*tls\$1ec\$1private*. ``` aws-cloudhsm > key generate-asymmetric-pair ec \ --curve prime256v1 \ --public-label tls_ec_pub \ --private-label tls_ec_private \ --private-attributes sign=true { "error_code": 0, "data": { "public_key": { "key-reference": "0x000000000012000b", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "session" }, "attributes": { "key-type": "ec", "label": "tls_ec_pub", "id": "", "check-value": "0xd7c1a7", "class": "public-key", "encrypt": false, "decrypt": false, "token": false, "always-sensitive": false, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": false, "sign": false, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 57, "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c", "curve": "secp224r1" } }, "private_key": { "key-reference": "0x000000000012000c", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "session" }, "attributes": { "key-type": "ec", "label": "tls_ec_private", "id": "", "check-value": "0xd7c1a7", "class": "private-key", "encrypt": false, "decrypt": false, "token": false, "always-sensitive": true, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": true, "sign": true, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 122, "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c", "curve": "secp224r1" } } } } ``` **Exportieren einer gefälschten privaten PEM-Schlüsseldatei** Sobald Sie einen privaten Schlüssel auf dem HSM haben, müssen Sie eine gefälschte private PEM-Schlüsseldatei exportieren. Diese Datei enthält nicht die eigentlichen Schlüsseldaten, ermöglicht es der OpenSSL Dynamic Engine jedoch, den privaten Schlüssel auf dem HSM zu identifizieren. Sie können dann den privaten Schlüssel verwenden, um eine Zertifikatsignierungsanforderung (CSR) zu erstellen und die CSR zu signieren, um das Zertifikat zu erstellen. Verwenden Sie den [`key generate-file`](cloudhsm_cli-key-generate-file.md)Befehl, um den privaten Schlüssel im falschen PEM-Format zu exportieren und in einer Datei zu speichern. Ersetzen Sie die folgenden Werte durch Ihre eigenen. + **— Bezeichnung des privaten Schlüssels, den Sie im vorherigen Schritt generiert haben. + **— Name der Datei, in die Ihr gefälschter PEM-Schlüssel geschrieben wird. ``` aws-cloudhsm > key generate-file --encoding reference-pem --path --filter attr.label= { "error_code": 0, "data": { "message": "Successfully generated key file" } } ``` **Beenden Sie die CloudHSM-CLI** Führen Sie den folgenden Befehl aus, um die CloudHSM-CLI zu beenden. ``` aws-cloudhsm > quit ``` Sie sollten jetzt eine neue Datei auf Ihrem System haben, die sich unter dem ** im vorherigen Befehl angegebenen Pfad befindet. Diese Datei ist die gefälschte private PEM-Schlüsseldatei. ### Generieren eines selbstsignierten Zertifikats Sobald Sie einen gefälschten privaten PEM-Schlüssel generiert haben, können Sie diese Datei verwenden, um eine Zertifikatssignieranforderung (CSR) und ein Zertifikat zu generieren. In einer Produktionsumgebung verwenden Sie in der Regel eine Zertifikatsstelle (CA) zum Erstellen eines Zertifikats aus einer CSR. Für eine Testumgebung ist keine CA erforderlich. Wenn Sie eine Zertifizierungsstelle verwenden, senden Sie ihnen die CSR-Datei und verwenden Sie ein signiertes SSL/TLS Zertifikat, das sie Ihnen auf Ihrem Webserver für HTTPS zur Verfügung stellen. Als Alternative zur Verwendung einer CA können Sie die AWS CloudHSM OpenSSL Dynamic Engine verwenden, um ein selbstsigniertes Zertifikat zu erstellen. Selbstsignierte Zertifikate sind nicht vertrauenswürdig für Browser und sollten in Produktionsumgebungen nicht verwendet werden. Sie können in Testumgebungen verwendet werden. **Warnung** Selbstsignierte Zertifikate sollten nur in einer Testumgebung verwendet werden. Für eine Produktionsumgebung, verwenden Sie eine sicherere Methode, wie z. B. eine Zertifikatstelle, um ein Zertifikat zu erstellen. **Installieren und konfigurieren Sie die OpenSSL Dynamic Engine** 1. Stellen Sie eine Verbindung mit Ihrer Client-Instance her. 1. [Installieren Sie die OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5](openssl5-install.md) **Generieren eines Zertifikats** 1. Besorgen Sie sich eine Kopie Ihrer gefälschten PEM-Datei, die in einem früheren Schritt generiert wurde. 1. Erstellen einer CSR Führen Sie den folgenden Befehl aus, um mit der AWS CloudHSM OpenSSL Dynamic Engine eine Certificate Signing Request (CSR) zu erstellen. **Ersetzen Sie ihn durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. **Ersetzen Sie es durch den Namen der Datei, die Ihre CSR enthält. Der Befehl `req` ist interaktiv. Füllen Sie jedes Feld aus. Die Feldinformationen werden in Ihr SSL/TLS Zertifikat kopiert. **Anmerkung** Die CSR-Erstellung wird derzeit vom OpenSSL Provider nicht unterstützt. Sie müssen für diesen Schritt die OpenSSL Engine verwenden, aber TLS-Verschlüsselungsoperationen funktionieren mit dem Anbieter. ``` $ openssl req -engine cloudhsm -new -key -out ``` 1. Erstellen eines selbstsignierten Zertifikats Führen Sie den folgenden Befehl aus, um die AWS CloudHSM OpenSSL Dynamic Engine zu verwenden, um Ihre CSR mit Ihrem privaten Schlüssel auf Ihrem HSM zu signieren. Dadurch wird ein selbstsigniertes Zertifikat erstellt. Ersetzen Sie die folgenden Werte in dem Befehl durch Ihre eigenen. + **— Name der Datei, die die CSR enthält. + **— Name der Datei, die den gefälschten privaten PEM-Schlüssel enthält. + **— Name der Datei, die Ihr Webserver-Zertifikat enthalten wird. ``` $ openssl x509 -engine cloudhsm -req -days 365 -in -signkey -out ``` Nachdem Sie einen privaten Schlüssel und ein Zertifikat haben, gehen Sie zu[Schritt 3: Konfigurieren des Webservers](#ssl-offload-provider-configure-web-server). ## Schritt 3: Konfigurieren des Webservers Aktualisieren Sie die Konfiguration Ihrer Webserver-Software, um das HTTPS-Zertifikat und den zugehörigen gefälschten privaten PEM-Schlüssel zu verwenden, die Sie im [vorherigen Schritt](#ssl-offload-provider-generate-key-and-certificate) erstellt haben. Denken Sie daran, Ihre vorhandenen Zertifikate und Schlüssel zu sichern, bevor Sie beginnen. Damit ist die Einrichtung Ihrer Linux-Webserver-Software für das Auslagern von SSL/TLS Serveridentitäten mit abgeschlossen. AWS CloudHSM Führen Sie die Schritte aus einem der folgenden Abschnitte aus. **Topics** + [Konfigurieren eines NGINX-Webservers](#ssl-offload-provider-configure-nginx) + [Webserver konfigurieren HAProxy](#ssl-offload-provider-configure-haproxy) ### Konfigurieren eines NGINX-Webservers Verwenden Sie diesen Abschnitt, um NGINX mit dem OpenSSL Provider zu konfigurieren. **So konfigurieren Sie NGINX für OpenSSL Provider** 1. Stellen Sie eine Verbindung mit Ihrer Client-Instance her. 1. Führen Sie den folgenden Befehl aus, um die erforderlichen Verzeichnisse für das Webserverzertifikat und den gefälschten privaten PEM-Schlüssel zu erstellen. ``` $ mkdir -p /etc/pki/nginx/private ``` 1. Führen Sie den folgenden Befehl aus, um Ihr Webserverzertifikat an die erforderliche Stelle zu kopieren. Ersetzen Sie es ** durch den Namen Ihres Webserver-Zertifikats. ``` $ cp /etc/pki/nginx/server.crt ``` 1. Führen Sie den folgenden Befehl aus, um den gefälschten privaten PEM-Schlüssel an die erforderliche Stelle zu kopieren. **Ersetzen Sie es durch den Namen der Datei, die Ihren gefälschten privaten PEM-Schlüssel enthält. ``` $ cp /etc/pki/nginx/private/server.key ``` 1. Führen Sie den folgenden Befehl aus, um die Eigentümerschaft für diese Dateien zu ändern, sodass der Benutzer mit dem Namen *nginx* diese lesen kann. ``` $ chown nginx /etc/pki/nginx/server.crt /etc/pki/nginx/private/server.key ``` 1. Konfigurieren Sie OpenSSL für die Verwendung des AWS CloudHSM Anbieters. Weitere Informationen zur Konfiguration des OpenSSL Providers finden Sie unter [AWS CloudHSM OpenSSL Provider for Client SDK 5.](openssl-provider-install.md) 1. Suchen Sie Ihre OpenSSL-Konfigurationsdatei: ``` $ openssl version -d ``` Sie sollten eine Ausgabe sehen, die der folgenden ähnelt: ``` OPENSSLDIR: "/etc/pki/tls" ``` Die Konfigurationsdatei befindet sich `openssl.cnf` in diesem Verzeichnis. 1. **Anmerkung** Ändern Sie die Standarddatei openssl.cnf Ihres Systems nicht direkt. Dadurch wird verhindert, dass systemweite OpenSSL-Operationen (SSH, TLS-Verbindungen und andere Dienste) unbeabsichtigt über den CloudHSM-Anbieter weitergeleitet werden. Durch die Verwendung einer separaten Konfigurationsdatei können Sie die Nutzung des CloudHSM Providers auf bestimmte Anwendungen beschränken, die HSM-gestützte kryptografische Operationen erfordern. Erstellen Sie eine neue OpenSSL-Konfigurationsdatei mit dem folgenden Inhalt: ``` $ cat > << 'EOF' ## NOTE: This should point to the system default openssl config file. # Replace /etc/pki/tls with the path to your OpenSSL configuration directory .include /openssl.cnf # Override the existing provider_section to include AWS CloudHSM OpenSSL Provider as a 3rd party OpenSSL provider [provider_sect] default = default_sect # Include AWS CloudHSM CloudHSM OpenSSL provider cloudhsm = cloudhsm_sect [default_sect] activate = 1 [cloudhsm_sect] activate = 1 EOF ``` 1. Stellen Sie sicher, dass die `CLOUDHSM_PIN` Umgebungsvariable mit Ihren Crypto-Benutzeranmeldedaten (CU) gesetzt ist: ``` $ export CLOUDHSM_PIN=: ``` 1. Stellen Sie die `OPENSSL_CONF` Umgebungsvariable so ein, dass sie auf Ihre aktualisierte Konfigurationsdatei verweist, und stellen Sie sicher, dass der Anbieter geladen ist: ``` $ OPENSSL_CONF=/path/to/example-cloudhsm-openssl.cnf openssl list -providers ``` Sie sollten sowohl den Standardanbieter als auch den CloudHSM-Anbieter aufgelistet sehen: ``` OPENSSL_CONF=/path/to/example-cloudhsm-openssl.cnf openssl list -providers Providers: default name: OpenSSL Default Provider version: 3.2.2 status: active cloudhsm name: AWS CloudHSM OpenSSL Provider version: 5.17.0 status: active ``` 1. Führen Sie den folgenden Befehl aus, um die Datei `/etc/nginx/nginx.conf` zu sichern. ``` $ cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup ``` 1. Aktualisieren Sie die NGINX-Konfiguration. **Anmerkung** Jeder Cluster kann maximal 1000 NGINX-Worker-Prozesse auf allen NGINX-Webservern unterstützen. ------ #### [ Amazon Linux 2023 ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dafür sind möglicherweise Linux-Root-Rechte erforderlich. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters for DHE ciphers # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 # ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"; ssl_prefer_server_ciphers off; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ RHEL 9 (9.2\$1) ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dies erfordert möglicherweise Linux-Root-Rechte. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters for DHE ciphers # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 # ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"; ssl_prefer_server_ciphers off; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ RHEL 10 (10.0\$1) ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dies erfordert möglicherweise Linux-Root-Rechte. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters for DHE ciphers # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 # ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"; ssl_prefer_server_ciphers off; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ Ubuntu 24.04 ] Verwenden Sie einen Texteditor, um die Datei `/etc/nginx/nginx.conf` zu bearbeiten. Dies erfordert möglicherweise Linux-Root-Rechte. Fügen Sie am Anfang der Datei die folgende Zeilen hinzu: ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Fügen Sie dann dem Abschnitt TLS der Datei Folgendes hinzu: ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /var/www/html; ssl_certificate "/etc/ssl/certs/server.crt"; ssl_certificate_key "/etc/ssl/private/server.key"; # It is *strongly* recommended to generate unique DH parameters for DHE ciphers # Generate them with: openssl dhparam -out /etc/ssl/certs/dhparams.pem 2048 # ssl_dhparam "/etc/ssl/certs/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"; ssl_prefer_server_ciphers off; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ Speichern Sie die Datei. 1. Sichern Sie die `systemd`-Konfigurationsdatei und legen Sie dann den `EnvironmentFile`-Pfad fest. ------ #### [ Amazon Linux 2023 ] 1. Erstellen Sie eine Sicherungskopie der `nginx.service` Datei: ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie `/lib/systemd/system/nginx.service` in einem Texteditor. Fügen Sie im Abschnitt [Service] Folgendes hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ RHEL 9 (9.2\$1) ] 1. Erstellen Sie eine Sicherungskopie der `nginx.service` Datei: ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie `/lib/systemd/system/nginx.service` in einem Texteditor. Fügen Sie im Abschnitt [Service] Folgendes hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ RHEL 10 (10.0\$1) ] 1. Erstellen Sie eine Sicherungskopie der `nginx.service` Datei: ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie `/lib/systemd/system/nginx.service` in einem Texteditor. Fügen Sie im Abschnitt [Service] Folgendes hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ Ubuntu 24.04 ] 1. Erstellen Sie eine Sicherungskopie der `nginx.service` Datei: ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Öffnen Sie `/lib/systemd/system/nginx.service` in einem Texteditor. Fügen Sie im Abschnitt [Service] Folgendes hinzu: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ 1. Überprüfen Sie, ob die Datei `/etc/sysconfig/nginx` vorhanden ist, und führen Sie dann einen der folgenden Schritte aus: + Wenn die Datei vorhanden ist, sichern Sie die Datei, indem Sie den folgenden Befehl ausführen: ``` $ cp /etc/sysconfig/nginx /etc/sysconfig/nginx.backup ``` + Öffnen Sie einen Texteditor und erstellen Sie im Ordner `/etc/sysconfig/` eine Datei mit dem Namen `nginx`, wenn die Datei nicht vorhanden ist. 1. Konfigurieren Sie die NGINX-Umgebung. ------ #### [ Amazon Linux 2023 ] Öffnen Sie als Linux-Root-Benutzer die `/etc/sysconfig/nginx` Datei in einem Texteditor. Zum Beispiel ``` vi /etc/sysconfig/nginx ``` Fügen Sie die Cryptography User (CU) -Anmeldeinformationen und den Pfad zu Ihrer OpenSSL-Konfigurationsdatei hinzu: ``` CLOUDHSM_PIN=: OPENSSL_CONF= ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. **Ersetzen Sie durch den vollständigen Pfad zu der Konfigurationsdatei, in der Sie sie erstellt haben[So konfigurieren Sie NGINX für OpenSSL Provider](#configure-nginx-provider). Speichern Sie die Datei. ------ #### [ RHEL 9 (9.2\$1) ] Öffnen Sie die Datei `/etc/sysconfig/nginx` in einem Text-Editor. Dies erfordert möglicherweise Linux-Root-Rechte. Fügen Sie die Cryptography User (CU) -Anmeldeinformationen und den Pfad zu Ihrer OpenSSL-Konfigurationsdatei hinzu: ``` CLOUDHSM_PIN=: OPENSSL_CONF= ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. **Ersetzen Sie durch den vollständigen Pfad zu der Konfigurationsdatei, in der Sie sie erstellt haben[So konfigurieren Sie NGINX für OpenSSL Provider](#configure-nginx-provider). Speichern Sie die Datei. ------ #### [ RHEL 10 (10.0\$1) ] Öffnen Sie die Datei `/etc/sysconfig/nginx` in einem Text-Editor. Dies erfordert möglicherweise Linux-Root-Rechte. Fügen Sie die Cryptography User (CU) -Anmeldeinformationen und den Pfad zu Ihrer OpenSSL-Konfigurationsdatei hinzu: ``` CLOUDHSM_PIN=: OPENSSL_CONF= ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. **Ersetzen Sie durch den vollständigen Pfad zu der Konfigurationsdatei, in der Sie sie erstellt haben[So konfigurieren Sie NGINX für OpenSSL Provider](#configure-nginx-provider). Speichern Sie die Datei. ------ #### [ Ubuntu 24.04 ] Öffnen Sie die Datei `/etc/sysconfig/nginx` in einem Text-Editor. Dies erfordert möglicherweise Linux-Root-Rechte. Fügen Sie die Cryptography User (CU) -Anmeldeinformationen und den Pfad zu Ihrer OpenSSL-Konfigurationsdatei hinzu: ``` CLOUDHSM_PIN=: OPENSSL_CONF= ``` Ersetzen Sie ** und ** durch die CU-Anmeldeinformationen. **Ersetzen Sie durch den vollständigen Pfad zu der Konfigurationsdatei, in der Sie sie erstellt haben[So konfigurieren Sie NGINX für OpenSSL Provider](#configure-nginx-provider). Speichern Sie die Datei. ------ 1. Starten Sie den NGINX-Webserver. ------ #### [ Amazon Linux 2023 ] Stoppen Sie alle NGINX-Prozesse ``` $ systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ systemctl daemon-reload ``` Starten Sie NGINX ``` $ systemctl start nginx ``` ------ #### [ RHEL 9 (9.2\$1) ] Stoppen Sie alle laufenden NGINX-Prozesse ``` $ systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ systemctl daemon-reload ``` Starten Sie den NGINX-Prozess ``` $ systemctl start nginx ``` ------ #### [ RHEL 10 (10.0\$1) ] Stoppen Sie alle laufenden NGINX-Prozesse ``` $ systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ systemctl daemon-reload ``` Starten Sie den NGINX-Prozess ``` $ systemctl start nginx ``` ------ #### [ Ubuntu 24.04 ] Stoppen Sie alle laufenden NGINX-Prozesse ``` $ systemctl stop nginx ``` Laden Sie die `systemd`-Konfiguration neu, um die neuesten Änderungen zu erhalten ``` $ systemctl daemon-reload ``` Starten Sie den NGINX-Prozess ``` $ systemctl start nginx ``` ------ Nachdem Sie NGINX konfiguriert haben, gehen Sie zu. [Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet](#ssl-offload-verify-https-connection-linux) ### Webserver konfigurieren HAProxy Verwenden Sie diesen Abschnitt, um HAProxy mit dem OpenSSL Provider zu konfigurieren. Die folgenden Beispiele zeigen, wie Sie HAProxy mit Ihren CloudHSM-Zertifikaten und -Schlüsseln einrichten. **So konfigurieren Sie HAProxy für OpenSSL Provider** 1. Erstellen Sie eine Sicherungskopie der vorhandenen kombinierten Zertifikatsdatei, falls vorhanden: ``` $ cp server-combined.pem server-combined.pem.backup ``` 1. Erstellen Sie eine kombinierte Zertifikatsdatei für die HAProxy Verwendung Ihres Zertifikats und des gefälschten CloudHSM-PEM-Schlüssels: ``` $ cat server.crt server.key > server-combined.pem ``` 1. Erstellen Sie eine Sicherungskopie der vorhandenen Konfiguration: HAProxy ``` $ cp /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.backup ``` 1. Erstellen Sie eine neue CloudHSM-TLS-Offload-Konfiguration unter: `/etc/haproxy/haproxy.cfg` ``` global daemon ssl-provider cloudhsm # It is *strongly* recommended to generate unique DH parameters # Generate them with: openssl dhparam -out /etc/haproxy/dhparams.pem 2048 # ssl-dh-param-file /etc/haproxy/dhparams.pem ssl-default-bind-ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305 ssl-default-bind-ciphersuites TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256 ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets defaults mode http timeout connect 5000ms timeout client 50000ms timeout server 50000ms frontend haproxy_frontend bind *:443 ssl crt /path/to/server-combined.pem default_backend web_servers backend web_servers server web1 127.0.0.1:8080 check ``` Aktualisieren Sie den Zertifikatspfad so, dass er mit Ihrem Dateispeicherort übereinstimmt. 1. Konfigurieren Sie Systemd so, dass es eine Umgebungsdatei für HAProxy verwendet. Der Speicherort hängt von Ihrer Linux-Distribution ab. ------ #### [ Amazon Linux and RHEL ] Sichern und ändern Sie die HAProxy Servicedatei: ``` $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup ``` Bearbeiten Sie die folgende Zeile `/lib/systemd/system/haproxy.service` und fügen Sie sie im Abschnitt [Service] hinzu: ``` EnvironmentFile=/etc/sysconfig/haproxy ``` ------ #### [ Ubuntu ] Erstellen Sie eine Sicherungskopie und ändern Sie die HAProxy Servicedatei: ``` $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup ``` Bearbeiten Sie die folgende Zeile `/lib/systemd/system/haproxy.service` und fügen Sie sie im Abschnitt [Service] hinzu: ``` EnvironmentFile=/etc/default/haproxy ``` ------ 1. Erstellen Sie die Umgebungsdatei am entsprechenden Speicherort für Ihr System. ------ #### [ Amazon Linux and RHEL ] Sichern Sie die HAProxy Umgebungsdatei, falls sie existiert: ``` $ cp /etc/sysconfig/haproxy /etc/sysconfig/haproxy.backup ``` Erstellen Sie die HAProxy Umgebungsdatei `/etc/sysconfig/haproxy` mit dem folgenden Inhalt: ``` CLOUDHSM_PIN=: ``` ------ #### [ Ubuntu ] Erstellen Sie eine HAProxy Sicherungskopie der Umgebungsdatei, falls sie existiert: ``` $ cp /etc/default/haproxy /etc/default/haproxy.backup ``` Erstellen Sie die HAProxy Umgebungsdatei `/etc/default/haproxy` mit dem folgenden Inhalt: ``` CLOUDHSM_PIN=: ``` ------ Ersetzen Sie ** und ** durch Ihre CU-Anmeldeinformationen. 1. Laden Sie die Systemd-Konfiguration neu: ``` $ systemctl daemon-reload ``` 1. Beginnen Sie HAProxy mit der CloudHSM TLS-Offload-Konfiguration: ``` $ systemctl start haproxy ``` Sie können den Vorgang auch HAProxy direkt mit einer benutzerdefinierten Konfigurationsdatei ausführen: ``` $ haproxy -f /path/to/haproxy-cloudhsm.cfg ``` Gehen Sie nach HAProxy der Konfiguration zu[Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet](#ssl-offload-verify-https-connection-linux). ## Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats Nachdem Sie Ihren Webserver für SSL/TLS Offload mit konfiguriert haben AWS CloudHSM, fügen Sie Ihre Webserver-Instanz einer Sicherheitsgruppe hinzu, die eingehenden HTTPS-Verkehr zulässt. Dadurch können Clients, wie z. B. Webbrowser, eine HTTPS-Verbindung mit Ihrem Webserver herstellen. Stellen Sie dann eine HTTPS-Verbindung zu Ihrem Webserver her und stellen Sie sicher, dass er das Zertifikat verwendet, mit dem Sie das SSL/TLS Offload konfiguriert haben. AWS CloudHSM **Topics** + [Aktivieren von eingehenden HTTPS-Verbindungen](#ssl-offload-add-security-group-linux) + [Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet](#ssl-offload-verify-https-connection-linux) ### Aktivieren von eingehenden HTTPS-Verbindungen Zum Herstellen einer Verbindung zu Ihrem Webserver von einem Client (z. B. ein Webbrowser) aus, erstellen Sie eine Sicherheitsgruppe, die eingehende HTTPS-Verbindungen zulässt. Insbesondere sollten eingehende TCP-Verbindungen auf Port 443 erlaubt werden. Weisen Sie diese Sicherheitsgruppe Ihrem Webserver zu. **So erstellen Sie eine Sicherheitsgruppe für HTTPS und weisen sie Ihrem Webserver zu** 1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. Wählen Sie im Navigationsbereich **Sicherheitsgruppen** aus. 1. Wählen Sie **Sicherheitsgruppe erstellen**. 1. Führen Sie für **Sicherheitsgruppe erstellen** die folgenden Schritte aus: 1. Geben Sie in das Feld **Sicherheitsgruppenname** einen Namen für die Sicherheitsgruppe ein, die Sie erstellen. 1. (Optional) Geben Sie eine Beschreibung der Sicherheitsgruppe ein, die Sie erstellen. 1. Wählen Sie für **VPC** die VPC aus, die Ihre Amazon-EC2-Instance enthält. 1. Wählen Sie **Regel hinzufügen** aus. 1. Wählen Sie im Drop-down-Fenster für **Typ** die Option **HTTPS** aus. 1. Geben Sie für **Quelle** einen Quellspeicherort ein. 1. Wählen Sie **Sicherheitsgruppe erstellen** aus. 1. Wählen Sie im Navigationsbereich **Instances** aus. 1. Aktivieren Sie das Kontrollkästchen neben Ihrer Webserver-Instance. 1. Wählen Sie das Drop-down-Menü **Aktionen** oben auf der Seite. Wählen Sie **Sicherheit** und dann **Sicherheitsgruppen ändern** aus. 1. Wählen Sie unter **Zugeordnete Sicherheitsgruppen** das Suchfeld aus und wählen Sie die Sicherheitsgruppe, die Sie für HTTPS erstellt haben, aus. Wählen Sie dann **Sicherheitsgruppen hinzufügen** aus. 1. Wählen Sie **Speichern**. ### Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet Nachdem Sie den Webserver zu einer Sicherheitsgruppe hinzugefügt haben, können Sie überprüfen, ob für den SSL/TLS Offload Ihr selbstsigniertes Zertifikat verwendet wird. Sie können dazu einen Webbrowser oder ein Tool wie [OpenSSL s\$1client](https://www.openssl.org/docs/manmaster/man1/s_client.html) nutzen. **Um den SSL/TLS Offload mit einem Webbrowser zu überprüfen** 1. Verwenden Sie einen Web-Browser, um eine Verbindung zum Webserver unter Verwendung des öffentlichen DNS-Namen oder der IP-Adresse des Servers herzustellen. Stellen Sie sicher, dass die URL in die Adresszeile mit https:// beginnt. Beispiel, **https://ec2-52-14-212-67.us-east-2.compute.amazonaws.com/**. **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Zeigen Sie das Webserverzertifikat mit Ihrem Webbrowser an. Weitere Informationen finden Sie hier: + Wenn Sie Mozilla Firefox nutzen, sehen Sie sich die Informationen auf der Mozilla Support-Website unter [Zertifikat anzeigen](https://support.mozilla.org/en-US/kb/secure-website-certificate#w_view-a-certificate) an. + Wenn Sie Google Chrome verwenden, sehen Sie sich die Informationen auf der „Google Tools für Web Developers“-Website unter [Sicherheitsprobleme verstehen](https://developers.google.com/web/tools/chrome-devtools/security) an. Andere Webbrowser unterstützen möglicherweise ähnliche Funktionen, über die Sie das Webserverzertifikat anzeigen können. 1. Stellen Sie sicher, dass es sich bei dem SSL/TLS Zertifikat um das Zertifikat handelt, für dessen Verwendung Sie Ihren Webserver konfiguriert haben. **Um den SSL/TLS Offload mit OpenSSL s\$1client zu überprüfen** 1. Führen Sie den folgenden OpenSSL-Befehl aus, um mittels HTTPS eine Verbindung zu Ihrem Webserver herzustellen. **Ersetzen Sie es durch den öffentlichen DNS-Namen oder die IP-Adresse Ihres Webservers. ``` openssl s_client -connect :443 ``` **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Stellen Sie sicher, dass es sich bei dem SSL/TLS Zertifikat um das Zertifikat handelt, für dessen Verwendung Sie Ihren Webserver konfiguriert haben. Sie verfügen jetzt über eine mit HTTPS gesicherte Website. Der private Schlüssel für den Webserver wird in einem HSM in Ihrem AWS CloudHSM Cluster gespeichert. Informationen zum Hinzufügen eines Load Balancers finden Sie unter [Einen Load Balancer mit Elastic Load Balancing hinzufügen für AWS CloudHSM(optional)](third-offload-add-lb.md). # AWS CloudHSM SSL/TLS-Offload unter Linux mit Tomcat mit JSSE Dieses Thema enthält step-by-step Anweisungen zum Einrichten von SSL/TLS Offloads mithilfe der Java Secure Socket Extension (JSSE) mit dem JCE SDK. AWS CloudHSM **Topics** + [-Übersicht](#third-offload-linux-jsse-overview) + [Schritt 1: Einrichten der Voraussetzungen](#third-offload-linux-jsse-prereqs) + [Schritt 2: Generieren oder importieren Sie einen privaten Schlüssel und ein Zertifikat SSL/TLS](#third-offload-linux-jsse-gen) + [Schritt 3: Konfigurieren des Tomcat-Webservers](#third-offload-linux-jsse-config) + [Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats](#third-offload-linux-jsse-verify) ## -Übersicht In AWS CloudHSM: Tomcat-Webserver funktionieren unter Linux und unterstützen HTTPS. Das AWS CloudHSM JCE SDK bietet eine Schnittstelle, die mit JSSE (Java Secure Socket Extension) verwendet werden kann, um die Verwendung von HSMs für solche Webserver zu ermöglichen. AWS CloudHSM JCE ist die Brücke, die JSSE mit Ihrem AWS CloudHSM CloudHSM-Cluster verbindet. JSSE ist eine Java-API für Secure Sockets Layer (SSL) und Transport Layer Security (TLS). ## Schritt 1: Einrichten der Voraussetzungen Erfüllen Sie diese Voraussetzungen, um einen Tomcat-Webserver AWS CloudHSM für SSL/TLS Offload unter Linux zu verwenden. Diese Voraussetzungen müssen erfüllt sein, um den SSL/TLS Webserver-Offload mit dem Client SDK 5 und einem Tomcat-Webserver einzurichten. **Anmerkung** Verschiedene Plattformen erfordern unterschiedliche Voraussetzungen. Folgen Sie immer den richtigen Installationsschritten für Ihre Plattform. ### Voraussetzungen + Eine Amazon EC2-Instance, auf der ein Linux-Betriebssystem mit einem installierten Tomcat-Webserver ausgeführt wird. + Ein [Crypto-Benutzer](understanding-users.md#crypto-user-chsm-cli) (CU), der den privaten Schlüssel des Webservers auf dem HSM besitzen und verwalten soll. + Ein aktiver AWS CloudHSM Cluster mit mindestens zwei Hardware-Sicherheitsmodulen (HSMs), auf denen [JCE for Client SDK 5](java-library-install_5.md) installiert und konfiguriert ist. **Anmerkung** Sie können einen einzelnen HSM-Cluster verwenden, müssen aber zuerst die Haltbarkeit der Client-Schlüssel deaktivieren. Weitere Informationen finden Sie unter [Einstellungen für die Haltbarkeit von Client-Schlüsseln verwalten](working-client-sync.md#client-sync-sdk8) und [Client-SDK 5 Configure Tool](configure-sdk-5.md). #### Wie erfüllt man die Voraussetzungen 1. Installieren und konfigurieren Sie das JCE für AWS CloudHSM auf einem aktiven AWS CloudHSM Cluster mit mindestens zwei Hardware-Sicherheitsmodulen ()HSMs. Weitere Informationen zur Installation finden Sie unter [JCE für Client-SDK 5.](java-library-install_5.md) 1. Folgen Sie auf einer EC2-Linux-Instance, die Zugriff auf Ihren AWS CloudHSM Cluster hat, den [Apache Tomcat-Anweisungen](https://tomcat.apache.org/download-90.cgi ), um den Tomcat-Webserver herunterzuladen und zu installieren. 1. Verwenden Sie die [CloudHSM-CLI](cloudhsm_cli.md), um einen Crypto-Benutzer (CU) zu erstellen. Weitere Informationen zur Verwaltung von HSM-Benutzern finden Sie unter [HSM-Benutzer mit der CloudHSM-CLI verwalten](manage-hsm-users-chsm-cli.md). **Tipp** Merken Sie sich den CU-Benutzernamen und das Passwort. Sie benötigen sie später beim Generieren oder Importieren des privaten HTTPS-Schlüssels und -Zertifikats für Ihren Webserver. 1. Folgen Sie den Anweisungen unter [Verwenden Sie Client SDK 5 zur Integration AWS CloudHSM mit Java Keytool und Jarsigner](keystore-third-party-tools_5.md), um JCE mit Java Keytool einzurichten. Nachdem Sie diese Schritte abgeschlossen haben, fahren Sie mit [Schritt 2: Generieren oder importieren Sie einen privaten Schlüssel und ein Zertifikat SSL/TLS](#third-offload-linux-jsse-gen) fort. #### Hinweise + Um Security-Enhanced Linux (SELinux) und Webserver zu verwenden, müssen Sie ausgehende TCP-Verbindungen an Port 2223 zulassen, dem Port, den das Client SDK 5 für die Kommunikation mit dem HSM verwendet. + Um einen Cluster zu erstellen und zu aktivieren und einer EC2-Instance Zugriff auf den Cluster zu gewähren, führen Sie die Schritte unter [Erste Schritte mit AWS CloudHSM](getting-started.md) aus. Dieser Abschnitt enthält step-by-step Anweisungen zum Erstellen eines aktiven Clusters mit einem HSM und einer Amazon EC2 EC2-Client-Instance. Sie können diese Client-Instance als Ihren Webserver verwenden. + Um zu vermeiden, dass die Haltbarkeit von Client-Schlüsseln deaktiviert wird, fügen Sie Ihrem Cluster mehr als ein HSM hinzu. Weitere Informationen finden Sie unter [Hinzufügen eines HSM zu einem Cluster AWS CloudHSM](add-hsm.md). + Um sich mit Ihrer Client-Instance zu verbinden, können Sie SSH oder PuTTY verwenden. Weitere Informationen finden Sie unter [Herstellung einer Verbindung zu Ihrer Linux-Instance mit SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html) oder [Herstellung einer Verbindung zu Ihrer Linux-Instance von Windows mit PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html) in der Amazon EC2-Dokumentation. ## Schritt 2: Generieren oder importieren Sie einen privaten Schlüssel und ein Zertifikat SSL/TLS Um HTTPS zu aktivieren, benötigt Ihre Tomcat-Webserver-Anwendung einen privaten Schlüssel und ein entsprechendes Zertifikat. SSL/TLS Um das SSL/TLS Webserver-Offload mit verwenden zu können AWS CloudHSM, müssen Sie den privaten Schlüssel in einem HSM in Ihrem Cluster speichern. AWS CloudHSM **Anmerkung** Wenn Sie noch nicht über einen privaten Schlüssel und ein entsprechendes Zertifikat verfügen, generieren Sie einen privaten Schlüssel in einem HSM. Sie verwenden den privaten Schlüssel, um eine Certificate Signing Request (CSR) zu erstellen, mit der Sie das Zertifikat erstellen. SSL/TLS Sie erstellen eine lokale AWS CloudHSM KeyStore Datei, die einen Verweis auf Ihren privaten Schlüssel auf dem HSM und das zugehörige Zertifikat enthält. Ihr Webserver verwendet die AWS CloudHSM KeyStore Datei, um den privaten Schlüssel auf dem HSM während SSL/TLS des Offloads zu identifizieren. **Topics** + [Generieren eines privaten Schlüssels](#jsse-ssl-offload-generate-private-key) + [Generieren eines selbstsignierten Zertifikats](#jsse-ssl-offload-generate-certificate) ### Generieren eines privaten Schlüssels In diesem Abschnitt erfahren Sie, wie Sie mit dem KeyTool From JDK ein key pair generieren. Sobald Sie ein key pair im HSM generiert haben, können Sie es als KeyStore Datei exportieren und das entsprechende Zertifikat generieren. Je nach Anwendungsfall können Sie entweder ein RSA- oder ein EC-Schlüsselpaar generieren. Im Folgenden wird beschrieben, wie Sie ein RSA-Schlüsselpaar generieren. **Verwenden Sie den `genkeypair` Befehl in KeyTool , um ein RSA-Schlüsselpaar zu generieren** 1. Nachdem Sie die ** folgenden Daten durch Ihre spezifischen Daten ersetzt haben, verwenden Sie den folgenden Befehl, um eine Keystore-Datei mit dem Namen zu generieren`jsse_keystore.keystore`, die eine Referenz Ihres privaten Schlüssels auf dem HSM enthält. ``` $ keytool -genkeypair -alias -keyalg -keysize -sigalg \ -keystore /.keystore -storetype CLOUDHSM \ -dname CERT_DOMAIN_NAME \ -J-classpath '-J'$JAVA_LIB'/*:/opt/cloudhsm/java/*:./*' \ -provider "com.amazonaws.cloudhsm.jce.provider.CloudHsmProvider" \ -providerpath "$CLOUDHSM_JCE_LOCATION" \ -keypass -storepass ``` + ******: Der Pfad, in dem Sie Ihre Keystore-Datei generieren möchten. + ******: Dies wird verwendet, um Ihren Schlüssel auf dem HSM eindeutig zu identifizieren. Dieser Alias wird als LABEL-Attribut für den Schlüssel festgelegt. + ******: Wir speichern den Verweis auf Ihren Schlüssel in der lokalen Keystore-Datei, und dieses Passwort schützt diese lokale Referenz. + ******: Dies ist das Passwort für Ihre lokale Keystore-Datei. + ******: Name der Keystore-Datei. + ******: X.500 Eindeutiger Name. + ******: Schlüsselalgorithmus zur Generierung key pair (z. B. RSA und EC). + ******: Schlüsselgröße zur Generierung des key pair (z. B. 2048, 3072 und 4096). + ******: Schlüsselgröße zur Generierung des key pair (z. B. RSA, SHA1with RSA, SHA224with RSA, SHA256with RSA und SHA384with RSA). SHA512with 1. Um zu bestätigen, dass der Befehl erfolgreich war, geben Sie den folgenden Befehl ein und überprüfen Sie, ob Sie erfolgreich ein RSA-Schlüsselpaar generiert haben. ``` $ ls /.keystore ``` ### Generieren eines selbstsignierten Zertifikats Nachdem Sie zusammen mit der Keystore-Datei einen privaten Schlüssel generiert haben, können Sie diese Datei verwenden, um eine Certificate Signing Request (CSR) und ein Zertifikat zu generieren. In einer Produktionsumgebung verwenden Sie in der Regel eine Zertifikatsstelle (CA) zum Erstellen eines Zertifikats aus einer CSR. Für eine Testumgebung ist keine CA erforderlich. Wenn Sie eine Zertifizierungsstelle verwenden, senden Sie ihnen die CSR-Datei und verwenden Sie ein signiertes SSL/TLS Zertifikat, das sie Ihnen auf Ihrem Webserver für HTTPS zur Verfügung stellen. Als Alternative zur Verwendung einer Zertifizierungsstelle können Sie die verwenden, KeyTool um ein selbstsigniertes Zertifikat zu erstellen. Selbstsignierte Zertifikate sind nicht vertrauenswürdig für Browser und sollten in Produktionsumgebungen nicht verwendet werden. Sie können in Testumgebungen verwendet werden. **Warnung** Selbstsignierte Zertifikate sollten nur in einer Testumgebung verwendet werden. Für eine Produktionsumgebung, verwenden Sie eine sicherere Methode, wie z. B. eine Zertifikatstelle, um ein Zertifikat zu erstellen. **Topics** **Generieren eines Zertifikats** 1. Besorgen Sie sich eine Kopie Ihrer Keystore-Datei, die in einem früheren Schritt generiert wurde. 1. Führen Sie den folgenden Befehl aus, um mit dem eine Zertifikatsignieranforderung (CSR) KeyTool zu erstellen. ``` $ keytool -certreq -keyalg RSA -alias unique_alias_for_key -file certreq.csr \ -keystore .keystore -storetype CLOUDHSM \ -J-classpath '-J$JAVA_LIB/*:/opt/cloudhsm/java/*:./*' \ -keypass -storepass ``` **Anmerkung** Die Ausgabedatei der Zertifikatssignierungsanforderung ist `certreq.csr`. **Ein Zertifikat signieren** + Nachdem ** Sie die folgenden Daten durch Ihre spezifischen Daten ersetzt haben, führen Sie den folgenden Befehl aus, um Ihre CSR mit Ihrem privaten Schlüssel auf Ihrem HSM zu signieren. Dadurch wird ein selbstsigniertes Zertifikat erstellt. ``` $ keytool -gencert -infile certreq.csr -outfile certificate.crt \ -alias -keypass -storepass -sigalg SIG_ALG \ -storetype CLOUDHSM -J-classpath '-J$JAVA_LIB/*:/opt/cloudhsm/java/*:./*' \ -keystore jsse_keystore.keystore ``` **Anmerkung** `certificate.crt` ist das signierte Zertifikat, das den privaten Schlüssel des Alias verwendet. **Ein Zertifikat in Keystore importieren** + Nachdem ** Sie das Folgende durch Ihre spezifischen Daten ersetzt haben, führen Sie den folgenden Befehl aus, um ein signiertes Zertifikat als vertrauenswürdiges Zertifikat zu importieren. In diesem Schritt wird das Zertifikat in dem durch den Alias identifizierten Keystore-Eintrag gespeichert. ``` $ keytool -import -alias -keystore jsse_keystore.keystore \ -file certificate.crt -storetype CLOUDHSM \ -v -J-classpath '-J$JAVA_LIB/*:/opt/cloudhsm/java/*:./*' \ -keypass -storepass ``` **Konvertiert ein Zertifikat in ein PEM** + Führen Sie den folgenden Befehl aus, um die signierte Zertifikatsdatei (`.crt`) in eine PEM-Datei zu konvertieren. Die PEM-Datei wird verwendet, um die Anfrage vom HTTP-Client zu senden. ``` $ openssl x509 -inform der -in certificate.crt -out certificate.pem ``` Nachdem Sie diese Schritte ausgeführt haben, fahren Sie mit [Schritt 3: Konfigurieren des Webservers](#third-offload-linux-jsse-config) fort. ## Schritt 3: Konfigurieren des Tomcat-Webservers Aktualisieren Sie die Konfiguration Ihrer Webserver-Software, um das HTTPS-Zertifikat und die entsprechende PEM-Datei zu verwenden, die Sie im vorherigen Schritt erstellt haben. Denken Sie daran, Ihre vorhandenen Zertifikate und Schlüssel zu sichern, bevor Sie beginnen. Damit ist die Einrichtung Ihrer Linux-Webserver-Software für das SSL/TLS Offload mit abgeschlossen. AWS CloudHSM Weitere Informationen finden Sie in der [Konfigurationsreferenz für Apache Tomcat 9](https://tomcat.apache.org/tomcat-9.0-doc/config/http.html). **Den Server beenden** + Nachdem ** Sie die folgenden Daten durch Ihre spezifischen Daten ersetzt haben, führen Sie den folgenden Befehl aus, um Tomcat Server zu beenden, bevor Sie die Konfiguration aktualisieren ``` $ //bin/shutdown.sh ``` + ******: Ihr Tomcat-Installationsverzeichnis. **Aktualisieren Sie den Tomcat-Klassenpfad** 1. Stellen Sie eine Verbindung mit Ihrer Client-Instance her. 1. Suchen Sie den Tomcat-Installationsordner. 1. Nachdem ** Sie das Folgende durch Ihre spezifischen Daten ersetzt haben, verwenden Sie den folgenden Befehl, um die Java-Bibliothek und AWS CloudHSM den Java-Pfad in Tomcat hinzuzufügen**classpath**, die sich in der SH-Datei befinden. Tomcat/bin/catalina ``` $ sed -i 's@CLASSPATH="$CLASSPATH""$CATALINA_HOME"\/bin\/bootstrap.jar@CLASSPATH="$CLASSPATH""$CATALINA_HOME"\/bin\/bootstrap.jar:'" "'\/*:\/opt\/cloudhsm\/java\/*:.\/*@' /bin/catalina.sh ``` + ******: Speicherort der Java JRE-Bibliothek. + ******: Tomcat-Installationsordner. **Fügen Sie der Serverkonfiguration einen HTTPS-Connector hinzu.** 1. Gehen Sie zum Tomcat-Installationsordner. 1. Nachdem ** Sie die folgenden Daten durch Ihre spezifischen Daten ersetzt haben, verwenden Sie den folgenden Befehl, um einen HTTPS-Connector hinzuzufügen, um Zertifikate zu verwenden, die in den Voraussetzungen generiert wurden: ``` $ sed -i '//.keystore\" keystorePass=\"\" keyPass=\" \" keyAlias=\"" clientAuth=\"false\" sslProtocol=\"TLS\"/>' /conf/server.xml ``` + ******: Verzeichnis, in dem sich die Keystore-Datei befindet. + ******: Name der Keystore-Datei. + ******: Dies ist das Passwort für Ihre lokale Keystore-Datei. + ******: Wir speichern den Verweis auf Ihren Schlüssel in der lokalen Keystore-Datei, und dieses Passwort schützt diese lokale Referenz. + ******: Dies wird verwendet, um Ihren Schlüssel auf dem HSM eindeutig zu identifizieren. Dieser Alias wird als LABEL-Attribut für den Schlüssel festgelegt. + ******: Der Pfad zu Ihrem Tomcat-Ordner. **Starten des Servers** + Nachdem ** Sie das Folgende durch Ihre spezifischen Daten ersetzt haben, verwenden Sie den folgenden Befehl, um Tomcat Server zu starten: ``` $ //bin/startup.sh ``` **Anmerkung** ******ist der Name Ihres Tomcat-Installationsverzeichnisses. Nachdem Sie Ihre Webserverkonfiguration aktualisiert haben, gehen Sie zu [Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats](#third-offload-linux-jsse-verify). ## Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats Nachdem Sie Ihren Webserver für SSL/TLS Offload mit konfiguriert haben AWS CloudHSM, fügen Sie Ihre Webserver-Instanz einer Sicherheitsgruppe hinzu, die eingehenden HTTPS-Verkehr zulässt. Dadurch können Clients, wie z. B. Webbrowser, eine HTTPS-Verbindung mit Ihrem Webserver herstellen. Stellen Sie dann eine HTTPS-Verbindung zu Ihrem Webserver her und stellen Sie sicher, dass er das Zertifikat verwendet, mit dem Sie das SSL/TLS Offload konfiguriert haben. AWS CloudHSM **Topics** + [Aktivieren von eingehenden HTTPS-Verbindungen](#jsse-linux-add-security-group) + [Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet](#jsse-linux-verify-https-connection) ### Aktivieren von eingehenden HTTPS-Verbindungen Zum Herstellen einer Verbindung zu Ihrem Webserver von einem Client (z. B. ein Webbrowser) aus, erstellen Sie eine Sicherheitsgruppe, die eingehende HTTPS-Verbindungen zulässt. Insbesondere sollten eingehende TCP-Verbindungen auf Port 443 erlaubt werden. Weisen Sie diese Sicherheitsgruppe Ihrem Webserver zu. **So erstellen Sie eine Sicherheitsgruppe für HTTPS und weisen sie Ihrem Webserver zu** 1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. Wählen Sie im Navigationsbereich **Sicherheitsgruppen** aus. 1. Wählen Sie **Sicherheitsgruppe erstellen**. 1. Führen Sie für **Sicherheitsgruppe erstellen** die folgenden Schritte aus: 1. Geben Sie in das Feld **Sicherheitsgruppenname** einen Namen für die Sicherheitsgruppe ein, die Sie erstellen. 1. (Optional) Geben Sie eine Beschreibung der Sicherheitsgruppe ein, die Sie erstellen. 1. Wählen Sie für **VPC** die VPC aus, die Ihre Amazon-EC2-Instance enthält. 1. Wählen Sie **Regel hinzufügen** aus. 1. Wählen Sie im Drop-down-Fenster für **Typ** die Option **HTTPS** aus. 1. Geben Sie für **Quelle** einen Quellspeicherort ein. 1. Wählen Sie **Sicherheitsgruppe erstellen** aus. 1. Wählen Sie im Navigationsbereich **Instances** aus. 1. Aktivieren Sie das Kontrollkästchen neben Ihrer Webserver-Instance. 1. Wählen Sie das Drop-down-Menü **Aktionen** oben auf der Seite. Wählen Sie **Sicherheit** und dann **Sicherheitsgruppen ändern** aus. 1. Wählen Sie unter **Zugeordnete Sicherheitsgruppen** das Suchfeld aus und wählen Sie die Sicherheitsgruppe, die Sie für HTTPS erstellt haben, aus. Wählen Sie dann **Sicherheitsgruppen hinzufügen** aus. 1. Wählen Sie **Speichern**. ### Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet Nachdem Sie den Webserver zu einer Sicherheitsgruppe hinzugefügt haben, können Sie überprüfen, ob der SSL/TLS Offload Ihr selbstsigniertes Zertifikat verwendet. Sie können dazu einen Webbrowser oder ein Tool wie [OpenSSL s\$1client](https://www.openssl.org/docs/manmaster/man1/s_client.html) nutzen. **Um den SSL/TLS Offload mit einem Webbrowser zu überprüfen** 1. Verwenden Sie einen Web-Browser, um eine Verbindung zum Webserver unter Verwendung des öffentlichen DNS-Namen oder der IP-Adresse des Servers herzustellen. Stellen Sie sicher, dass die URL in die Adresszeile mit https:// beginnt. Beispiel, **https://ec2-52-14-212-67.us-east-2.compute.amazonaws.com/**. **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Zeigen Sie das Webserverzertifikat mit Ihrem Webbrowser an. Weitere Informationen finden Sie hier: + Wenn Sie Mozilla Firefox nutzen, sehen Sie sich die Informationen auf der Mozilla Support-Website unter [Zertifikat anzeigen](https://support.mozilla.org/en-US/kb/secure-website-certificate#w_view-a-certificate) an. + Wenn Sie Google Chrome verwenden, sehen Sie sich die Informationen auf der „Google Tools für Web Developers“-Website unter [Sicherheitsprobleme verstehen](https://developers.google.com/web/tools/chrome-devtools/security) an. Andere Webbrowser unterstützen möglicherweise ähnliche Funktionen, über die Sie das Webserverzertifikat anzeigen können. 1. Stellen Sie sicher, dass es sich bei dem SSL/TLS Zertifikat um das Zertifikat handelt, für dessen Verwendung Sie Ihren Webserver konfiguriert haben. **Um den SSL/TLS Offload mit OpenSSL s\$1client zu überprüfen** 1. Führen Sie den folgenden OpenSSL-Befehl aus, um mittels HTTPS eine Verbindung zu Ihrem Webserver herzustellen. **Ersetzen Sie es durch den öffentlichen DNS-Namen oder die IP-Adresse Ihres Webservers. ``` openssl s_client -connect :443 ``` **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Stellen Sie sicher, dass es sich bei dem SSL/TLS Zertifikat um das Zertifikat handelt, für dessen Verwendung Sie Ihren Webserver konfiguriert haben. Sie verfügen jetzt über eine mit HTTPS gesicherte Website. Der private Schlüssel für den Webserver wird in einem HSM in Ihrem AWS CloudHSM Cluster gespeichert. Informationen zum Hinzufügen eines Load Balancers finden Sie unter [Einen Load Balancer mit Elastic Load Balancing hinzufügen für AWS CloudHSM(optional)](third-offload-add-lb.md). # AWS CloudHSM SSL/TLS-Offload unter Windows mithilfe von IIS mit KSP Dieses Tutorial enthält step-by-step Anweisungen zum Einrichten von SSL/TLS Offload mit AWS CloudHSM auf einem Windows-Webserver. **Topics** + [-Übersicht](#ssl-offload-windows-overview) + [Schritt 1: Einrichten der Voraussetzungen](#ssl-offload-prerequisites-windows) + [Schritt 2: Erstellen einer Zertifikatsignierungsanforderung (CSR) und eines Zertifikats](#ssl-offload-windows-create-csr-and-certificate) + [Schritt 3: Konfigurieren des Webservers](#ssl-offload-configure-web-server-windows) + [Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats](#ssl-offload-enable-traffic-and-verify-certificate-windows) ## -Übersicht Unter Windows bietet die Webserveranwendung [Internet Information Services (IIS) für Windows Server](https://www.iis.net/) native Unterstützung für HTTPS. Der [AWS CloudHSM Key Storage Provider (KSP) für Microsofts Cryptography API: Next Generation (CNG)](ksp-library.md) stellt die Schnittstelle bereit, über die IIS den HSMs in Ihrem Cluster für kryptografisches Offloading und Schlüsselspeicher verwenden kann. Der AWS CloudHSM KSP ist die Brücke, die IIS mit Ihrem Cluster verbindet. AWS CloudHSM In diesem Tutorial erfahren Sie, wie Sie folgende Aufgaben ausführen: + Installieren der Web-Server-Software auf einer Amazon EC2-Instance + Konfigurieren Sie die Webserver-Software so, dass sie HTTPS mit einem privaten Schlüssel unterstützt, der in Ihrem AWS CloudHSM -Cluster gespeichert ist. + (Optional) Verwenden Sie Amazon EC2, um eine zweite Webserver-Instance zu erstellen, und Elastic Load Balancing, um einen Load Balancer zu erstellen. Mit einem Load Balancer kann die Leistung durch Verteilung der Arbeitslast auf mehrere Server gesteigert werden. Sie kann auch für Redundanz und eine höhere Verfügbarkeit sorgen, falls ein oder mehrere Webserver ausfallen. Wenn Sie bereit sind, sehen Sie sich [Schritt 1: Einrichten der Voraussetzungen](#ssl-offload-prerequisites-windows) an. ## Schritt 1: Einrichten der Voraussetzungen Verschiedene Plattformen erfordern unterschiedliche Voraussetzungen. Verwenden Sie den Abschnitt mit den Voraussetzungen unten, der zu Ihrer Plattform passt. **Topics** + [Voraussetzungen für das Client-SDK 5](#ssl-offload-prerequisites-windows-sdk5) + [Voraussetzungen für das Client-SDK 3](#ssl-offload-prerequisites-windows-sdk3) ### Voraussetzungen für das Client-SDK 5 Um das SSL/TLS Webserver-Offload mit einzurichten AWS CloudHSM, benötigen Sie Folgendes: + Ein aktiver AWS CloudHSM Cluster mit mindestens einem HSM. + Eine Amazon EC2-Instance, auf der ein Windows-Betriebssystem ausgeführt wird und die folgende Software installiert ist: + Die AWS CloudHSM Client-Software für Windows. + Internet Information Services (IIS) für Windows Server + Ein [Crypto-Benutzer](understanding-users.md#crypto-user-chsm-cli) (CU), der den privaten Schlüssel des Webservers auf dem HSM besitzen und verwalten soll. **Anmerkung** Dieses Tutorial verwendet Microsoft Windows Server 2019. Microsoft Windows Server 2016 und 2022 werden ebenfalls unterstützt. **So richten Sie eine Windows-Webserver-Instance auf dem HSM ein und erstellen einen CU** 1. Führen Sie die Schritte unter [Erste Schritte](getting-started.md) aus. Wenn Sie den Amazon EC2 EC2-Client starten, wählen Sie ein Windows Server 2019-AMI. Wenn Sie diese Schritte ausgeführt haben, verfügen Sie über einen aktiven Cluster mit mindestens einem HSM. Sie haben auch eine Amazon EC2 EC2-Client-Instance, auf der Windows Server ausgeführt wird und auf der die AWS CloudHSM Client-Software für Windows installiert ist. 1. (Optional) Fügen Sie Ihrem Cluster weitere HSMs hinzu. Weitere Informationen finden Sie unter [Hinzufügen eines HSM zu einem Cluster AWS CloudHSM](add-hsm.md). 1. Stellen Sie eine Verbindung zu Ihrem Windows-Server her. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Verwenden Sie die CloudHSM-CLI, um einen Crypto-Benutzer (CU) zu erstellen. Merken Sie sich den CU-Benutzernamen und das Passwort. Sie benötigen diese im nächsten Schritt. **Anmerkung** Informationen zum Erstellen eines Benutzers finden Sie unter [HSM-Benutzer mit der CloudHSM-CLI verwalten](manage-hsm-users-chsm-cli.md). 1. [Legen Sie die Anmeldeinformationen für das HSM fest](ksp-library-authentication.md). Verwenden Sie hierfür den im vorherigen Schritt erstellten CU-Benutzernamen und das entsprechende Passwort. 1. Wenn Sie in Schritt 5 den Windows Credentials Manager zum Einrichten [https://live.sysinternals.com/psexec.exe](https://live.sysinternals.com/psexec.exe)von HSM-Anmeldeinformationen verwendet haben, laden Sie den folgenden Befehl als *NT Authority\$1* SYSTEM herunter, SysInternals um ihn auszuführen: ``` psexec.exe -s "C:\Program Files\Amazon\CloudHsm\tools\set_cloudhsm_credentials.exe" --username --password ``` Ersetzen Sie ** und ** durch die HSM-Anmeldeinformationen. **So installieren Sie IIS auf Ihrem Windows-Server** 1. Stellen Sie eine Verbindung mit Ihrem Windows-Server her, sofern noch nicht geschehen. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Starten Sie auf Ihrem Windows-Server **Server Manager**. 1. Wählen Sie im Dashboard **Server-Manager** die Option **Rollen und Features hinzufügen**. 1. Lesen Sie die Informationen unter **Before you begin (Zur Vorbereitung)** und klicken Sie dann auf **Weiter**. 1. Wählen Sie unter **Installationsart** die **Rollenbasierte oder funktionsbasierte Installation**. Wählen Sie anschließend **Weiter**. 1. Wählen Sie unter **Serverauswahl** die Option **Einen Server aus dem Serverpool auswählen**. Klicken Sie anschließend auf **Weiter**. 1. Gehen Sie für **Serverrollen** wie folgt vor: 1. Wählen Sie **Web Server (IIS) (Webserver (IIS))** aus. 1. Klicken Sie für **Add features that are required für Web Server (IIS) (Für Webserver (IIS) erforderliche Funktionen hinzufügen)** auf **Add Features (Funktionen hinzufügen)**. 1. Klicken Sie auf **Weiter**, um das Auswählen von Serverrollen abzuschließen. 1. Für **Features (Funktionen)**, übernehmen Sie die Standardeinstellungen. Klicken Sie anschließend auf **Weiter**. 1. Lesen Sie die Informationen unter **Web Server Role (IIS) (Webserverrolle (IIS))**. Klicken Sie anschließend auf **Weiter**. 1. Übernehmen Sie für **Select role services (Rollenservices auswählen)** die Standardwerte oder ändern Sie die Einstellungen. Klicken Sie anschließend auf **Weiter**. 1. Lesen Sie unter **Confirmation (Bestätigung)** die Informationen zur Bestätigung. Wählen Sie anschließend **Installieren**. 1. Nach abgeschlossener Installation klicken Sie auf **Close (Schließen)**. Nachdem Sie diese Schritte abgeschlossen haben, fahren Sie mit [Schritt 2: Erstellen einer Zertifikatsignierungsanforderung (CSR) und eines Zertifikats](#ssl-offload-windows-create-csr-and-certificate) fort. ### Voraussetzungen für das Client-SDK 3 Um das SSL/TLS Webserver-Offload mit einzurichten AWS CloudHSM, benötigen Sie Folgendes: + Ein aktiver AWS CloudHSM Cluster mit mindestens einem HSM. + Eine Amazon EC2-Instance, auf der ein Windows-Betriebssystem ausgeführt wird und die folgende Software installiert ist: + Die AWS CloudHSM Client-Software für Windows. + Internet Information Services (IIS) für Windows Server + Ein [Crypto-Benutzer](understanding-users.md#crypto-user-chsm-cli) (CU), der den privaten Schlüssel des Webservers auf dem HSM besitzen und verwalten soll. **Anmerkung** In diesem Tutorial wird Microsoft Windows Server 2016 verwendet. Microsoft Windows Server 2012 wird ebenfalls unterstützt, Microsoft Windows Server 2012 R2 jedoch nicht. **So richten Sie eine Windows-Webserver-Instance auf dem HSM ein und erstellen einen CU** 1. Führen Sie die Schritte unter [Erste Schritte](getting-started.md) aus. Beim Starten des Amazon EC2-Clients wählen Sie ein Windows Server 2016- oder Windows Server 2012-AMI aus. Wenn Sie diese Schritte ausgeführt haben, verfügen Sie über einen aktiven Cluster mit mindestens einem HSM. Sie haben auch eine Amazon EC2 EC2-Client-Instance, auf der Windows Server ausgeführt wird und auf der die AWS CloudHSM Client-Software für Windows installiert ist. 1. (Optional) Fügen Sie Ihrem Cluster weitere HSMs hinzu. Weitere Informationen finden Sie unter [Hinzufügen eines HSM zu einem Cluster AWS CloudHSM](add-hsm.md). 1. Stellen Sie eine Verbindung zu Ihrem Windows-Server her. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Verwenden Sie die CloudHSM-CLI, um einen Crypto-Benutzer (CU) zu erstellen. Merken Sie sich den CU-Benutzernamen und das Passwort. Sie benötigen diese im nächsten Schritt. **Anmerkung** Informationen zum Erstellen eines Benutzers finden Sie unter [HSM-Benutzer mit der CloudHSM-CLI verwalten](manage-hsm-users-chsm-cli.md). 1. [Legen Sie die Anmeldeinformationen für das HSM fest](ksp-library-prereq.md). Verwenden Sie hierfür den im vorherigen Schritt erstellten CU-Benutzernamen und das entsprechende Passwort. 1. Wenn Sie in Schritt 5 den Windows Credentials Manager zum Einrichten [https://live.sysinternals.com/psexec.exe](https://live.sysinternals.com/psexec.exe)von HSM-Anmeldeinformationen verwendet haben, laden Sie den folgenden Befehl als *NT Authority\$1* SYSTEM herunter, SysInternals um ihn auszuführen: ``` psexec.exe -s "C:\Program Files\Amazon\CloudHsm\tools\set_cloudhsm_credentials.exe" --username --password ``` Ersetzen Sie ** und ** durch die HSM-Anmeldeinformationen. **So installieren Sie IIS auf Ihrem Windows-Server** 1. Stellen Sie eine Verbindung mit Ihrem Windows-Server her, sofern noch nicht geschehen. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Starten Sie auf Ihrem Windows-Server **Server Manager**. 1. Wählen Sie im Dashboard **Server-Manager** die Option **Rollen und Features hinzufügen**. 1. Lesen Sie die Informationen unter **Before you begin (Zur Vorbereitung)** und klicken Sie dann auf **Weiter**. 1. Wählen Sie unter **Installationsart** die **Rollenbasierte oder funktionsbasierte Installation**. Wählen Sie anschließend **Weiter**. 1. Wählen Sie unter **Serverauswahl** die Option **Einen Server aus dem Serverpool auswählen**. Klicken Sie anschließend auf **Weiter**. 1. Gehen Sie für **Serverrollen** wie folgt vor: 1. Wählen Sie **Web Server (IIS) (Webserver (IIS))** aus. 1. Klicken Sie für **Add features that are required für Web Server (IIS) (Für Webserver (IIS) erforderliche Funktionen hinzufügen)** auf **Add Features (Funktionen hinzufügen)**. 1. Klicken Sie auf **Weiter**, um das Auswählen von Serverrollen abzuschließen. 1. Für **Features (Funktionen)**, übernehmen Sie die Standardeinstellungen. Klicken Sie anschließend auf **Weiter**. 1. Lesen Sie die Informationen unter **Web Server Role (IIS) (Webserverrolle (IIS))**. Klicken Sie anschließend auf **Weiter**. 1. Übernehmen Sie für **Select role services (Rollenservices auswählen)** die Standardwerte oder ändern Sie die Einstellungen. Klicken Sie anschließend auf **Weiter**. 1. Lesen Sie unter **Confirmation (Bestätigung)** die Informationen zur Bestätigung. Wählen Sie anschließend **Installieren**. 1. Nach abgeschlossener Installation klicken Sie auf **Close (Schließen)**. Nachdem Sie diese Schritte abgeschlossen haben, fahren Sie mit [Schritt 2: Erstellen einer Zertifikatsignierungsanforderung (CSR) und eines Zertifikats](#ssl-offload-windows-create-csr-and-certificate) fort. ## Schritt 2: Erstellen einer Zertifikatsignierungsanforderung (CSR) und eines Zertifikats Um HTTPS zu aktivieren, benötigt Ihr Webserver ein SSL/TLS Zertifikat und einen entsprechenden privaten Schlüssel. Um SSL/TLS Offload mit zu verwenden AWS CloudHSM, speichern Sie den privaten Schlüssel im HSM in Ihrem AWS CloudHSM Cluster. Verwenden Sie dazu den [AWS CloudHSM -Schlüsselspeicher-Anbieter (Key Storage Provider, KSP) für die Microsoft Cryptography API: Next Generation (CNG)](ksp-v3-library.md), um eine Zertifikatsignierungsanforderung (CSR) zu erstellen. Senden Sie die CSR dann an eine Zertifizierungsstelle (Certificate Authority, CA), um die CSR signieren zu lassen und ein Zertifikat zu erhalten. **Topics** + [Erstellen Sie eine CSR mit Client SDK 5](#ssl-offload-windows-create-csr-new-version) + [Erstellen Sie eine CSR mit dem Client SDK 3](#ssl-offload-windows-create-csr-old-version) + [Erhalten und Importieren eines signierten Zertifikats](#ssl-offload-windows-create-certificate) ### Erstellen Sie eine CSR mit Client SDK 5 1. Verwenden Sie auf Ihrem Windows-Server einen Texteditor, um eine Zertifikatanforderungsdatei namens `IISCertRequest.inf` zu erstellen. Den Inhalt einer Beispieldatei `IISCertRequest.inf` sehen Sie nachfolgend. Weitere Informationen zu den Abschnitten, Schlüsseln und Werten in dieser Datei finden Sie in der [Microsoft-Dokumentation](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1#BKMK_New). Ändern Sie den Wert `ProviderName` nicht. ``` [Version] Signature = "$Windows NT$" [NewRequest] Subject = "CN=example.com,C=US,ST=Washington,L=Seattle,O=ExampleOrg,OU=WebServer" HashAlgorithm = SHA256 KeyAlgorithm = RSA KeyLength = 2048 ProviderName = "CloudHSM Key Storage Provider" KeyUsage = 0xf0 MachineKeySet = True [EnhancedKeyUsageExtension] OID=1.3.6.1.5.5.7.3.1 ``` 1. Verwenden Sie den [**certreq**Windows-Befehl](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1), um eine CSR aus der `IISCertRequest.inf` Datei zu erstellen, die Sie im vorherigen Schritt erstellt haben. Im folgenden Beispiel wird die CSR in einer Datei namens `IISCertRequest.csr` gespeichert. Wenn Sie für Ihre Zertifikatsanforderungsdatei einen anderen Dateinamen verwendet haben, *IISCertRequest.inf* ersetzen Sie ihn durch den entsprechenden Dateinamen. Sie können Ihre CSR-Datei optional durch einen anderen Dateinamen ersetzen*IISCertRequest.csr*. ``` C:\>certreq -new IISCertRequest.inf IISCertRequest.csr CertReq: Request Created ``` Die Datei `IISCertRequest.csr` enthält Ihre CSR. Sie benötigen diese CSR, um ein signiertes Zertifikat zu erhalten. ### Erstellen Sie eine CSR mit dem Client SDK 3 1. Stellen Sie eine Verbindung mit Ihrem Windows-Server her, sofern noch nicht geschehen. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Verwenden Sie den folgenden Befehl, um den AWS CloudHSM Client-Daemon zu starten. ------ #### [ Amazon Linux ] ``` $ sudo start cloudhsm-client ``` ------ #### [ Amazon Linux 2 ] ``` $ sudo service cloudhsm-client start ``` ------ #### [ CentOS 7 ] ``` $ sudo service cloudhsm-client start ``` ------ #### [ CentOS 8 ] ``` $ sudo service cloudhsm-client start ``` ------ #### [ RHEL 7 ] ``` $ sudo service cloudhsm-client start ``` ------ #### [ RHEL 8 ] ``` $ sudo service cloudhsm-client start ``` ------ #### [ Ubuntu 16.04 LTS ] ``` $ sudo service cloudhsm-client start ``` ------ #### [ Ubuntu 18.04 LTS ] ``` $ sudo service cloudhsm-client start ``` ------ #### [ Windows ] + Für Windows-Client 1.1.2 und höher: ``` C:\Program Files\Amazon\CloudHSM>net.exe start AWSCloudHSMClient ``` + Für Windows-Clients 1.1.1 und früher: ``` C:\Program Files\Amazon\CloudHSM>start "cloudhsm_client" cloudhsm_client.exe C:\ProgramData\Amazon\CloudHSM\data\cloudhsm_client.cfg ``` ------ 1. Verwenden Sie auf Ihrem Windows-Server einen Texteditor, um eine Zertifikatanforderungsdatei namens `IISCertRequest.inf` zu erstellen. Den Inhalt einer Beispieldatei `IISCertRequest.inf` sehen Sie nachfolgend. Weitere Informationen zu den Abschnitten, Schlüsseln und Werten in dieser Datei finden Sie in der [Microsoft-Dokumentation](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1#BKMK_New). Ändern Sie den Wert `ProviderName` nicht. ``` [Version] Signature = "$Windows NT$" [NewRequest] Subject = "CN=example.com,C=US,ST=Washington,L=Seattle,O=ExampleOrg,OU=WebServer" HashAlgorithm = SHA256 KeyAlgorithm = RSA KeyLength = 2048 ProviderName = "Cavium Key Storage Provider" KeyUsage = 0xf0 MachineKeySet = True [EnhancedKeyUsageExtension] OID=1.3.6.1.5.5.7.3.1 ``` 1. Verwenden Sie den [**certreq**Windows-Befehl](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1), um eine CSR aus der `IISCertRequest.inf` Datei zu erstellen, die Sie im vorherigen Schritt erstellt haben. Im folgenden Beispiel wird die CSR in einer Datei namens `IISCertRequest.csr` gespeichert. Wenn Sie für Ihre Zertifikatsanforderungsdatei einen anderen Dateinamen verwendet haben, *IISCertRequest.inf* ersetzen Sie ihn durch den entsprechenden Dateinamen. Sie können Ihre CSR-Datei optional durch einen anderen Dateinamen ersetzen*IISCertRequest.csr*. ``` C:\>certreq -new IISCertRequest.inf IISCertRequest.csr SDK Version: 2.03 CertReq: Request Created ``` Die Datei `IISCertRequest.csr` enthält Ihre CSR. Sie benötigen diese CSR, um ein signiertes Zertifikat zu erhalten. ### Erhalten und Importieren eines signierten Zertifikats In einer Produktionsumgebung verwenden Sie in der Regel eine Zertifikatsstelle (CA) zum Erstellen eines Zertifikats aus einer CSR. Für eine Testumgebung ist keine CA erforderlich. Wenn Sie eine Zertifizierungsstelle verwenden, senden Sie die CSR-Datei (`IISCertRequest.csr`) an diese und verwenden Sie die Zertifizierungsstelle, um ein signiertes SSL/TLS Zertifikat zu erstellen. Als Alternative zur Verwendung einer Zertifizierungsstelle können Sie ein Tool wie [OpenSSL](https://www.openssl.org/) verwenden, um ein selbstsigniertes Zertifikat zu erstellen. **Warnung** Selbstsignierte Zertifikate sind nicht vertrauenswürdig für Browser und sollten in Produktionsumgebungen nicht verwendet werden. Sie können in Testumgebungen verwendet werden. Nachfolgend wird beschrieben, wie Sie ein selbstsigniertes Zertifikat erstellen und dieses für die Signierung der CSR Ihres Webservers verwenden. **So erstellen Sie ein selbstsigniertes Zertifikat** 1. Verwenden Sie den folgenden OpenSSL-Befehl, um einen privaten Schlüssel zu erstellen. Sie können es optional durch den Dateinamen *SelfSignedCA.key* ersetzen, der Ihren privaten Schlüssel enthält. ``` openssl genrsa -aes256 -out SelfSignedCA.key 2048 Generating RSA private key, 2048 bit long modulus ......................................................................+++ .........................................+++ e is 65537 (0x10001) Enter pass phrase for SelfSignedCA.key: Verifying - Enter pass phrase for SelfSignedCA.key: ``` 1. Verwenden Sie den folgenden OpenSSL-Befehl, um ein selbstsigniertes Zertifikat mit dem privaten Schlüssel zu erstellen, den Sie im vorherigen Schritt erstellt haben. Hierbei handelt es sich um einen interaktiven Befehl. Lesen Sie die Anweisungen auf dem Bildschirm und befolgen Sie die Eingabeaufforderungen. *SelfSignedCA.key*Ersetzen Sie ihn durch den Namen der Datei, die Ihren privaten Schlüssel enthält (falls anders). Sie können es optional durch den Dateinamen *SelfSignedCA.crt* ersetzen, um Ihr selbstsigniertes Zertifikat zu enthalten. ``` openssl req -new -x509 -days 365 -key SelfSignedCA.key -out SelfSignedCA.crt Enter pass phrase for SelfSignedCA.key: You are about to be asked to enter information that will be incorporated into your certificate request. What you are about to enter is what is called a Distinguished Name or a DN. There are quite a few fields but you can leave some blank For some fields there will be a default value, If you enter '.', the field will be left blank. ----- Country Name (2 letter code) [AU]: State or Province Name (full name) [Some-State]: Locality Name (eg, city) []: Organization Name (eg, company) [Internet Widgits Pty Ltd]: Organizational Unit Name (eg, section) []: Common Name (e.g. server FQDN or YOUR name) []: Email Address []: ``` **So verwenden Sie ein selbstsigniertes Zertifikat, um die CSR Ihres Webservers zu signieren** + Verwenden Sie den folgenden OpenSSL-Befehl, um mit Ihrem privaten Schlüssel und Ihrem selbstsignierten Zertifikat die CSR zu signieren. Ersetzen Sie die folgenden Namen durch die Namen der Dateien, die die jeweiligen Daten enthalten, sofern diese abweichen. + *IISCertRequest.csr*— Der Name der Datei, die den CSR Ihres Webservers enthält + *SelfSignedCA.crt*— Der Name der Datei, die Ihr selbstsigniertes Zertifikat enthält + *SelfSignedCA.key*— Der Name der Datei, die Ihren privaten Schlüssel enthält + *IISCert.crt*— Der Name der Datei, die das signierte Zertifikat Ihres Webservers enthalten soll ``` openssl x509 -req -days 365 -in IISCertRequest.csr \ -CA SelfSignedCA.crt \ -CAkey SelfSignedCA.key \ -CAcreateserial \ -out IISCert.crt Signature ok subject=/ST=IIS-HSM/L=IIS-HSM/OU=IIS-HSM/O=IIS-HSM/CN=IIS-HSM/C=IIS-HSM Getting CA Private Key Enter pass phrase for SelfSignedCA.key: ``` Nachdem Sie den vorherigen Schritt abgeschlossen haben, haben Sie ein signiertes Zertifikat für Ihren Webserver (`IISCert.crt`) sowie ein selbstsigniertes Zertifikat (`SelfSignedCA.crt`). Wenn Sie diese Dateien haben, gehen Sie zu [Schritt 3: Konfigurieren des Webservers](#ssl-offload-configure-web-server-windows). ## Schritt 3: Konfigurieren des Webservers Aktualisieren Sie die Konfiguration Ihrer IIS-Website, um das HTTPS-Zertifikat zu verwenden, das Sie am Ende des [vorherigen Schritts](#ssl-offload-windows-create-csr-and-certificate) erstellt haben. Damit ist die Einrichtung Ihrer Windows-Webserver-Software (IIS) für das SSL/TLS Auslagern mit abgeschlossen. AWS CloudHSM Wenn Sie ein selbstsigniertes Zertifikat zum Signieren Ihrer CSR verwendet haben, müssen Sie zunächst das selbstsignierte Zertifikat in Windows unter „Vertrauenswürdige Stammzertifizierungsstellen“ importieren. **So importieren Sie Ihr selbstsigniertes Zertifikat in Windows unter „Vertrauenswürdige Stammzertifizierungsstellen“** 1. Stellen Sie eine Verbindung mit Ihrem Windows-Server her, sofern noch nicht geschehen. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Kopieren Sie Ihr selbstsigniertes Zertifikat auf Ihren Windows-Server. 1. Öffnen Sie auf Ihrem Windows-Server die **Systemsteuerung**. 1. Geben Sie für **Search Control Panel (Systemsteuerung durchsuchen)** **certificates** ein. Klicken Sie dann auf **Computerzertifikate verwalten**. 1. Doppelklicken Sie im Fenster **Zertifikate — Lokaler Computer** auf **Vertrauenswürdige Stammzertifizierungsstellen**. 1. Klicken Sie mit der rechten Maustaste auf **Zertifikate**, **Alle Aufgaben** und **Importieren**. 1. Klicken Sie im **Zertifikatimport-Assistent** auf **Weiter**. 1. Klicken Sie auf **Durchsuchen** und wählen Sie Ihr selbstsigniertes Zertifikat aus. Wenn Sie Ihr selbstsigniertes Zertifikat nach der Anleitung im [vorherigen Schritt dieser Anleitung](#ssl-offload-windows-create-csr-and-certificate) erstellt haben, hat Ihr selbstsigniertes Zertifikat den Namen `SelfSignedCA.crt`. Klicken Sie auf **Open**. 1. Wählen Sie **Weiter**. 1. Klicken Sie für **Zertifikatspeicher** auf **Alle Zertifikate in folgendem Speicher speichern**. Stellen Sie dann sicher, dass für **Zertifikatspeicher** **Vertrauenswürdige Stammzertifizierungsstellen** ausgewählt ist. 1. Wählen Sie **Weiter** und anschließend **Beenden** aus. **So aktualisieren Sie die Konfiguration Ihrer IIS-Website** 1. Stellen Sie eine Verbindung mit Ihrem Windows-Server her, sofern noch nicht geschehen. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Starten Sie den AWS CloudHSM Client-Daemon. 1. Kopieren Sie das signierte Zertifikat Ihres Webservers – dasjenige, das Sie am Ende [des vorherigen Schritts dieses Tutorials erstellt haben](#ssl-offload-windows-create-csr-and-certificate) – auf Ihren Windows-Server. 1. Verwenden Sie auf Ihrem Windows Server den [**certreq**Windows-Befehl](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1), um das signierte Zertifikat zu akzeptieren, wie im folgenden Beispiel. *IISCert.crt*Ersetzen Sie es durch den Namen der Datei, die das signierte Zertifikat Ihres Webservers enthält. ``` C:\>certreq -accept IISCert.crt SDK Version: 2.03 ``` 1. Starten Sie auf Ihrem Windows-Server **Server Manager**. 1. Klicken Sie rechts oben im Dashboard **Server-Manager** auf **Extras**, **Internet Information Services (IIS)-Manager**. 1. Doppelklicken Sie im Fenster **Internet Information Services (IIS)-Manager** auf den Servernamen. Doppelklicken Sie dann auf **Websites**. Wählen Sie Ihre Website aus. 1. Klicken Sie auf **SSL-Einstellungen**. Klicken Sie dann rechts im Fenster auf **Bindungen**. 1. Klicken Sie im Fenster **Websitebindungen** auf **Hinzufügen**. 1. Wählen Sie für **Typ** die Option **HTTPS** aus. Wählen Sie für **SSL-Zertifikat** das HTTPS-Zertifikat aus, das Sie am Ende [des vorherigen Schritts dieser Anleitung](#ssl-offload-windows-create-csr-and-certificate) erstellt haben. **Anmerkung** Wenn während dieser Zertifikat-Bindung ein Fehler auftritt, starten Sie Ihren Server neu und wiederholen Sie diesen Schritt. 1. Wählen Sie **OK** aus. Nachdem Sie die Konfiguration Ihrer Website aktualisiert haben, gehen Sie zu [Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats](#ssl-offload-enable-traffic-and-verify-certificate-windows). ## Schritt 4: Aktivieren von HTTPS-Datenverkehr und Verifizieren des Zertifikats Nachdem Sie Ihren Webserver für SSL/TLS Offload mit konfiguriert haben AWS CloudHSM, fügen Sie Ihre Webserver-Instanz einer Sicherheitsgruppe hinzu, die eingehenden HTTPS-Verkehr zulässt. Dadurch können Clients, wie z. B. Webbrowser, eine HTTPS-Verbindung mit Ihrem Webserver herstellen. Stellen Sie dann eine HTTPS-Verbindung zu Ihrem Webserver her und stellen Sie sicher, dass er das Zertifikat verwendet, mit dem Sie das SSL/TLS Offload konfiguriert haben. AWS CloudHSM **Topics** + [Aktivieren von eingehenden HTTPS-Verbindungen](#ssl-offload-add-security-group-windows) + [Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet](#ssl-offload-verify-https-connection-windows) ### Aktivieren von eingehenden HTTPS-Verbindungen Zum Herstellen einer Verbindung zu Ihrem Webserver von einem Client (z. B. ein Webbrowser) aus, erstellen Sie eine Sicherheitsgruppe, die eingehende HTTPS-Verbindungen zulässt. Insbesondere sollten eingehende TCP-Verbindungen auf Port 443 erlaubt werden. Weisen Sie diese Sicherheitsgruppe Ihrem Webserver zu. **So erstellen Sie eine Sicherheitsgruppe für HTTPS und weisen sie Ihrem Webserver zu** 1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. Wählen Sie im Navigationsbereich **Sicherheitsgruppen** aus. 1. Wählen Sie **Sicherheitsgruppe erstellen**. 1. Führen Sie für **Sicherheitsgruppe erstellen** die folgenden Schritte aus: 1. Geben Sie in das Feld **Sicherheitsgruppenname** einen Namen für die Sicherheitsgruppe ein, die Sie erstellen. 1. (Optional) Geben Sie eine Beschreibung der Sicherheitsgruppe ein, die Sie erstellen. 1. Wählen Sie für **VPC** die VPC aus, die Ihre Amazon-EC2-Instance enthält. 1. Wählen Sie **Regel hinzufügen** aus. 1. Wählen Sie im Drop-down-Fenster für **Typ** die Option **HTTPS** aus. 1. Geben Sie für **Quelle** einen Quellspeicherort ein. 1. Wählen Sie **Sicherheitsgruppe erstellen** aus. 1. Wählen Sie im Navigationsbereich **Instances** aus. 1. Aktivieren Sie das Kontrollkästchen neben Ihrer Webserver-Instance. 1. Wählen Sie das Drop-down-Menü **Aktionen** oben auf der Seite. Wählen Sie **Sicherheit** und dann **Sicherheitsgruppen ändern** aus. 1. Wählen Sie unter **Zugeordnete Sicherheitsgruppen** das Suchfeld aus und wählen Sie die Sicherheitsgruppe, die Sie für HTTPS erstellt haben, aus. Wählen Sie dann **Sicherheitsgruppen hinzufügen** aus. 1. Wählen Sie **Speichern**. ### Verifizieren, dass HTTPS das konfigurierte Zertifikat verwendet Nachdem Sie den Webserver zu einer Sicherheitsgruppe hinzugefügt haben, können Sie überprüfen, ob der SSL/TLS Offload Ihr selbstsigniertes Zertifikat verwendet. Sie können dazu einen Webbrowser oder ein Tool wie [OpenSSL s\$1client](https://www.openssl.org/docs/manmaster/man1/s_client.html) nutzen. **Um den SSL/TLS Offload mit einem Webbrowser zu überprüfen** 1. Verwenden Sie einen Web-Browser, um eine Verbindung zum Webserver unter Verwendung des öffentlichen DNS-Namen oder der IP-Adresse des Servers herzustellen. Stellen Sie sicher, dass die URL in die Adresszeile mit https:// beginnt. Beispiel, **https://ec2-52-14-212-67.us-east-2.compute.amazonaws.com/**. **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Zeigen Sie das Webserverzertifikat mit Ihrem Webbrowser an. Weitere Informationen finden Sie hier: + Wenn Sie Mozilla Firefox nutzen, sehen Sie sich die Informationen auf der Mozilla Support-Website unter [Zertifikat anzeigen](https://support.mozilla.org/en-US/kb/secure-website-certificate#w_view-a-certificate) an. + Wenn Sie Google Chrome verwenden, sehen Sie sich die Informationen auf der „Google Tools für Web Developers“-Website unter [Sicherheitsprobleme verstehen](https://developers.google.com/web/tools/chrome-devtools/security) an. Andere Webbrowser unterstützen möglicherweise ähnliche Funktionen, über die Sie das Webserverzertifikat anzeigen können. 1. Stellen Sie sicher, dass es sich bei dem SSL/TLS Zertifikat um das Zertifikat handelt, für dessen Verwendung Sie Ihren Webserver konfiguriert haben. **Um den SSL/TLS Offload mit OpenSSL s\$1client zu überprüfen** 1. Führen Sie den folgenden OpenSSL-Befehl aus, um mittels HTTPS eine Verbindung zu Ihrem Webserver herzustellen. **Ersetzen Sie es durch den öffentlichen DNS-Namen oder die IP-Adresse Ihres Webservers. ``` openssl s_client -connect :443 ``` **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Stellen Sie sicher, dass es sich bei dem SSL/TLS Zertifikat um das Zertifikat handelt, für dessen Verwendung Sie Ihren Webserver konfiguriert haben. Sie verfügen jetzt über eine mit HTTPS gesicherte Website. Der private Schlüssel für den Webserver wird in einem HSM in Ihrem AWS CloudHSM Cluster gespeichert. Informationen zum Hinzufügen eines Load Balancers finden Sie unter [Einen Load Balancer mit Elastic Load Balancing hinzufügen für AWS CloudHSM(optional)](third-offload-add-lb.md). # Einen Load Balancer mit Elastic Load Balancing hinzufügen für AWS CloudHSM(optional) Nachdem Sie SSL/TLS Offload mit einem Webserver eingerichtet haben, können Sie weitere Webserver und einen Elastic Load Balancing Load Balancer erstellen, der HTTPS-Verkehr an die Webserver weiterleitet. Ein Load Balancer kann die Auslastung Ihrer einzelnen Webserver reduzieren, indem der Verkehr auf zwei oder mehr Webserver verteilt wird. Er kann zudem die Verfügbarkeit Ihrer Website erhöhen, da er den Zustand Ihrer Webserver überwacht und den Datenverkehr nur an stabile Server weiterleitet. Wenn ein Webserver ausfällt, beendet der Load Balancer automatisch die Weiterleitung des Datenverkehrs an diesen. **Topics** + [Schritt 1. Erstellen eines Subnetzes für einen zweiten Webserver](#ssl-offload-load-balancer-create-new-subnet) + [Schritt 2. Erstellen des zweiten Webservers](#ssl-offload-load-balancer-create-web-server) + [Schritt 3. Erstellen Sie den Load Balancer](#ssl-offload-load-balancer-create-load-balancer) ## Schritt 1. Erstellen eines Subnetzes für einen zweiten Webserver Bevor Sie einen weiteren Webserver erstellen können, müssen Sie ein neues Subnetz in derselben VPC erstellen, die Ihren vorhandenen Webserver und AWS CloudHSM Cluster enthält. **So erstellen Sie ein neues Subnetz** 1. Öffnen Sie den [Abschnitt **Subnetze** der Amazon VPC-Konsole](https://console.aws.amazon.com/vpc/home#subnets:). 1. Wählen Sie **Create Subnet** aus. 1. Führen Sie im Dialogfeld **Create Subnet** Folgendes aus: 1. Geben Sie unter **Name tag**(Namens-Tag) einen Namen für Ihr Subnetz ein. 1. Wählen Sie für **VPC** die AWS CloudHSM VPC aus, die Ihren vorhandenen Webserver und AWS CloudHSM Cluster enthält. 1. Wählen Sie als **Availability Zone** eine Availability Zone aus, die sich von der unterscheidet, die Ihren vorhandenen Webserver enthält. 1. Geben Sie unter **IPv4 CIDR block** den CIDR-Block für das Subnetz ein. Geben Sie beispielsweise **10.0.10.0/24** ein. 1. Wählen Sie **Ja, erstellen** aus. 1. Aktivieren Sie das Kontrollkästchen neben dem öffentlichen Subnetz, das Ihren vorhandenen Webserver enthält. Dieses unterscheidet sich von dem öffentlichen Subnetz, das Sie im vorherigen Schritt erstellt haben. 1. Klicken Sie im Inhaltsbereich auf die Registerkarte **Routing-Tabelle**. Wählen Sie dann den Link für die Routing-Tabelle aus. ![\[Wählen Sie den Link für die Routing-Tabelle in der Amazon-VPC-Konsole aus.\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/images/console-vpc-choose-route-table.png) 1. Aktivieren Sie das Kontrollkästchen neben der Routing-Tabelle. 1. Wählen Sie die Registerkarte **Subnetz-Verknüpfungen** aus. Wählen Sie dann **Bearbeiten** aus. 1. Wählen Sie das Kontrollkästchen neben dem öffentlichen Subnetz aus, das Sie zuvor erstellt haben. Wählen Sie dann **Speichern**. ## Schritt 2. Erstellen des zweiten Webservers Führen Sie die folgenden Schritte aus, um einen zweiten Webserver mit der gleichen Konfiguration wie der des vorhandenen Webservers zu erstellen. **So erstellen Sie einen zweiten Webserver** 1. Öffnen Sie den Bereich [https://console.aws.amazon.com/ec2/v2/home#Instances:](https://console.aws.amazon.com/ec2/v2/home#Instances:) in der Amazon-EC2-Konsole unter. 1. Aktivieren Sie das Kontrollkästchen neben Ihrer vorhandenen Webserver-Instance. 1. Wählen Sie **Aktionen**, **Image** und dann **Image erstellen**. 1. Führen Sie im Dialogfeld **Create Image** (Abbild erstellen) die folgenden Schritte aus: 1. Geben Sie für **Image name** (Image-Name) einen eindeutigen Namen für das Image ein. 1. Geben Sie unter **Image description** (Image-Beschreibung) eine Beschreibung für das Image ein. 1. Wählen Sie **Image erstellen** aus. Mit dieser Aktion wird Ihr vorhandener Webserver neu gestartet. 1. Wählen Sie den **Link „Ausstehendes Bild anzeigen“. **** ![\[Wählen Sie den Link zum Anzeigen des ausstehenden Abbilds in der Amazon EC2-Konsole aus.\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/images/console-ec2-choose-view-pending-image.png) Beachten Sie den Abbildstatus in der **Status**-Spalte. Lautet der Abbildstatus **available** (verfügbar), dies kann einige Minuten dauern, fahren Sie mit dem nächsten Schritt fort. 1. Wählen Sie im Navigationsbereich **Instances** aus. 1. Aktivieren Sie das Kontrollkästchen neben Ihrem vorhandenen Webserver. 1. Wählen Sie **Aktionen** und dann **Weitere solche starten** aus. 1. Wählen Sie **AMI bearbeiten** aus. ![\[Wählen Sie den Link zur AMI-Bearbeitung in der Amazon-EC2-Konsole aus.\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/images/console-ec2-choose-edit-ami.png) 1. Wählen Sie im linken Navigationsbereich **Meine** aus AMIs. Löschen Sie anschließend den Text im Suchfeld. 1. Wählen Sie neben Ihrem Webserverabbild **Auswählen** aus. 1. Wählen Sie **Ja, ich möchte mit diesem AMI fortfahren (**- ami-**)**. 1. Wählen Sie **Weiter** aus. 1. Wählen Sie einen Instance-Typen und danach **Weiter: Instance-Details konfigurieren** aus. 1. Führen Sie für **Step 3: Configure Instance Details (Schritt 3: Instance-Details konfigurieren)** Folgendes aus: 1. Wählen Sie für **Netzwerk** die VPC mit Ihrem vorhandenen Webserver aus. 1. Wählen Sie für **Subnetz** das öffentliche Subnetz aus, das Sie für den zweiten Webserver erstellt haben. 1. Wählen Sie für **Öffentliche IP automatisch zuweisen** **Aktivieren** aus. 1. Ändern Sie die verbleibenden Instance-Details wie gewünscht. Wählen Sie dann **Weiter: Speicher hinzufügen** aus. 1. Ändern Sie die Speichereinstellungen wie gewünscht. Wählen Sie dann **Weiter: Tags hinzufügen** aus. 1. Bearbeiten Sie Tags nach Bedarf oder fügen Sie diese hinzu. Wählen Sie dann **Als Nächstes: Sicherheitsgruppe konfigurieren** aus. 1. Führen Sie für **Schritt 6: Sicherheitsgruppe konfigurieren** die folgenden Schritte aus: 1. Wählen Sie für **Sicherheitsgruppe zuweisen** die Option **Existierende Sicherheitsgruppe auswählen** aus. 1. Aktivieren Sie das Kontrollkästchen neben der Sicherheitsgruppe mit dem Namen **cloudhsm- ** -sg**. AWS CloudHSM hat diese Sicherheitsgruppe in Ihrem Namen erstellt, als Sie den Cluster [erstellt](create-cluster.md) haben. Sie müssen diese Sicherheitsgruppe auswählen, damit die Webserver-Instanz eine Verbindung mit der HSMs im Cluster herstellen kann. 1. Aktivieren Sie das Kontrollkästchen neben der Sicherheitsgruppe, die eingehenden HTTPS-Datenverkehr zulässt. Sie [haben diese Sicherheitsgruppe zuvor erstellt](ssl-offload-windows.md#ssl-offload-add-security-group-windows). 1. (Optional) Aktivieren Sie das Kontrollkästchen neben einer Sicherheitsgruppe, die eingehenden SSH- (für Linux) oder RDP-Datenverkehr (für Windows) aus Ihrem Netzwerk zulässt. Das heißt, die Sicherheitsgruppe muss ein- und ausgehenden TCP-Datenverkehr auf Port 22 (für SSH unter Linux) bzw. Port 3389 (für RDP unter Windows) zulassen. Andernfalls können Sie keine Verbindung zu Ihrer Client-Instance herstellen. Wenn Sie keine solche Sicherheitsgruppe haben, müssen Sie sie erstellen und Ihrer Client-Instance zu einem späteren Zeitpunkt hinzufügen. Klicken Sie auf **Review and Launch**. 1. Überprüfen Sie die Instance-Details. Wählen Sie anschließend **Start** aus. 1. Legen Sie fest, ob Ihre Instance mit einem vorhandenen Schlüsselpaar oder ohne Schlüsselpaar gestartet werden soll, oder ob ein neues Schlüsselpaar erstellt werden soll. + Um ein vorhandenes Schlüsselpaar zu verwenden, führen Sie die folgenden Schritte aus: 1. Wählen Sie **Vorhandenes Schlüsselpaar auswählen** aus. 1. Wählen Sie für **Schlüsselpaar auswählen** das zu verwendende Schlüsselpaar aus. 1. Aktivieren Sie das Kontrollkästchen neben **Ich bestätige, dass ich Zugriff auf die ausgewählte private Schlüsseldatei (**.pem) habe und dass ich mich ohne diese Datei nicht bei meiner Instance anmelden kann**. + Wenn Sie ein neues Schlüsselpaar erstellen möchten, führen Sie die folgenden Schritte aus: 1. Wählen Sie **Ein neues Schlüsselpaar erstellen** aus. 1. Geben Sie für **Key pair name** (Schlüsselpaarname) einen Schlüsselpaarnamen ein. 1. Wählen Sie **Schlüsselpaar herunterladen** aus und speichern Sie die Datei mit dem privaten Schlüssel an einem sicheren, zugänglichen Ort. **Warnung** Nach diesem Zeitpunkt können Sie die Datei mit dem privaten Schlüssel nicht erneut herunterladen. Wenn Sie die Datei mit dem privaten Schlüssel jetzt nicht herunterzuladen, können Sie sich auf die Client-Instance zugreifen. + Zum Starten Ihrer Instance ohne Schlüsselpaar führen Sie die folgenden Schritte aus: 1. Wählen Sie **Ohne Schlüsselpaar fortfahren** aus. 1. Aktivieren Sie das Kontrollkästchen neben **Ich bestätige, dass ich mich nicht bei dieser Instance anmelden kann, wenn ich das in dieses AMI integrierte Passwort nicht kenne.** Wählen Sie **Instances starten** aus. ## Schritt 3. Erstellen Sie den Load Balancer Führen Sie die folgenden Schritte aus, um einen Elastic Load Balancing Load Balancer zu erstellen, der den HTTPS-Datenverkehr an Ihre Webserver weiterleitet. **So erstellen Sie einen Load Balancer** 1. Öffnen Sie den Bereich [ https://console.aws.amazon.com/ec2/v2/home#LoadBalancers:]( https://console.aws.amazon.com/ec2/v2/home#LoadBalancers:) in der Amazon EC2-Konsole. 1. Klicken Sie auf **Load Balancer erstellen**. 1. Klicken Sie im Bereich **Network Load Balancer** auf **Create**. 1. Führen Sie für **Step 1: Configure Load Balancer** (Schritt 1; Konfigurieren von Load Balancer) die folgenden Schritte aus: 1. Geben Sie als **Name** einen Namen für den Load Balancer ein, den Sie erstellen. 1. Ändern Sie im Bereich **Listeners** den Wert in **443** für **Load Balancer Port**. 1. Wählen Sie im Bereich **Availability Zones** als **VPC** die VPC aus, die Ihre Webserver enthält. 1. Wählen Sie im Bereich **Availability Zones** die Subnetze aus, die Ihre Webserver enthalten. 1. Wählen Sie **Weiter: Routing konfigurieren** aus. 1. Führen Sie für **Step 2: Configure Routing** (Schritt 2: Routing konfigurieren) die folgenden Schritte aus: 1. Geben Sie als **Name** einen Namen für die Zielgruppe ein, die Sie erstellen. 1. Ändern Sie für den **Port** den Wert in **443**. 1. Klicken Sie auf **Weiter: Ziele registrieren**. 1. Führen Sie für **Step 3: Register Targets** (Schritt 3: Ziele registrieren) die folgenden Schritte aus: 1. Aktivieren Sie im Bereich **Instances** die Kontrollkästchen neben Ihren Webserver-Instances. Wählen Sie dann **Zu registrierten hinzufügen** aus. 1. Wählen Sie **Weiter: Prüfen** aus. 1. Überprüfen Sie die Load Balancer-Details und wählen Sie dann **Erstellen** aus. 1. Wenn der Load Balancer erfolgreich erstellt wurde, klicken Sie auf **Close** (Schließen). Nachdem Sie die vorangegangenen Schritte durchgeführt haben, zeigt die Amazon EC2-Konsole Ihren Elastic Load-Balancing Load Balancer an. Wenn der Status Ihres Load Balancers „aktiv“ ist, können Sie verifizieren, dass der Load Balancer funktioniert. Das heißt, Sie können mit SSL/TLS Offload with überprüfen, ob HTTPS-Verkehr an Ihre Webserver gesendet wird. AWS CloudHSM Sie können dazu einen Webbrowser oder ein Tool wie [OpenSSL s\$1client](https://www.openssl.org/docs/manmaster/man1/s_client.html) verwenden. **So stellen Sie sicher, dass der Load Balancer mit einem Webbrowser arbeitet** 1. Suchen Sie in der Amazon EC2-Konsole den **DNS-Namen** für den Load Balancer, den Sie gerade erstellt haben. Wählen Sie anschließend den DNS-Namen aus und kopieren Sie ihn. 1. Verwenden Sie einen Webbrowser wie Mozilla Firefox oder Google Chrome für die Verbindung Ihres Load Balancers über dessen DNS-Namen. Stellen Sie sicher, dass die URL in die Adresszeile mit https:// beginnt. **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Zeigen Sie das Webserverzertifikat mit Ihrem Webbrowser an. Weitere Informationen finden Sie hier: + Wenn Sie Mozilla Firefox nutzen, sehen Sie sich die Informationen auf der Mozilla Support-Website unter [Zertifikat anzeigen](https://support.mozilla.org/en-US/kb/secure-website-certificate#w_view-a-certificate) an. + Wenn Sie Google Chrome verwenden, sehen Sie sich die Informationen auf der „Google Tools für Web Developers“-Website unter [Sicherheitsprobleme verstehen](https://developers.google.com/web/tools/chrome-devtools/security) an. Andere Webbrowser unterstützen möglicherweise ähnliche Funktionen, über die Sie das Webserverzertifikat anzeigen können. 1. Stellen Sie sicher, dass das Zertifikat dasjenige ist, das Sie für die Nutzung im Webserver konfiguriert haben. **So stellen Sie sicher, dass der Load Balancer mit OpenSSL s\$1client arbeitet** 1. Verbinden Sie mit dem folgenden OpenSSL-Befehl Ihrer Load Balancer mittels HTTPS. **Ersetzen Sie ihn durch den DNS-Namen Ihres Load Balancers. ``` openssl s_client -connect :443 ``` **Tipp** Sie können einen DNS-Dienst wie Amazon Route 53 verwenden, um den Domainnamen Ihrer Website (z. B. https://www.example.com/) an Ihren Webserver weiterzuleiten. Weitere Informationen finden Sie unter [Routing des Datenverkehrs zu einer Amazon-EC2-Instance](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) im *Entwicklerleitfaden zu Amazon Route 53* oder in der Dokumentation für Ihren DNS-Service. 1. Stellen Sie sicher, dass das Zertifikat dasjenige ist, das Sie für die Nutzung im Webserver konfiguriert haben. Sie haben jetzt eine Website, die mit HTTPS gesichert ist, wobei der private Schlüssel des Webservers in einem HSM in Ihrem AWS CloudHSM Cluster gespeichert ist. Ihre Website verfügt über zwei Webserver und einen Load Balancer, um Effizienz und Verfügbarkeit zu verbessern. # Konfigurieren Sie Windows Server als Zertifizierungsstelle (CA) mit AWS CloudHSM AWS CloudHSM bietet Unterstützung für die Konfiguration von Windows Server als Zertifizierungsstelle (CA) über Client SDK 3 und Client SDK 5. Die Schritte zur Verwendung dieser Tools hängen von der Version des Client-SDK ab, die Sie derzeit heruntergeladen haben. Die folgenden Abschnitte enthalten Informationen zu den einzelnen SDKs. **Topics** + [Client-SDK 5 mit Windows Server-CA](win-ca-overview-sdk5.md) + [Client-SDK 3 mit Windows Server-CA](win-ca-overview-sdk3.md) # Konfigurieren Sie Windows Server als Zertifizierungsstelle (CA) mit Client SDK 5 In einer Public Key-Infrastruktur (PKI) ist eine Zertifizierungsstelle (CA) eine vertrauenswürdige Entität, die digitale Zertifikate ausstellt. Diese digitalen Zertifikate binden einen öffentlichen Schlüssel unter Verwendung von Kryptografie öffentlicher Schlüssel und von digitalen Signaturen an eine Identität (eine Person oder Organisation). Um eine CA zu betreiben, müssen Sie das Vertrauen aufrechterhalten, indem Sie den privaten Schlüssel schützen, der die von Ihrer CA ausgestellten Zertifikate signiert. Sie können den privaten Schlüssel im HSM in Ihrem AWS CloudHSM -Cluster speichern und das HSM zur Durchführung der kryptografischen Signiervorgänge verwenden. In diesem Tutorial verwenden Sie Windows Server und AWS CloudHSM konfigurieren eine Zertifizierungsstelle. Nach der Installation der AWS CloudHSM -Client-Software für Windows auf Ihrem Windows Server fügen Sie Ihrem Windows Server die Active Directory-Zertifikatsdienste (AD CS)-Rolle hinzu. Wenn Sie diese Rolle konfigurieren, verwenden Sie einen AWS CloudHSM Key Storage Provider (KSP), um den privaten Schlüssel der CA zu erstellen und auf Ihrem AWS CloudHSM Cluster zu speichern. Der KSP ist die Brücke, die Ihren Windows-Server mit Ihrem Cluster verbindet. AWS CloudHSM Im letzten Schritt signieren Sie mit Ihrer Windows Server-CA eine Zertifikatssignierungsanforderung (Certificate Signing Request, CSR). Weitere Informationen finden Sie unter den folgenden Themen: **Topics** + [Schritt 1: Einrichten der Voraussetzungen](#win-ca-prerequisites-sdk5) + [Schritt 2: Erstellen Sie eine Windows Server-Zertifizierungsstelle mit AWS CloudHSM](#win-ca-setup-sdk5) + [Schritt 3: Signieren Sie eine Zertifikatssignieranforderung (CSR) mit Ihrer Windows Server-Zertifizierungsstelle mit AWS CloudHSM](#win-ca-sign-csr-sdk5) ## Schritt 1: Einrichten der Voraussetzungen Um Windows Server als Zertifizierungsstelle (CA) mit einzurichten AWS CloudHSM, benötigen Sie Folgendes: + Ein aktiver AWS CloudHSM Cluster mit mindestens einem HSM. + Eine Amazon EC2 EC2-Instance, auf der ein Windows Server-Betriebssystem mit installierter AWS CloudHSM Client-Software für Windows ausgeführt wird. In diesem Tutorial wird Microsoft Windows Server 2016 verwendet. + Einen Crypto-Benutzer (CU), der den privaten Schlüssel der CA auf dem HSM besitzen und verwalten soll. **Um die Voraussetzungen für eine Windows Server-CA einzurichten mit AWS CloudHSM** 1. Führen Sie die Schritte unter [Erste Schritte](getting-started.md) aus. Beim Starten der Amazon EC2-Clients wählen Sie ein Windows Server-AMI aus. In diesem Tutorial wird Microsoft Windows Server 2016 verwendet. Wenn Sie diese Schritte ausgeführt haben, verfügen Sie über einen aktiven Cluster mit mindestens einem HSM. Sie haben auch eine Amazon EC2 EC2-Client-Instance, auf der Windows Server ausgeführt wird und auf der die AWS CloudHSM Client-Software für Windows installiert ist. 1. (Optional) Fügen Sie Ihrem Cluster weitere HSMs hinzu. Weitere Informationen finden Sie unter [Hinzufügen eines HSM zu einem Cluster AWS CloudHSM](add-hsm.md). 1. Stellen Sie eine Verbindung mit Ihrer Client-Instance her. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Erstellen Sie einen Crypto-Benutzer (CU) mithilfe [von Managing HSM users with CloudHSM CLI oder Managing HSM](manage-hsm-users-chsm-cli.md) [users with CloudHSM](manage-hsm-users-cmu.md) Management Utility (CMU). Merken Sie sich den CU-Benutzernamen und das Passwort. Sie benötigen diese im nächsten Schritt. 1. [Legen Sie die Anmeldeinformationen für das HSM fest](ksp-library-authentication.md). Verwenden Sie hierfür den im vorherigen Schritt erstellten CU-Benutzernamen und das entsprechende Passwort. 1. *Wenn Sie in Schritt 5 den Windows Credentials Manager zum Einrichten von HSM-Anmeldeinformationen verwendet haben, laden Sie den folgenden Befehl als NT Authority\$1 [https://live.sysinternals.com/psexec.exe](https://live.sysinternals.com/psexec.exe)SYSTEM herunter, SysInternals um ihn auszuführen:* ``` psexec.exe -s "C:\Program Files\Amazon\CloudHsm\tools\set_cloudhsm_credentials.exe" --username --password ``` Ersetzen Sie ** und ** durch die HSM-Anmeldeinformationen. Um eine Windows Server-Zertifizierungsstelle mit zu erstellen AWS CloudHSM, gehen Sie zu[Erstellen einer Windows Server-CA](#win-ca-setup-sdk5). ## Schritt 2: Erstellen Sie eine Windows Server-Zertifizierungsstelle mit AWS CloudHSM Um eine Windows Server-CA zu erstellen, fügen Sie Ihrem Windows Server die Active Directory-Zertifikatsdienste (Active Directory Certificate Services, AD CS)-Rolle hinzu. Wenn Sie diese Rolle hinzufügen, verwenden Sie einen AWS CloudHSM Schlüsselspeicheranbieter (KSP), um den privaten Schlüssel der Zertifizierungsstelle zu erstellen und auf Ihrem AWS CloudHSM Cluster zu speichern. **Anmerkung** Wenn Sie Ihre Windows Server-CA erstellen, können Sie sich für das Erstellen einer Stamm-Zertifizierungsstelle oder einer untergeordneten Zertifizierungsstelle entscheiden. Sie treffen diese Entscheidung in der Regel basierend auf dem Entwurf Ihrer Public Key-Infrastruktur und der Sicherheitsrichtlinien Ihrer Organisation. In diesem Tutorial wird der Einfachheit halber erklärt, wie eine Stamm-CA erstellt wird. **So fügen Sie Ihrem Windows Server die AD-CS-Rolle hinzu und erstellen den privaten Schlüssel der CA** 1. Stellen Sie eine Verbindung mit Ihrem Windows-Server her, sofern noch nicht geschehen. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Starten Sie auf Ihrem Windows-Server **Server Manager**. 1. Wählen Sie im Dashboard **Server-Manager** die Option **Rollen und Features hinzufügen**. 1. Lesen Sie die Informationen unter **Before you begin (Zur Vorbereitung)** und klicken Sie dann auf **Weiter**. 1. Wählen Sie unter **Installationsart** die **Rollenbasierte oder funktionsbasierte Installation**. Wählen Sie anschließend **Weiter**. 1. Wählen Sie unter **Serverauswahl** die Option **Einen Server aus dem Serverpool auswählen**. Klicken Sie anschließend auf **Weiter**. 1. Gehen Sie für **Serverrollen** wie folgt vor: 1. Wählen Sie **Active Directory-Zertifikatdienste**. 1. Wählen Sie für **Sollen für Active Directory-Zertifikatsdienste erforderliche Features hinzugefügt werden?** die Option **Features hinzufügen**. 1. Klicken Sie auf **Weiter**, um das Auswählen von Serverrollen abzuschließen. 1. Übernehmen Sie für **Features** die Standardwerte und klicken Sie dann auf **Weiter**. 1. Verfahren Sie für **AD CS** wie folgt: 1. Wählen Sie **Weiter** aus. 1. Wählen Sie **Zertifizierungsstelle** und klicken Sie dann auf **Weiter**. 1. Lesen Sie unter **Bestätigung** die Informationen zur Bestätigung und klicken Sie dann auf **Installieren**. Schließen Sie das Fenster nicht. 1. Wählen Sie den hervorgehobenen Link **Active Directory-Zertifikatdienste auf dem Zielserver konfigurieren**. 1. Prüfen oder ändern Sie die Anmeldeinformationen unter **Anmeldeinformationen**. Klicken Sie anschließend auf **Weiter**. 1. Wählen Sie für **Rollendienste** die Option **Zertifizierungsstelle**. Klicken Sie anschließend auf **Weiter**. 1. Wählen Sie für **Installationsart** die Option **Eigenständige Zertifizierungsstelle**. Klicken Sie anschließend auf **Weiter**. 1. Wählen Sie für **Zertifizierungsstellentyp** die Option **Stammzertifizierungsstelle**. Klicken Sie anschließend auf **Weiter**. **Anmerkung** Sie können basierend auf dem Entwurf Ihrer Public Key-Infrastruktur und der Sicherheitsrichtlinien Ihrer Organisation entscheiden, ob eine Stammzertifizierungsstelle oder eine untergeordnete Zertifizierungsstelle erstellt werden soll. In diesem Tutorial wird der Einfachheit halber erklärt, wie eine Stamm-CA erstellt wird. 1. Wählen Sie für **Privater Schlüssel** die Option **Neuen privaten Schlüssel erstellen**. Klicken Sie anschließend auf **Weiter**. 1. Führen Sie für **Kryptografie** einen der folgenden Schritte aus: 1. **Wählen Sie für Select a cryptographic provider** eine der **CloudHSM Key Storage Provider-Optionen** aus dem Menü aus. Dies sind die AWS CloudHSM -Schlüsselspeicher-Provider. Sie können beispielsweise **RSA \$1CloudHSM Key Storage Provider** wählen. 1. Wählen Sie für **Schlüssellänge** eine der verfügbaren Schlüssellängen aus. 1. Wählen Sie für **Select the hash algorithm für signing certificates issued by this CA (Wählen Sie den Hashalgorithmus zum Signieren von Zertifikaten aus, die von dieser Zertifizierungsstelle ausgestellt wurden)** einen der verfügbaren Hashalgorithmen aus. Wählen Sie **Weiter**. 1. Führen Sie für **Zertifizierungsstelle** einen der folgenden Schritte aus: 1. (Optional) Bearbeiten Sie den allgemeinen Namen. 1. (Optional) Geben Sie ein spezifisches Namenssuffix ein. Wählen Sie **Weiter**. 1. Geben Sie für **Gültigkeitsdauer** einen Zeitraum in Jahren, Monaten, Wochen oder Tagen ein. Klicken Sie anschließend auf **Weiter**. 1. Für **Zertifikatdatenbank**können Sie die Standardwerte übernehmen. Sie können optional den Speicherort für die Datenbank und das Datenbankprotokoll ändern. Klicken Sie anschließend auf **Weiter**. 1. Überprüfen Sie die Informationen zur Zertifizierungsstelle unter **Bestätigung**. Klicken Sie dann auf **Konfigurieren**. 1. Klicken Sie auf **Schließen** und dann erneut auf **Schließen**. Sie haben jetzt eine Windows Server-Zertifizierungsstelle mit AWS CloudHSM. Weitere Informationen zum Signieren einer Zertifikatssignierungsanforderung (Certificate Signing Request, CSR) mit Ihrer CA finden Sie unter [Signieren einer CSR](#win-ca-sign-csr-sdk5). ## Schritt 3: Signieren Sie eine Zertifikatssignieranforderung (CSR) mit Ihrer Windows Server-Zertifizierungsstelle mit AWS CloudHSM Sie können Ihre Windows Server-Zertifizierungsstelle verwenden, AWS CloudHSM um eine Zertifikatssignieranforderung (CSR) zu signieren. Um diese Schritte ausführen zu können, benötigen Sie eine gültige CSR. Es gibt mehrere Möglichkeiten, eine CSR zu erstellen, einschließlich der Folgenden: + Verwenden von OpenSSL + Verwenden des Windows Server Internet Information Services (IIS) Manager + Verwenden des Zertifikate-Snap-In in der Microsoft Management Console + Verwenden des Befehlszeilendienstprogramms **certreq** unter Windows Die Schritte zum Erstellen einer CSR werden in dieser Anleitung allerdings nicht behandelt. Wenn Sie über eine CSR verfügen, können Sie sie mit Ihrer Windows Server-Zertifizierungsstelle signieren. **So signieren Sie eine CSR mit Ihrer Windows Server-CA** 1. Stellen Sie eine Verbindung mit Ihrem Windows-Server her, sofern noch nicht geschehen. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Starten Sie auf Ihrem Windows-Server **Server Manager**. 1. Klicken Sie rechts oben im Dashboard **Server-Manager** auf **Extras**, **Zertifizierungsstelle**. 1. Wählen Sie im Fenster **Zertifizierungsstelle** den Namen Ihres Computers aus. 1. Wählen Sie im Menü **Aktion** die Option **Alle Aufgaben**, **Neue Anforderung einreichen**. 1. Wählen Sie Ihre CSR-Datei aus und klicken Sie auf **Öffnen**. 1. Doppelklicken Sie im Fenster **Zertifizierungsstelle** auf **Ausstehende Anforderungen**. 1. Wählen Sie die ausstehende Anforderung aus. Wählen Sie dann im Menü **Aktion** die Option **Alle Aufgaben**, **Ausstellen**. 1. Doppelklicken Sie im Fenster **Zertifizierungsstelle** auf **Ausgestellte Anforderungen**, um das signierte Zertifikat anzuzeigen. 1. (Optional) Um das signierte Zertifikat in eine Datei zu exportieren, führen Sie die folgenden Schritte aus: 1. Doppelklicken Sie im Fenster **Zertifizierungsstelle** auf das Zertifikat. 1. Wählen Sie die Registerkarte **Details** und anschließend **In Datei kopieren**. 1. Befolgen Sie die Anweisungen im **Zertifikatexport-Assistent**. Sie haben jetzt eine Windows Server-Zertifizierungsstelle mit und ein gültiges Zertifikat AWS CloudHSM, das von der Windows Server-Zertifizierungsstelle signiert wurde. # Konfigurieren Sie Windows Server als Zertifizierungsstelle (CA) mit Client SDK 3 In einer Public Key-Infrastruktur (PKI) ist eine Zertifizierungsstelle (CA) eine vertrauenswürdige Entität, die digitale Zertifikate ausstellt. Diese digitalen Zertifikate binden einen öffentlichen Schlüssel unter Verwendung von Kryptografie öffentlicher Schlüssel und von digitalen Signaturen an eine Identität (eine Person oder Organisation). Um eine CA zu betreiben, müssen Sie das Vertrauen aufrechterhalten, indem Sie den privaten Schlüssel schützen, der die von Ihrer CA ausgestellten Zertifikate signiert. Sie können den privaten Schlüssel im HSM in Ihrem AWS CloudHSM -Cluster speichern und das HSM zur Durchführung der kryptografischen Signiervorgänge verwenden. In diesem Tutorial verwenden Sie Windows Server und AWS CloudHSM konfigurieren eine Zertifizierungsstelle. Nach der Installation der AWS CloudHSM -Client-Software für Windows auf Ihrem Windows Server fügen Sie Ihrem Windows Server die Active Directory-Zertifikatsdienste (AD CS)-Rolle hinzu. Wenn Sie diese Rolle konfigurieren, verwenden Sie einen AWS CloudHSM Key Storage Provider (KSP), um den privaten Schlüssel der CA zu erstellen und auf Ihrem AWS CloudHSM Cluster zu speichern. Der KSP ist die Brücke, die Ihren Windows-Server mit Ihrem Cluster verbindet. AWS CloudHSM Im letzten Schritt signieren Sie mit Ihrer Windows Server-CA eine Zertifikatssignierungsanforderung (Certificate Signing Request, CSR). Weitere Informationen finden Sie unter den folgenden Themen: **Topics** + [Schritt 1: Einrichten der Voraussetzungen](#win-ca-prerequisites-sdk3) + [Schritt 2: Erstellen Sie eine Windows Server-Zertifizierungsstelle mit AWS CloudHSM](#win-ca-setup-sdk3) + [Schritt 3: Signieren Sie eine Zertifikatssignieranforderung (CSR) mit Ihrer Windows Server-Zertifizierungsstelle mit AWS CloudHSM](#win-ca-sign-csr-sdk3) ## Schritt 1: Einrichten der Voraussetzungen Um Windows Server als Zertifizierungsstelle (CA) mit einzurichten AWS CloudHSM, benötigen Sie Folgendes: + Ein aktiver AWS CloudHSM Cluster mit mindestens einem HSM. + Eine Amazon EC2 EC2-Instance, auf der ein Windows Server-Betriebssystem mit installierter AWS CloudHSM Client-Software für Windows ausgeführt wird. In diesem Tutorial wird Microsoft Windows Server 2016 verwendet. + Einen Crypto-Benutzer (CU), der den privaten Schlüssel der CA auf dem HSM besitzen und verwalten soll. **Um die Voraussetzungen für eine Windows Server-CA einzurichten mit AWS CloudHSM** 1. Führen Sie die Schritte unter [Erste Schritte](getting-started.md) aus. Beim Starten der Amazon EC2-Clients wählen Sie ein Windows Server-AMI aus. In diesem Tutorial wird Microsoft Windows Server 2016 verwendet. Wenn Sie diese Schritte ausgeführt haben, verfügen Sie über einen aktiven Cluster mit mindestens einem HSM. Sie haben auch eine Amazon EC2 EC2-Client-Instance, auf der Windows Server ausgeführt wird und auf der die AWS CloudHSM Client-Software für Windows installiert ist. 1. (Optional) Fügen Sie Ihrem Cluster weitere HSMs hinzu. Weitere Informationen finden Sie unter [Hinzufügen eines HSM zu einem Cluster AWS CloudHSM](add-hsm.md). 1. Stellen Sie eine Verbindung mit Ihrer Client-Instance her. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Erstellen Sie einen Crypto-Benutzer (CU) mithilfe [von Managing HSM users with CloudHSM CLI oder Managing HSM](manage-hsm-users-chsm-cli.md) [users with CloudHSM](manage-hsm-users-cmu.md) Management Utility (CMU). Merken Sie sich den CU-Benutzernamen und das Passwort. Sie benötigen diese im nächsten Schritt. 1. [Legen Sie die Anmeldeinformationen für das HSM fest](ksp-library-prereq.md). Verwenden Sie hierfür den im vorherigen Schritt erstellten CU-Benutzernamen und das entsprechende Passwort. 1. *Wenn Sie in Schritt 5 den Windows Credentials Manager zum Einrichten von HSM-Anmeldeinformationen verwendet haben, laden Sie den folgenden Befehl als NT Authority\$1 [https://live.sysinternals.com/psexec.exe](https://live.sysinternals.com/psexec.exe)SYSTEM herunter, SysInternals um ihn auszuführen:* ``` psexec.exe -s "C:\Program Files\Amazon\CloudHsm\tools\set_cloudhsm_credentials.exe" --username --password ``` Ersetzen Sie ** und ** durch die HSM-Anmeldeinformationen. Um eine Windows Server-Zertifizierungsstelle mit zu erstellen AWS CloudHSM, gehen Sie zu[Erstellen einer Windows Server-CA](#win-ca-setup-sdk3). ## Schritt 2: Erstellen Sie eine Windows Server-Zertifizierungsstelle mit AWS CloudHSM Um eine Windows Server-CA zu erstellen, fügen Sie Ihrem Windows Server die Active Directory-Zertifikatsdienste (Active Directory Certificate Services, AD CS)-Rolle hinzu. Wenn Sie diese Rolle hinzufügen, verwenden Sie einen AWS CloudHSM Schlüsselspeicheranbieter (KSP), um den privaten Schlüssel der Zertifizierungsstelle zu erstellen und auf Ihrem AWS CloudHSM Cluster zu speichern. **Anmerkung** Wenn Sie Ihre Windows Server-CA erstellen, können Sie sich für das Erstellen einer Stamm-Zertifizierungsstelle oder einer untergeordneten Zertifizierungsstelle entscheiden. Sie treffen diese Entscheidung in der Regel basierend auf dem Entwurf Ihrer Public Key-Infrastruktur und der Sicherheitsrichtlinien Ihrer Organisation. In diesem Tutorial wird der Einfachheit halber erklärt, wie eine Stamm-CA erstellt wird. **So fügen Sie Ihrem Windows Server die AD-CS-Rolle hinzu und erstellen den privaten Schlüssel der CA** 1. Stellen Sie eine Verbindung mit Ihrem Windows-Server her, sofern noch nicht geschehen. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Starten Sie auf Ihrem Windows-Server **Server Manager**. 1. Wählen Sie im Dashboard **Server-Manager** die Option **Rollen und Features hinzufügen**. 1. Lesen Sie die Informationen unter **Before you begin (Zur Vorbereitung)** und klicken Sie dann auf **Weiter**. 1. Wählen Sie unter **Installationsart** die **Rollenbasierte oder funktionsbasierte Installation**. Wählen Sie anschließend **Weiter**. 1. Wählen Sie unter **Serverauswahl** die Option **Einen Server aus dem Serverpool auswählen**. Klicken Sie anschließend auf **Weiter**. 1. Gehen Sie für **Serverrollen** wie folgt vor: 1. Wählen Sie **Active Directory-Zertifikatdienste**. 1. Wählen Sie für **Sollen für Active Directory-Zertifikatsdienste erforderliche Features hinzugefügt werden?** die Option **Features hinzufügen**. 1. Klicken Sie auf **Weiter**, um das Auswählen von Serverrollen abzuschließen. 1. Übernehmen Sie für **Features** die Standardwerte und klicken Sie dann auf **Weiter**. 1. Verfahren Sie für **AD CS** wie folgt: 1. Wählen Sie **Weiter** aus. 1. Wählen Sie **Zertifizierungsstelle** und klicken Sie dann auf **Weiter**. 1. Lesen Sie unter **Bestätigung** die Informationen zur Bestätigung und klicken Sie dann auf **Installieren**. Schließen Sie das Fenster nicht. 1. Wählen Sie den hervorgehobenen Link **Active Directory-Zertifikatdienste auf dem Zielserver konfigurieren**. 1. Prüfen oder ändern Sie die Anmeldeinformationen unter **Anmeldeinformationen**. Klicken Sie anschließend auf **Weiter**. 1. Wählen Sie für **Rollendienste** die Option **Zertifizierungsstelle**. Klicken Sie anschließend auf **Weiter**. 1. Wählen Sie für **Installationsart** die Option **Eigenständige Zertifizierungsstelle**. Klicken Sie anschließend auf **Weiter**. 1. Wählen Sie für **Zertifizierungsstellentyp** die Option **Stammzertifizierungsstelle**. Klicken Sie anschließend auf **Weiter**. **Anmerkung** Sie können basierend auf dem Entwurf Ihrer Public Key-Infrastruktur und der Sicherheitsrichtlinien Ihrer Organisation entscheiden, ob eine Stammzertifizierungsstelle oder eine untergeordnete Zertifizierungsstelle erstellt werden soll. In diesem Tutorial wird der Einfachheit halber erklärt, wie eine Stamm-CA erstellt wird. 1. Wählen Sie für **Privater Schlüssel** die Option **Neuen privaten Schlüssel erstellen**. Klicken Sie anschließend auf **Weiter**. 1. Führen Sie für **Kryptografie** einen der folgenden Schritte aus: 1. Wählen Sie für **Wählen Sie einen Kryptografie-Provider aus** eine der Optionen für **Cavium-Schlüsselspeicher-Provider** im Menü aus. Dies sind die AWS CloudHSM -Schlüsselspeicher-Provider. Beispielsweise können Sie **RSA\$1Cavium Key Storage Provider (RSA\$1Cavium-Schlüsselspeicher-Provider)** wählen. 1. Wählen Sie für **Schlüssellänge** eine der verfügbaren Schlüssellängen aus. 1. Wählen Sie für **Select the hash algorithm für signing certificates issued by this CA (Wählen Sie den Hashalgorithmus zum Signieren von Zertifikaten aus, die von dieser Zertifizierungsstelle ausgestellt wurden)** einen der verfügbaren Hashalgorithmen aus. Wählen Sie **Weiter**. 1. Führen Sie für **Zertifizierungsstelle** einen der folgenden Schritte aus: 1. (Optional) Bearbeiten Sie den allgemeinen Namen. 1. (Optional) Geben Sie ein spezifisches Namenssuffix ein. Wählen Sie **Weiter**. 1. Geben Sie für **Gültigkeitsdauer** einen Zeitraum in Jahren, Monaten, Wochen oder Tagen ein. Klicken Sie anschließend auf **Weiter**. 1. Für **Zertifikatdatenbank**können Sie die Standardwerte übernehmen. Sie können optional den Speicherort für die Datenbank und das Datenbankprotokoll ändern. Klicken Sie anschließend auf **Weiter**. 1. Überprüfen Sie die Informationen zur Zertifizierungsstelle unter **Bestätigung**. Klicken Sie dann auf **Konfigurieren**. 1. Klicken Sie auf **Schließen** und dann erneut auf **Schließen**. Sie haben jetzt eine Windows Server-CA mit AWS CloudHSM. Weitere Informationen zum Signieren einer Zertifikatssignierungsanforderung (Certificate Signing Request, CSR) mit Ihrer CA finden Sie unter [Signieren einer CSR](#win-ca-sign-csr-sdk3). ## Schritt 3: Signieren Sie eine Zertifikatssignieranforderung (CSR) mit Ihrer Windows Server-Zertifizierungsstelle mit AWS CloudHSM Sie können Ihre Windows Server-Zertifizierungsstelle verwenden, AWS CloudHSM um eine Zertifikatssignieranforderung (CSR) zu signieren. Um diese Schritte ausführen zu können, benötigen Sie eine gültige CSR. Es gibt mehrere Möglichkeiten, eine CSR zu erstellen, einschließlich der Folgenden: + Verwenden von OpenSSL + Verwenden des Windows Server Internet Information Services (IIS) Manager + Verwenden des Zertifikate-Snap-In in der Microsoft Management Console + Verwenden des Befehlszeilendienstprogramms **certreq** unter Windows Die Schritte zum Erstellen einer CSR werden in dieser Anleitung allerdings nicht behandelt. Wenn Sie über eine CSR verfügen, können Sie sie mit Ihrer Windows Server-Zertifizierungsstelle signieren. **So signieren Sie eine CSR mit Ihrer Windows Server-CA** 1. Stellen Sie eine Verbindung mit Ihrem Windows-Server her, sofern noch nicht geschehen. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Starten Sie auf Ihrem Windows-Server **Server Manager**. 1. Klicken Sie rechts oben im Dashboard **Server-Manager** auf **Extras**, **Zertifizierungsstelle**. 1. Wählen Sie im Fenster **Zertifizierungsstelle** den Namen Ihres Computers aus. 1. Wählen Sie im Menü **Aktion** die Option **Alle Aufgaben**, **Neue Anforderung einreichen**. 1. Wählen Sie Ihre CSR-Datei aus und klicken Sie auf **Öffnen**. 1. Doppelklicken Sie im Fenster **Zertifizierungsstelle** auf **Ausstehende Anforderungen**. 1. Wählen Sie die ausstehende Anforderung aus. Wählen Sie dann im Menü **Aktion** die Option **Alle Aufgaben**, **Ausstellen**. 1. Doppelklicken Sie im Fenster **Zertifizierungsstelle** auf **Ausgestellte Anforderungen**, um das signierte Zertifikat anzuzeigen. 1. (Optional) Um das signierte Zertifikat in eine Datei zu exportieren, führen Sie die folgenden Schritte aus: 1. Doppelklicken Sie im Fenster **Zertifizierungsstelle** auf das Zertifikat. 1. Wählen Sie die Registerkarte **Details** und anschließend **In Datei kopieren**. 1. Befolgen Sie die Anweisungen im **Zertifikatexport-Assistent**. Sie haben jetzt eine Windows Server-Zertifizierungsstelle mit und ein gültiges Zertifikat AWS CloudHSM, das von der Windows Server-Zertifizierungsstelle signiert wurde. # Transparente Datenverschlüsselung (TDE) für Oracle-Datenbanken mit AWS CloudHSM Transparent Data Encryption (TDE) wird für die Verschlüsselung von Datenbankdateien eingesetzt. Mit TDE verschlüsselt die Datenbanksoftware die Daten, bevor sie auf der Festplatte gespeichert werden. Die Daten in den Tabellenspalten oder Tablespaces der Datenbank werden mit einem Tabellenschlüssel oder einem Tablespace-Schlüssel verschlüsselt. Einige Versionen der Datenbanksoftware von Oracle bieten TDE. In Oracle TDE werden diese Schlüssel mit einem TDE-Master-Schlüssel verschlüsselt. Sie können mehr Sicherheit erreichen, indem Sie den TDE-Master-Verschlüsselungsschlüssel HSMs in Ihrem AWS CloudHSM Cluster speichern. ![\[Speichern Sie den Oracle-TDE-Master-Verschlüsselungsschlüssel in AWS CloudHSM.\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/images/tde-master-key-in-hsm.png) In dieser Lösung verwenden Sie Oracle Database, das in einer Amazon EC2-Instance installiert ist. Oracle Database ist in die [AWS CloudHSM Softwarebibliothek für PKCS \$111](pkcs11-library.md) integriert, um den TDE-Hauptschlüssel in Ihrem Cluster zu speichern. HSMs **Wichtig** Wir empfehlen die Installation der Oracle-Datenbank auf einer Amazon-EC2-Instance. Führen Sie die folgenden Schritte aus, um die Oracle TDE-Integration mit AWS CloudHSM zu vollenden. **Topics** + [Schritt 1. Richten Sie die Voraussetzungen ein](#oracle-tde-prerequisites) + [Schritt 2: Aktualisieren Sie die Oracle-Datenbankkonfiguration](#oracle-tde-configure-database-and-generate-master-key) + [Schritt 3: Generieren Sie den Oracle TDE-Master-Verschlüsselungsschlüssel](#oracle-tde-generate-master-key) ## Schritt 1. Richten Sie die Voraussetzungen ein Um die Oracle TDE-Integration mit durchzuführen AWS CloudHSM, benötigen Sie Folgendes: + Ein aktiver AWS CloudHSM Cluster mit mindestens einem HSM. + Eine Amazon EC2-Instance, auf der das Amazon Linux-Betriebssystem mit der folgenden Software installiert ist: + Der AWS CloudHSM Client und die Befehlszeilentools. + Die AWS CloudHSM Softwarebibliothek für PKCS \$111. + Oracle-Datenbank. AWS CloudHSM unterstützt die Oracle TDE-Integration. Client-SDK 5.6 und höher unterstützen Oracle-Datenbank 19c. Das Client-SDK 3 unterstützt Oracle TDE für die Oracle-Datenbankversionen 11g und 12c. + Ein kryptografischer Benutzer (CU), der den TDE-Master-Verschlüsselungsschlüssel HSMs in Ihrem Cluster besitzt und verwaltet. Führen Sie zum Einrichten aller Voraussetzungen die folgenden Schritte aus. **Um die Voraussetzungen für die Oracle TDE-Integration mit einzurichten AWS CloudHSM** 1. Führen Sie die Schritte unter [Erste Schritte](getting-started.md) aus. Anschließend verfügen Sie über einen aktiven Cluster mit einem HSM. Außerdem verfügen Sie über eine Amazon-EC2-Instance, auf der das Amazon-Linux-Betriebssystem läuft. Die AWS CloudHSM Client- und Befehlszeilentools werden ebenfalls installiert und konfiguriert. 1. (Optional) Fügen Sie Ihrem Cluster weitere HSMs hinzu. Weitere Informationen finden Sie unter [Hinzufügen eines HSM zu einem Cluster AWS CloudHSM](add-hsm.md). 1. Stellen Sie eine Verbindung zur Ihrer Amazon EC2-Client-Instance her und führen Sie die folgenden Schritte aus: 1. [Installieren Sie die AWS CloudHSM Softwarebibliothek für PKCS \$111](pkcs11-library-install.md). 1. Installieren Sie Oracle Database. Weitere Informationen finden Sie in der [Oracle Database-Dokumentation](https://docs.oracle.com/en/database/). Client-SDK 5.6 und höher unterstützen Oracle-Datenbank 19c. Das Client-SDK 3 unterstützt Oracle TDE für die Oracle-Datenbankversionen 11g und 12c. 1. Verwenden Sie zum Erstellen eines Crypto-Benutzers (CU) in Ihrem Cluster das Befehlszeilen-Tool cloudhsm\$1mgmt\$1util. Weitere Informationen zum Erstellen eines CU finden Sie unter [So verwalten Sie HSM-Benutzer mit CMU](create-users-cmu.md) und [HSM-Benutzer](manage-hsm-users.md). ## Schritt 2: Aktualisieren Sie die Oracle-Datenbankkonfiguration Um die Oracle Database-Konfiguration zu aktualisieren, um ein HSM in Ihrem Cluster als *externes Sicherheitsmodul* zu verwenden, führen Sie die folgenden Schritte aus. Weitere Informationen zu externen Sicherheitsmodulen finden Sie unter [Introduction to Transparent Data Encryption](https://docs.oracle.com/database/122/ASOAG/introduction-to-transparent-data-encryption.htm) im *Oracle Database Advanced Security Guide*. **So aktualisieren Sie die Oracle-Konfiguration** 1. Stellen Sie eine Verbindung zu Ihrer Amazon-EC2-Client-Instance her. Dies ist die Instance, in der Sie Oracle Database installiert haben. 1. Erstellen Sie eine Sicherungskopie der Datei `sqlnet.ora`. Informationen zum Speicherort dieser Datei finden Sie in der Oracle-Dokumentation. 1. Verwenden Sie einen Texteditor, um die Daten namens `sqlnet.ora` zu bearbeiten. Fügen Sie die folgende Zeile zu. Wenn eine Zeile in der Datei mit `encryption_wallet_location` beginnt, ersetzen Sie diese durch die folgende. ``` encryption_wallet_location=(source=(method=hsm)) ``` Speichern Sie die Datei. 1. Führen Sie den folgenden Befehl aus, um das Verzeichnis zu erstellen, in dem Oracle Database erwartet, die Bibliotheksdatei für die AWS CloudHSM PKCS \$111 -Softwarebibliothek zu finden. ``` sudo mkdir -p /opt/oracle/extapi/64/hsm ``` 1. Führen Sie den folgenden Befehl aus, um die AWS CloudHSM Softwarebibliothek für die PKCS \$111 -Datei in das Verzeichnis zu kopieren, das Sie im vorherigen Schritt erstellt haben. ``` sudo cp /opt/cloudhsm/lib/libcloudhsm_pkcs11.so /opt/oracle/extapi/64/hsm/ ``` **Anmerkung** Das Verzeichnis `/opt/oracle/extapi/64/hsm` darf nur eine Bibliotheksdatei enthalten. Entfernen Sie alle anderen Dateien, die in diesem Verzeichnis vorhanden sind. 1. Führen Sie den folgenden Befehl aus, um den Eigentümer des Verzeichnisses `/opt/oracle` und alle darin enthaltenen Daten zu ändern. ``` sudo chown -R oracle:dba /opt/oracle ``` 1. Starten Sie Oracle Database. ## Schritt 3: Generieren Sie den Oracle TDE-Master-Verschlüsselungsschlüssel Um den Oracle TDE-Masterschlüssel auf dem HSMs in Ihrem Cluster zu generieren, führen Sie die Schritte im folgenden Verfahren aus. **So generieren Sie den Masterschlüssel** 1. Verwenden Sie den folgenden Befehl, um Oracle SQL\$1Plus zu öffnen. Geben Sie, wenn Sie dazu aufgefordert werden, das Systempasswort ein, das Sie beim Installieren von Oracle Database festgelegt haben. ``` sqlplus / as sysdba ``` **Anmerkung** Für Client-SDK 3 müssen Sie die `CLOUDHSM_IGNORE_CKA_MODIFIABLE_FALSE`-Umgebungsvariable jedes Mal setzen, wenn Sie einen Hauptschlüssel erzeugen. Diese Variable wird nur für die Generierung des Masterschlüssels benötigt. Weitere Informationen finden Sie unter „Problem: Oracle legt das PCS \$111-Attribut `CKA_MODIFIABLE` bei der Generierung des Masterschlüssels fest, aber das HSM unterstützt es nicht“ unter [Bekannte Probleme für die Integration von Drittanbieteranwendungen](ki-third-party.md). 1. Führen Sie die SQL-Anweisung aus, die den Master-Verschlüsselungsschlüssel erstellt, wie in den folgenden Beispielen gezeigt. Verwenden Sie die Anweisung, die Ihrer Version von Oracle Database entspricht. **Ersetzen Sie ihn durch den Benutzernamen des kryptografischen Benutzers (CU). Ersetzen Sie es ** durch das CU-Passwort. **Wichtig** Führen Sie einmalig den folgenden Befehl aus. Jedes Mal, wenn der Befehl ausgeführt wird, wird ein neuer Master-Verschlüsselungsschlüssel erstellt. + Führen Sie für Oracle Database, Version 11, die folgende SQL-Anweisung aus. ``` SQL> alter system set encryption key identified by ":"; ``` + Für Oracle Database Version 12 und Version 19c führen Sie die folgende SQL-Anweisung aus. ``` SQL> administer key management set key identified by ":"; ``` Wenn die Antwort `System altered` oder `keystore altered` ist, haben Sie den Masterschlüssel für Oracle TDE erfolgreich generiert und festgelegt. 1. (Optional) Führen Sie den folgenden Befehl aus, um den Status von *Oracle Wallet* zu verifizieren. ``` SQL> select * from v$encryption_wallet; ``` Ist das Wallet nicht geöffnet, öffnen Sie es mit einem der folgenden Befehle. **Ersetzen Sie es durch den Namen des kryptografischen Benutzers (CU). Ersetzen Sie es ** durch das CU-Passwort. + Führen Sie für Oracle 11 zum Öffnen des Wallet den folgenden Befehl aus. ``` SQL> alter system set encryption wallet open identified by ":"; ``` Führen Sie zum manuellen Schließen des Wallet den folgenden Befehl aus. ``` SQL> alter system set encryption wallet close identified by ":"; ``` + Bei Oracle 12 und Oracle 19c führen Sie den folgenden Befehl aus, um die Brieftasche zu öffnen. ``` SQL> administer key management set keystore open identified by ":"; ``` Führen Sie zum manuellen Schließen des Wallet den folgenden Befehl aus. ``` SQL> administer key management set keystore close identified by ":"; ``` # Verwenden Sie Microsoft SignTool mit AWS CloudHSM , um Dateien zu signieren AWS CloudHSM bietet Unterstützung für die Verwendung von Microsoft Signtool zum Signieren von Dateien über Client SDK 3 und Client SDK 5. Die Schritte zur Verwendung dieser Tools hängen von der Version des Client-SDK ab, die Sie derzeit heruntergeladen haben. Die folgenden Abschnitte enthalten Informationen zu den einzelnen SDKs. **Topics** + [Client-SDK 5 mit Microsoft SignTool](signtool-sdk5.md) + [Client-SDK 3 mit Microsoft SignTool](signtool-sdk3.md) # Verwenden Sie Microsoft SignTool mit Client SDK 5 zum Signieren von Dateien In der Kryptographie und bei PKIs (Public Key Infrastructure) werden digitale Signaturen verwendet, um zu bestätigen, dass Daten von einer vertrauenswürdigen Einheit gesendet wurden. Signaturen zeigen außerdem, dass die Daten während der Übertragung nicht manipuliert wurden. Eine Signatur ist ein verschlüsselter Hash, der mit dem privaten Schlüssel des Absenders erzeugt wird. Der Empfänger kann die Datenintegrität überprüfen, indem er seine Hashsignatur mit dem öffentlichen Schlüssel des Absenders entschlüsselt. Im Gegenzug liegt es in der Verantwortung des Absenders, ein digitales Zertifikat zu pflegen. Das digitale Zertifikat belegt den Besitz des privaten Schlüssels durch den Absender und stellt dem Empfänger den öffentlichen Schlüssel zur Verfügung, der für die Entschlüsselung benötigt wird. Solange der private Schlüssel dem Absender gehört, kann der Signatur vertraut werden. AWS CloudHSM bietet sichere, nach FIPS 140-2 Level 3 validierte Hardware, mit der Sie diese Schlüssel mit exklusivem Einzelmandantenzugriff sichern können. Viele Organisationen verwenden Microsoft SignTool, ein Befehlszeilentool, das Dateien signiert, verifiziert und mit einem Zeitstempel versehen kann, um den Codesignaturprozess zu vereinfachen. Sie können AWS CloudHSM es verwenden, um Ihre Schlüsselpaare sicher zu speichern, bis sie von Ihnen benötigt werden SignTool, und so einen leicht automatisierbaren Arbeitsablauf für das Signieren von Daten schaffen. Die folgenden Themen bieten einen Überblick über die Verwendung SignTool von. AWS CloudHSM **Topics** + [Schritt 1: Einrichten der Voraussetzungen](#signtool-sdk5-prereqs) + [Schritt 2: Erstellen Sie ein Signaturzertifikat](#signtool-sdk5-csr) + [Schritt 3: Signieren Sie eine Datei](#signtool-sdk5-sign) ## Schritt 1: Einrichten der Voraussetzungen Um Microsoft SignTool mit verwenden zu können AWS CloudHSM, benötigen Sie Folgendes: + Eine Amazon-EC2-Client-Instance, auf der ein Windows-Betriebssystem läuft. + Eine Zertifizierungsstelle (CA), die entweder selbst unterhalten oder von einem Drittanbieter eingerichtet wurde. + Ein aktiver AWS CloudHSM Cluster in derselben virtuellen Public Cloud (VPC) wie Ihre EC2-Instance. Der Cluster muss mindestens ein HSM enthalten. + Ein Krypto-Benutzer (CU), der Schlüssel im Cluster besitzt und verwaltet. AWS CloudHSM + Eine unsignierte Datei oder ausführbare Datei. + Das Microsoft Windows Software Development Kit (SDK). **Um die Voraussetzungen für die Verwendung AWS CloudHSM mit Windows einzurichten SignTool** 1. Befolgen Sie die Anweisungen im Abschnitt [Erste Schritte](getting-started.md) dieses Handbuchs, um eine Windows EC2-Instance und einen AWS CloudHSM -Cluster zu starten. 1. Wenn Sie Ihre eigene Windows Server-Zertifizierungsstelle hosten möchten, folgen Sie den Schritten 1 und 2 [unter Windows Server als Zertifizierungsstelle konfigurieren mit AWS CloudHSM](win-ca-overview-sdk5.md). Verwenden Sie andernfalls weiterhin Ihre öffentlich vertrauenswürdige Zertifizierungsstelle eines Drittanbieters. 1. Laden Sie eine der folgenden Versionen des Microsoft Windows-SDKs herunter und installieren Sie es in Ihrer Windows EC2-Instance: + [Microsoft Windows SDK 10](https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk) + [Microsoft Windows SDK 8.1](https://developer.microsoft.com/en-us/windows/downloads/windows-8-1-sdk) + [Microsoft Windows SDK 7](https://www.microsoft.com/en-us/download/details.aspx?id=8279) Die ausführbare Datei `SignTool` ist Teil der Installationsfeatures von Windows SDK Signing Tools für Desktop Apps. Sie können die anderen zu installierenden Features weglassen, wenn Sie sie nicht benötigen. Der Standardinstallationspfad ist: ``` C:\Program Files (x86)\Windows Kits\\bin\\\signtool.exe ``` Sie können jetzt das Microsoft Windows SDK, Ihren AWS CloudHSM Cluster und Ihre CA verwenden, um [ein Signaturzertifikat zu erstellen](#signtool-sdk5-csr). ## Schritt 2: Erstellen Sie ein Signaturzertifikat Nachdem Sie das Windows-SDK auf Ihre EC2-Instance heruntergeladen haben, können Sie damit eine Certificate Signing Request (CSR) generieren. Die CSR ist ein unsigniertes Zertifikat, das möglicherweise zur Signatur an Ihre CA weitergeleitet wird. In diesem Beispiel verwenden wir die ausführbare Datei `certreq`, die im Windows-SDK enthalten ist, um die CSR zu generieren. **So erstellen Sie eine CSR mit der ausführbaren Datei `certreq`:** 1. Wenn Sie dies noch nicht getan haben, verbinden Sie sich mit Ihrer Windows EC2-Instance. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Erstellen Sie eine Datei namens `request.inf`, die die folgenden Zeilen enthält. Ersetzen Sie die `Subject`-Informationen durch die Ihrer Organisation. Eine Erklärung der einzelnen Parameter finden Sie in der [Dokumentation von Microsoft](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1#BKMK_New). ``` [Version] Signature= $Windows NT$ [NewRequest] Subject = "C=,CN=,O=,OU=,L=,S=" RequestType=PKCS10 HashAlgorithm = SHA256 KeyAlgorithm = RSA KeyLength = 2048 ProviderName = "CloudHSM Key Storage Provider" KeyUsage = "CERT_DIGITAL_SIGNATURE_KEY_USAGE" MachineKeySet = True Exportable = False ``` 1. Führen Sie `certreq.exe`. In diesem Beispiel speichern wir die CSR als `request.csr`. ``` certreq.exe -new request.inf request.csr ``` Intern wird auf Ihrem AWS CloudHSM Cluster ein neues key pair generiert, und der private Schlüssel des Paares wird verwendet, um die CSR zu erstellen. 1. Übermitteln Sie die CSR an Ihre CA. Wenn Sie eine Windows Server-CA verwenden, führen Sie diese Schritte aus: 1. Geben Sie den folgenden Befehl ein, um das CA-Tool zu öffnen: ``` certsrv.msc ``` 1. Klicken Sie im neuen Fenster mit der rechten Maustaste auf den Namen des CA-Servers. Wählen Sie **Alle Aufgaben** aus, und wählen Sie dann **Neue Anfrage senden** aus. 1. Navigieren Sie zum Speicherort von `request.csr` und wählen Sie **Öffnen** aus. 1. Navigieren Sie zum Ordner **Pending Requests (Ausstehende Anforderungen**), indem Sie das Menü **Server CA** erweitern. Klicken Sie mit der rechten Maustaste auf die gerade erstellte Anforderung, und wählen Sie unter **All tasks (Alle Aufgaben)** **Issue (Ausstellen)** aus. 1. Navigieren Sie nun zum Ordner **Issued Certificates (Ausgestellte Zertifikate)** (über dem Ordner **Pending Requests (Ausstehende Anforderungen)**). 1. Wählen Sie **Öffnen** aus, um das Zertifikat anzuzeigen, und wählen Sie dann die Registerkarte **Details** aus. 1. Wählen Sie **In Datei kopieren** aus, um den Assistenten für den Zertifikatsexport zu starten. Speichern Sie die DER-kodierte X.509-Datei an einem sicheren Ort als `signedCertificate.cer`. 1. Verlassen Sie das CA-Tool und verwenden Sie den folgenden Befehl, der die Zertifikatsdatei in den persönlichen Zertifikatsspeicher unter Windows verschiebt. Sie kann dann von anderen Anwendungen verwendet werden. ``` certreq.exe -accept signedCertificate.cer ``` Sie können zum [Signieren einer Datei](#signtool-sdk5-sign) nun Ihr importiertes Zertifikat in verwenden. ## Schritt 3: Signieren Sie eine Datei Sie können jetzt Ihr importiertes Zertifikat verwenden SignTool , um Ihre Beispieldatei zu signieren. Um dies zu tun, müssen Sie den SHA-1-Hash oder *Fingerabdruck* (Thumbprint) des Zertifikats kennen. Der Fingerabdruck wird verwendet, um sicherzustellen, dass SignTool nur Zertifikate verwendet werden, die von verifiziert wurden. AWS CloudHSM In diesem Beispiel verwenden wir, PowerShell um den Hash des Zertifikats abzurufen. Sie können auch die GUI der CA oder die ausführbare Datei `certutil` des Windows-SDKs verwenden. **So erhalten Sie den Fingerabdruck eines Zertifikats und signieren damit eine Datei:** 1. Öffnen Sie PowerShell als Administrator und führen Sie den folgenden Befehl aus: ``` Get-ChildItem -path cert:\LocalMachine\My ``` Kopieren Sie den `Thumbprint`, der zurückgegeben wird. ![\[Der Hash des Zertifikats wird als Fingerabdruck zurückgegeben.\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/images/signtool-hash.png) 1. Navigieren Sie zu dem Verzeichnis PowerShell , das Folgendes enthält`SignTool.exe`. Der Standardspeicherort ist `C:\Program Files (x86)\Windows Kits\10\bin\10.0.17763.0\x64`. 1. Signieren Sie dann Ihre Datei, indem Sie den folgenden Befehl ausführen. Wenn der Befehl erfolgreich ist, wird eine Erfolgsmeldung PowerShell zurückgegeben. ``` signtool.exe sign /v /fd sha256 /sha1 /sm C:\Users\Administrator\Desktop\.ps1 ``` ![\[Die .ps1-Datei wurde erfolgreich signiert.\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/images/signtool-last-command.png) 1. (Optional) Um die Signatur der Datei zu überprüfen, verwenden Sie den folgenden Befehl: ``` signtool.exe verify /v /pa C:\Users\Administrator\Desktop\.ps1 ``` # Verwenden Sie Microsoft SignTool mit Client SDK 3 zum Signieren von Dateien In der Kryptographie und bei PKIs (Public Key Infrastructure) werden digitale Signaturen verwendet, um zu bestätigen, dass Daten von einer vertrauenswürdigen Einheit gesendet wurden. Signaturen zeigen außerdem, dass die Daten während der Übertragung nicht manipuliert wurden. Eine Signatur ist ein verschlüsselter Hash, der mit dem privaten Schlüssel des Absenders erzeugt wird. Der Empfänger kann die Datenintegrität überprüfen, indem er seine Hash-Signatur mit dem öffentlichen Schlüssel des Absenders entschlüsselt. Im Gegenzug liegt es in der Verantwortung des Absenders, ein digitales Zertifikat zu pflegen. Das digitale Zertifikat belegt den Besitz des privaten Schlüssels durch den Absender und stellt dem Empfänger den öffentlichen Schlüssel zur Verfügung, der für die Entschlüsselung benötigt wird. Solange der private Schlüssel dem Absender gehört, kann der Signatur vertraut werden. AWS CloudHSM bietet sichere, nach FIPS 140-2 Level 3 validierte Hardware, mit der Sie diese Schlüssel mit exklusivem Einzelmandantenzugriff sichern können. Viele Organisationen verwenden Microsoft SignTool, ein Befehlszeilentool, das Dateien signiert, verifiziert und mit einem Zeitstempel versehen kann, um den Codesignaturprozess zu vereinfachen. Sie können AWS CloudHSM es verwenden, um Ihre Schlüsselpaare sicher zu speichern, bis sie von Ihnen benötigt werden SignTool, und so einen leicht automatisierbaren Arbeitsablauf für das Signieren von Daten schaffen. Die folgenden Themen bieten einen Überblick über die Verwendung SignTool von. AWS CloudHSM **Topics** + [Schritt 1: Einrichten der Voraussetzungen](#signtool-sdk3-prereqs) + [Schritt 2: Erstellen Sie ein Signaturzertifikat](#signtool-sdk3-csr) + [Schritt 3: Signieren Sie eine Datei](#signtool-sdk3-sign) ## Schritt 1: Einrichten der Voraussetzungen Um Microsoft SignTool mit verwenden zu können AWS CloudHSM, benötigen Sie Folgendes: + Eine Amazon-EC2-Client-Instance, auf der ein Windows-Betriebssystem läuft. + Eine Zertifizierungsstelle (CA), die entweder selbst unterhalten oder von einem Drittanbieter eingerichtet wurde. + Ein aktiver AWS CloudHSM Cluster in derselben virtuellen Public Cloud (VPC) wie Ihre EC2-Instance. Der Cluster muss mindestens ein HSM enthalten. + Ein Krypto-Benutzer (CU), der Schlüssel im Cluster besitzt und verwaltet. AWS CloudHSM + Eine unsignierte Datei oder ausführbare Datei. + Das Microsoft Windows Software Development Kit (SDK). **Um die Voraussetzungen für die Verwendung AWS CloudHSM mit Windows einzurichten SignTool** 1. Befolgen Sie die Anweisungen im Abschnitt [Erste Schritte](getting-started.md) dieses Handbuchs, um eine Windows EC2-Instance und einen AWS CloudHSM -Cluster zu starten. 1. Wenn Sie Ihre eigene Windows Server-Zertifizierungsstelle hosten möchten, folgen Sie den Schritten 1 und 2 [unter Windows Server als Zertifizierungsstelle konfigurieren mit AWS CloudHSM](win-ca-overview-sdk3.md). Verwenden Sie andernfalls weiterhin Ihre öffentlich vertrauenswürdige Zertifizierungsstelle eines Drittanbieters. 1. Laden Sie eine der folgenden Versionen des Microsoft Windows-SDKs herunter und installieren Sie es in Ihrer Windows EC2-Instance: + [Microsoft Windows SDK 10](https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk) + [Microsoft Windows SDK 8.1](https://developer.microsoft.com/en-us/windows/downloads/windows-8-1-sdk) + [Microsoft Windows SDK 7](https://www.microsoft.com/en-us/download/details.aspx?id=8279) Die ausführbare Datei `SignTool` ist Teil der Installationsfeatures von Windows SDK Signing Tools für Desktop Apps. Sie können die anderen zu installierenden Features weglassen, wenn Sie sie nicht benötigen. Der Standardinstallationspfad ist: ``` C:\Program Files (x86)\Windows Kits\\bin\\\signtool.exe ``` Sie können jetzt das Microsoft Windows SDK, Ihren AWS CloudHSM Cluster und Ihre CA verwenden, um [ein Signaturzertifikat zu erstellen](#signtool-sdk3-csr). ## Schritt 2: Erstellen Sie ein Signaturzertifikat Nachdem Sie das Windows-SDK auf Ihre EC2-Instance heruntergeladen haben, können Sie damit eine Certificate Signing Request (CSR) generieren. Die CSR ist ein unsigniertes Zertifikat, das möglicherweise zur Signatur an Ihre CA weitergeleitet wird. In diesem Beispiel verwenden wir die ausführbare Datei `certreq`, die im Windows-SDK enthalten ist, um die CSR zu generieren. **So erstellen Sie eine CSR mit der ausführbaren Datei `certreq`:** 1. Wenn Sie dies noch nicht getan haben, verbinden Sie sich mit Ihrer Windows EC2-Instance. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) im *Amazon EC2 EC2-Benutzerhandbuch*. 1. Erstellen Sie eine Datei namens `request.inf`, die die folgenden Zeilen enthält. Ersetzen Sie die `Subject`-Informationen durch die Ihrer Organisation. Eine Erklärung der einzelnen Parameter finden Sie in der [Dokumentation von Microsoft](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1#BKMK_New). ``` [Version] Signature= $Windows NT$ [NewRequest] Subject = "C=,CN=,O=,OU=,L=,S=" RequestType=PKCS10 HashAlgorithm = SHA256 KeyAlgorithm = RSA KeyLength = 2048 ProviderName = "Cavium Key Storage Provider" KeyUsage = "CERT_DIGITAL_SIGNATURE_KEY_USAGE" MachineKeySet = True Exportable = False ``` 1. Führen Sie `certreq.exe`. In diesem Beispiel speichern wir die CSR als `request.csr`. ``` certreq.exe -new request.inf request.csr ``` Intern wird auf Ihrem AWS CloudHSM Cluster ein neues key pair generiert, und der private Schlüssel des Paares wird verwendet, um die CSR zu erstellen. 1. Übermitteln Sie die CSR an Ihre CA. Wenn Sie eine Windows Server-CA verwenden, führen Sie diese Schritte aus: 1. Geben Sie den folgenden Befehl ein, um das CA-Tool zu öffnen: ``` certsrv.msc ``` 1. Klicken Sie im neuen Fenster mit der rechten Maustaste auf den Namen des CA-Servers. Wählen Sie **Alle Aufgaben** aus, und wählen Sie dann **Neue Anfrage senden** aus. 1. Navigieren Sie zum Speicherort von `request.csr` und wählen Sie **Öffnen** aus. 1. Navigieren Sie zum Ordner **Pending Requests (Ausstehende Anforderungen**), indem Sie das Menü **Server CA** erweitern. Klicken Sie mit der rechten Maustaste auf die gerade erstellte Anforderung, und wählen Sie unter **All tasks (Alle Aufgaben)** **Issue (Ausstellen)** aus. 1. Navigieren Sie nun zum Ordner **Issued Certificates (Ausgestellte Zertifikate)** (über dem Ordner **Pending Requests (Ausstehende Anforderungen)**). 1. Wählen Sie **Öffnen** aus, um das Zertifikat anzuzeigen, und wählen Sie dann die Registerkarte **Details** aus. 1. Wählen Sie **In Datei kopieren** aus, um den Assistenten für den Zertifikatsexport zu starten. Speichern Sie die DER-kodierte X.509-Datei an einem sicheren Ort als `signedCertificate.cer`. 1. Verlassen Sie das CA-Tool und verwenden Sie den folgenden Befehl, der die Zertifikatsdatei in den persönlichen Zertifikatsspeicher unter Windows verschiebt. Sie kann dann von anderen Anwendungen verwendet werden. ``` certreq.exe -accept signedCertificate.cer ``` Sie können zum [Signieren einer Datei](#signtool-sdk3-sign) nun Ihr importiertes Zertifikat in verwenden. ## Schritt 3: Signieren Sie eine Datei Sie können jetzt Ihr importiertes Zertifikat verwenden SignTool , um Ihre Beispieldatei zu signieren. Um dies zu tun, müssen Sie den SHA-1-Hash oder *Fingerabdruck* (Thumbprint) des Zertifikats kennen. Der Fingerabdruck wird verwendet, um sicherzustellen, dass SignTool nur Zertifikate verwendet werden, die von verifiziert wurden. AWS CloudHSM In diesem Beispiel verwenden wir, PowerShell um den Hash des Zertifikats abzurufen. Sie können auch die GUI der CA oder die ausführbare Datei `certutil` des Windows-SDKs verwenden. **So erhalten Sie den Fingerabdruck eines Zertifikats und signieren damit eine Datei:** 1. Öffnen Sie PowerShell als Administrator und führen Sie den folgenden Befehl aus: ``` Get-ChildItem -path cert:\LocalMachine\My ``` Kopieren Sie den `Thumbprint`, der zurückgegeben wird. ![\[Der Hash des Zertifikats wird als Fingerabdruck zurückgegeben.\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/images/signtool-hash.png) 1. Navigieren Sie zu dem Verzeichnis PowerShell , das Folgendes enthält`SignTool.exe`. Der Standardspeicherort ist `C:\Program Files (x86)\Windows Kits\10\bin\10.0.17763.0\x64`. 1. Signieren Sie dann Ihre Datei, indem Sie den folgenden Befehl ausführen. Wenn der Befehl erfolgreich ist, wird eine Erfolgsmeldung PowerShell zurückgegeben. ``` signtool.exe sign /v /fd sha256 /sha1 /sm C:\Users\Administrator\Desktop\.ps1 ``` ![\[Die .ps1-Datei wurde erfolgreich signiert.\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/images/signtool-last-command.png) 1. (Optional) Um die Signatur der Datei zu überprüfen, verwenden Sie den folgenden Befehl: ``` signtool.exe verify /v /pa C:\Users\Administrator\Desktop\.ps1 ``` # Integration von Java Keytool und Jarsigner mit AWS CloudHSM AWS CloudHSM bietet die Integration mit den Java-Dienstprogrammen Keytool und Jarsigner über das Client SDK 3 und das Client SDK 5. Die Schritte zur Verwendung dieser Tools hängen von der Version des Client-SDK ab, die Sie derzeit heruntergeladen haben. Die folgenden Abschnitte enthalten Informationen zu den einzelnen SDKs. **Topics** + [Client SDK 5 mit Java Keytool und Jarsigner](keystore-third-party-tools_5.md) + [Client SDK 3 mit Java Keytool und Jarsigner](keystore-third-party-tools.md) # Verwenden Sie Client SDK 5 zur Integration AWS CloudHSM mit Java Keytool und Jarsigner AWS CloudHSM Der Schlüsselspeicher ist ein spezieller JCE-Schlüsselspeicher, der Zertifikate verwendet, die mit Schlüsseln auf Ihrem Hardware-Sicherheitsmodul (HSM) verknüpft sind, und zwar über Tools von Drittanbietern wie und. `keytool` `jarsigner` AWS CloudHSM speichert keine Zertifikate auf dem HSM, da es sich bei Zertifikaten um öffentliche, nicht vertrauliche Daten handelt. Der AWS CloudHSM Schlüsselspeicher speichert die Zertifikate in einer lokalen Datei und ordnet die Zertifikate den entsprechenden Schlüsseln auf Ihrem HSM zu. Wenn Sie den AWS CloudHSM Schlüsselspeicher verwenden, um neue Schlüssel zu generieren, werden keine Einträge in der lokalen Schlüsselspeicherdatei generiert — die Schlüssel werden auf dem HSM erstellt. Wenn Sie den AWS CloudHSM -Schlüsselspeicher verwenden, um nach Schlüsseln zu suchen, wird die Suche an das HSM übergeben. Wenn Sie Zertifikate im AWS CloudHSM Schlüsselspeicher speichern, überprüft der Anbieter, ob ein key pair mit dem entsprechenden Alias auf dem HSM vorhanden ist, und ordnet dann das bereitgestellte Zertifikat dem entsprechenden key pair zu. **Topics** + [Voraussetzungen](keystore-prerequisites_5.md) + [Verwenden Sie den Schlüsselspeicher mit Keytool](using_keystore_with_keytool_5.md) + [Verwenden Sie den Schlüsselspeicher mit Jarsigner](using_keystore_jarsigner_5.md) + [Bekannte Probleme](known-issues-keytool-jarsigner_5.md) # Voraussetzungen für die Integration AWS CloudHSM mit Java Keytool und Jarsigner mithilfe des Client SDK 5 Um den AWS CloudHSM Schlüsselspeicher verwenden zu können, müssen Sie zuerst das JCE SDK initialisieren und konfigurieren. AWS CloudHSM Gehen Sie dazu wie folgt vor. ## Schritt 1: Installieren der JCE Um das JCE, einschließlich der AWS CloudHSM Client-Voraussetzungen, zu installieren, folgen Sie den Schritten zur [Installation der](java-library-install_5.md) Java-Bibliothek. ## Schritt 2: Hinzufügen von HSM-Anmeldeinformationen zu Umgebungsvariablen Richten Sie Umgebungsvariablen so ein, dass sie Ihre HSM-Anmeldeinformationen enthalten. ------ #### [ Linux ] ``` $ export HSM_USER= ``` ``` $ export HSM_PASSWORD= ``` ------ #### [ Windows ] ``` PS C:\> $Env:HSM_USER= ``` ``` PS C:\> $Env:HSM_PASSWORD= ``` ------ **Anmerkung** Das AWS CloudHSM JCE bietet verschiedene Anmeldeoptionen. Um den AWS CloudHSM Schlüsselspeicher mit Anwendungen von Drittanbietern zu verwenden, müssen Sie die implizite Anmeldung mit Umgebungsvariablen verwenden. Wenn Sie die explizite Anmeldung über Anwendungscode verwenden möchten, müssen Sie mithilfe des AWS CloudHSM Schlüsselspeichers Ihre eigene Anwendung erstellen. Weitere Informationen finden Sie im Artikel zur [Verwendung des AWS CloudHSM Schlüsselspeichers](alternative-keystore_5.md). ## Schritt 3: Registrieren des JCE-Providers Gehen Sie folgendermaßen vor, um den JCE-Anbieter in der CloudProvider Java-Konfiguration zu registrieren: 1. Öffnen Sie die `java.security`-Konfigurationsdatei in Ihrer Java-Installation zur Bearbeitung. 1. Fügen Sie in der `java.security`-Konfigurationsdatei `com.amazonaws.cloudhsm.jce.provider.CloudHsmProvider` als letzten Anbieter hinzu. Wenn sich beispielsweise neun Anbieter in der `java.security`-Datei befinden, fügen Sie den folgenden Anbieter als letzten Anbieter in dem Abschnitt hinzu: `security.provider.10=com.amazonaws.cloudhsm.jce.provider.CloudHsmProvider` **Anmerkung** Wenn Sie den AWS CloudHSM Anbieter mit höherer Priorität hinzufügen, kann sich dies negativ auf die Leistung Ihres Systems auswirken, da dem AWS CloudHSM Anbieter für Vorgänge, die sicher in Software ausgelagert werden können, Priorität eingeräumt wird. Es hat sich bewährt, **immer** den Anbieter anzugeben, den Sie für einen Vorgang verwenden möchten, unabhängig davon, ob es sich um den AWS CloudHSM oder einen softwarebasierten Anbieter handelt. **Anmerkung** Die Angabe von `-providerName``-providerclass`, und `-providerpath` Befehlszeilenoptionen beim Generieren von Schlüsseln **keytool** mithilfe des AWS CloudHSM CloudHSM-Schlüsselspeichers kann zu Fehlern führen. # Verwenden Sie den AWS CloudHSM Schlüsselspeicher mit Keytool und verwenden Sie das Client SDK 5 [ Keytool](https://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html) ist ein beliebtes Befehlszeilenprogramm für allgemeine Schlüssel- und Zertifikataufgaben. Ein vollständiges Tutorial zu keytool liegt außerhalb des Umfangs der AWS CloudHSM -Dokumentation. In diesem Artikel werden die spezifischen Parameter erläutert, die Sie mit verschiedenen Keytool-Funktionen verwenden sollten, wenn Sie sie über den AWS CloudHSM Schlüsselspeicher AWS CloudHSM als Vertrauensbasis verwenden. Wenn Sie Keytool mit dem AWS CloudHSM Schlüsselspeicher verwenden, geben Sie die folgenden Argumente für jeden Keytool-Befehl an: ------ #### [ Linux ] ``` -storetype CLOUDHSM -J-classpath< '-J/opt/cloudhsm/java/*'> ``` ------ #### [ Windows ] ``` -storetype CLOUDHSM -J-classpath<'-J"C:\Program Files\Amazon\CloudHSM\java\*"'> ``` ------ Wenn Sie mithilfe des Schlüsselspeichers eine neue Schlüsselspeicherdatei erstellen möchten, finden Sie AWS CloudHSM weitere Informationen unter. [Verwenden Sie das SDK 3 für den Client AWS CloudHSM KeyStore AWS CloudHSM](alternative-keystore.md#using_cloudhsm_keystore) Um einen vorhandenen Schlüsselspeicher zu verwenden, geben Sie seinen Namen (einschließlich Pfad) mit dem Argument -keystore zu keytool an. Wenn Sie in einem Keytool-Befehl eine nicht existierende Schlüsselspeicherdatei angeben, erstellt der AWS CloudHSM Schlüsselspeicher eine neue Schlüsselspeicherdatei. # Erstellen Sie neue AWS CloudHSM Schlüssel mit Keytool Sie können Keytool verwenden, um RSA, AES und den vom JCE SDK unterstützten DESede Schlüsseltyp zu generieren. AWS CloudHSM **Wichtig** Ein mit Keytool generierter Schlüssel wird in der Software generiert und dann AWS CloudHSM als extrahierbarer, persistenter Schlüssel importiert. Wir empfehlen nachdrücklich, nicht exportierbare Schlüssel außerhalb von keytool zu generieren und dann entsprechende Zertifikate in den Schlüsselspeicher zu importieren. Wenn Sie extrahierbare RSA- oder EC-Schlüssel über Keytool und Jarsigner verwenden, exportieren die Anbieter Schlüssel aus dem AWS CloudHSM und verwenden den Schlüssel dann lokal für Signaturvorgänge. Wenn Sie mehrere Client-Instanzen mit Ihrem AWS CloudHSM Cluster verbunden haben, beachten Sie, dass der Import eines Zertifikats in den Schlüsselspeicher einer Client-Instanz die Zertifikate nicht automatisch auf anderen Client-Instances verfügbar macht. Um den Schlüssel und die zugehörigen Zertifikate auf jeder Client-Instance zu registrieren, müssen Sie eine Java-Anwendung ausführen, wie in [Generieren Sie eine AWS CloudHSM CSR mit Keytool](generate_csr_using_keytool_5.md) beschrieben. Alternativ können Sie die erforderlichen Änderungen auf einem Client vornehmen und die resultierende Schlüsselspeicherdatei auf jede andere Client-Instanz kopieren. **Beispiel 1:** Um einen symmetrischen AES-256-Schlüssel zu generieren und ihn in einer Schlüsselspeicherdatei mit dem Namen „example\$1keystore.store“ im Arbeitsverzeichnis zu speichern. Durch eine eindeutige Bezeichnung ersetzen. ** ------ #### [ Linux ] ``` $ keytool -genseckey -alias -keyalg aes \ -keysize 256 -keystore example_keystore.store \ -storetype CloudHSM -J-classpath '-J/opt/cloudhsm/java/*' \ ``` ------ #### [ Windows ] ``` PS C:\> keytool -genseckey -alias -keyalg aes ` -keysize 256 -keystore example_keystore.store ` -storetype CloudHSM -J-classpath '-J"C:\Program Files\Amazon\CloudHSM\java\*"' ``` ------ **Beispiel 2:** Um ein RSA 2048-Schlüsselpaar zu generieren und es in einer Schlüsselspeicherdatei mit dem Namen „example\$1keystore.store“ im Arbeitsverzeichnis zu speichern. Durch eine eindeutige Bezeichnung ersetzen. ** ------ #### [ Linux ] ``` $ keytool -genkeypair -alias \ -keyalg rsa -keysize 2048 \ -sigalg sha512withrsa \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' ``` ------ #### [ Windows ] ``` PS C:\> keytool -genkeypair -alias ` -keyalg rsa -keysize 2048 ` -sigalg sha512withrsa ` -keystore example_keystore.store ` -storetype CLOUDHSM ` -J-classpath '-J"C:\Program Files\Amazon\CloudHSM\java\*"' ``` ------ Sie finden eine Liste der [unterstützten Signaturalgorithmen](java-lib-supported_5.md#java-sign-verify_5) in der Java-Bibliothek. # Löschen Sie einen AWS CloudHSM Schlüssel mit Keytool Der AWS CloudHSM Schlüsselspeicher unterstützt das Löschen von Schlüsseln nicht. Sie können Schlüssel mit der Destroyable-Methode der [Destroyable-Schnittstelle](https://devdocs.io/openjdk%7E8/javax/security/auth/destroyable#destroy--) löschen. ``` ((Destroyable) key).destroy(); ``` # Generieren Sie eine AWS CloudHSM CSR mit Keytool Sie erhalten die größte Flexibilität beim Generieren einer Zertifikatsignieranforderung (Certificate Signing Request, CSR), wenn Sie die [OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5](openssl-library.md) verwenden. Der folgende Befehl verwendet keytool, um eine CSR für ein Schlüsselpaar mit dem Alias, `example-key-pair`, zu generieren. ------ #### [ Linux ] ``` $ keytool -certreq -alias \ -file my_csr.csr \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' ``` ------ #### [ Windows ] ``` PS C:\> keytool -certreq -alias ` -file my_csr.csr ` -keystore example_keystore.store ` -storetype CLOUDHSM ` -J-classpath '-J"C:\Program Files\Amazon\CloudHSM\java\*"' ``` ------ **Anmerkung** Um ein Schlüsselpaar von keytool zu verwenden, muss dieses Schlüsselpaar einen Eintrag in der angegebenen Schlüsselspeicherdatei haben. Wenn Sie ein Schlüsselpaar verwenden möchten, das außerhalb von keytool generiert wurde, müssen Sie die Schlüssel- und Zertifikatmetadaten in den Schlüsselspeicher importieren. Anweisungen zum Importieren der Keystore-Daten finden Sie unter [Verwenden Sie Keytool, um Zwischen- und Stammzertifikate in den Schlüsselspeicher zu importieren AWS CloudHSM](import_cert_using_keytool_5.md). # Verwenden Sie Keytool, um Zwischen- und Stammzertifikate in den Schlüsselspeicher zu importieren AWS CloudHSM Um ein CA-Zertifikat zu importieren AWS CloudHSM, müssen Sie die Überprüfung einer vollständigen Zertifikatskette für ein neu importiertes Zertifikat aktivieren. Im Folgenden wird ein Beispielbefehl gezeigt. ------ #### [ Linux ] ``` $ keytool -import -trustcacerts -alias rootCAcert \ -file rootCAcert.cert -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' ``` ------ #### [ Windows ] ``` PS C:\> keytool -import -trustcacerts -alias rootCAcert ` -file rootCAcert.cert -keystore example_keystore.store ` -storetype CLOUDHSM ` -J-classpath '-J"C:\Program Files\Amazon\CloudHSM\java\*"' ``` ------ Wenn Sie mehrere Client-Instances mit Ihrem AWS CloudHSM Cluster verbinden, wird durch den Import eines Zertifikats in den Schlüsselspeicher einer Client-Instanz das Zertifikat nicht automatisch auf anderen Client-Instances verfügbar. Sie müssen das Zertifikat auf jeder Client-Instanz importieren. # Verwenden Sie Keytool, um Zertifikate aus dem AWS CloudHSM Schlüsselspeicher zu löschen Der folgende Befehl zeigt ein Beispiel für das Löschen eines AWS CloudHSM Zertifikats aus einem Java-Keytool-Schlüsselspeicher. ------ #### [ Linux ] ``` $ keytool -delete -alias mydomain \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' ``` ------ #### [ Windows ] ``` PS C:\> keytool -delete -alias mydomain ` -keystore example_keystore.store ` -storetype CLOUDHSM ` -J-classpath '-J"C:\Program Files\Amazon\CloudHSM\java\*"' ``` ------ Wenn Sie mehrere Client-Instances mit Ihrem AWS CloudHSM Cluster verbinden, wird beim Löschen eines Zertifikats im Schlüsselspeicher einer Client-Instanz das Zertifikat nicht automatisch aus anderen Client-Instances entfernt. Sie müssen das Zertifikat auf jeder Client-Instanz löschen. # Importieren Sie ein funktionierendes Zertifikat mit AWS CloudHSM Keytool in den Schlüsselspeicher Sobald eine Zertifikatsignieranforderung (CSR) signiert ist, können Sie sie in den AWS CloudHSM -Schlüsselspeicher importieren und mit dem entsprechenden Schlüsselpaar verknüpfen. Der folgende Befehl bietet ein Beispiel. ------ #### [ Linux ] ``` $ keytool -importcert -noprompt -alias \ -file my_certificate.crt \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' ``` ------ #### [ Windows ] ``` PS C:\> keytool -importcert -noprompt -alias ` -file my_certificate.crt ` -keystore example_keystore.store ` -storetype CLOUDHSM ` -J-classpath '-J"C:\Program Files\Amazon\CloudHSM\java\*"' ``` ------ Der Alias sollte ein Schlüsselpaar mit einem zugeordneten Zertifikat im Schlüsselspeicher sein. Wenn der Schlüssel außerhalb von keytool oder auf einer anderen Client-Instanz generiert wird, müssen Sie zuerst die Schlüssel- und Zertifikatmetadaten in den Schlüsselspeicher importieren. Die Zertifikatkette muss überprüfbar sein. Wenn Sie das Zertifikat nicht überprüfen können, müssen Sie möglicherweise das Signaturzertifikat (Zertifizierungsstelle) in den Schlüsselspeicher importieren, damit die Kette überprüft werden kann. # Exportieren Sie ein Zertifikat AWS CloudHSM mit Keytool Im folgenden Beispiel wird ein Zertifikat im Binärformat X.509 generiert. Um ein menschenlesbares Zertifikat von zu exportieren AWS CloudHSM, fügen Sie `-rfc` es dem `-exportcert` Befehl hinzu. ------ #### [ Linux ] ``` $ keytool -exportcert -alias \ -file my_exported_certificate.crt \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' ``` ------ #### [ Windows ] ``` PS C:\> keytool -exportcert -alias ` -file my_exported_certificate.crt ` -keystore example_keystore.store ` -storetype CLOUDHSM ` -J-classpath '-J"C:\Program Files\Amazon\CloudHSM\java\*"' ``` ------ # Verwenden Sie den AWS CloudHSM Schlüsselspeicher mit Jarsigner und verwenden Sie das Client SDK 5 Jarsigner ist ein beliebtes Befehlszeilenprogramm zum Signieren von JAR-Dateien mithilfe eines Schlüssels, der sicher auf einem Hardware-Sicherheitsmodul (HSM) gespeichert ist. Ein vollständiges Tutorial zu Jarsigner ist in dieser Dokumentation nicht enthalten. AWS CloudHSM In diesem Abschnitt werden die Jarsigner-Parameter erläutert, die Sie verwenden sollten, um Signaturen AWS CloudHSM als Vertrauensbasis über den Schlüsselspeicher zu signieren und zu verifizieren. AWS CloudHSM # Richten Sie AWS CloudHSM Schlüssel und Zertifikate mit Jarsigner ein Bevor Sie AWS CloudHSM JAR-Dateien mit Jarsigner signieren können, stellen Sie sicher, dass Sie die folgenden Schritte eingerichtet oder abgeschlossen haben: 1. Folgen Sie den Anweisungen unter [AWS CloudHSM -Schlüsselspeichervoraussetzungen](keystore-prerequisites_5.md). 1. Richten Sie Ihre Signaturschlüssel und die zugehörigen Zertifikate und die Zertifikatskette ein, die im AWS CloudHSM Schlüsselspeicher der aktuellen Server- oder Client-Instanz gespeichert werden sollen. Erstellen Sie die Schlüssel auf dem AWS CloudHSM und importieren Sie dann die zugehörigen Metadaten in Ihren AWS CloudHSM Schlüsselspeicher. Informationen zum Einrichten der Schlüssel und Zertifikate mit keytool finden Sie unter [Erstellen Sie neue AWS CloudHSM Schlüssel mit Keytool](create_key_keytool_5.md). Wenn Sie mehrere Client-Instanzen verwenden, um Ihre zu signieren JARs, erstellen Sie den Schlüssel und importieren Sie die Zertifikatskette. Kopieren Sie dann die resultierende Schlüsselspeicherdatei auf jede Client-Instanz. Wenn Sie häufig neue Schlüssel generieren, ist es möglicherweise einfacher, Zertifikate einzeln in jede Client-Instanz zu importieren. 1. Die gesamte Zertifikatskette sollte überprüfbar sein. Damit die Zertifikatskette verifizierbar ist, müssen Sie möglicherweise das CA-Zertifikat und die Zwischenzertifikate zum AWS CloudHSM Schlüsselspeicher hinzufügen. Im Codeausschnitt in [Signieren Sie eine JAR-Datei mit AWS CloudHSM und Jarsigner](jarsigner_sign_jar_using_hsm_jarsigner_5.md) finden Sie eine Anleitung zur Verwendung von Java-Code zur Überprüfung der Zertifikatskette. Wenn Sie möchten, können Sie keytool verwenden, um Zertifikate zu importieren. Eine Anleitung zur Verwendung von keytool finden Sie unter [Verwenden Sie Keytool, um Zwischen- und Stammzertifikate in den Schlüsselspeicher zu importieren AWS CloudHSM](import_cert_using_keytool_5.md). # Signieren Sie eine JAR-Datei mit AWS CloudHSM und Jarsigner Verwenden Sie den folgenden Befehl, um eine JAR-Datei mit AWS CloudHSM einem Jarsigner zu signieren: ------ #### [ Linux; ] Für OpenJDK 8 ``` jarsigner -keystore example_keystore.store \ -signedjar signthisclass_signed.jar \ -sigalg sha512withrsa \ -storetype CloudHSM \ -J-classpath '-J/opt/cloudhsm/java/*:/usr/lib/jvm/java-1.8.0/lib/tools.jar' \ -J-Djava.library.path=/opt/cloudhsm/lib \ signthisclass.jar ``` Für OpenJDK 11, OpenJDK 17 und OpenJDK 21 ``` jarsigner -keystore example_keystore.store \ -signedjar signthisclass_signed.jar \ -sigalg sha512withrsa \ -storetype CloudHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib \ signthisclass.jar ``` ------ #### [ Windows ] Für Open JDK8 ``` jarsigner -keystore example_keystore.store ` -signedjar signthisclass_signed.jar ` -sigalg sha512withrsa ` -storetype CloudHSM ` -J-classpath '-JC:\Program Files\Amazon\CloudHSM\java\*;C:\Program Files\Java\jdk1.8.0_331\lib\tools.jar' ` "-J-Djava.library.path='C:\Program Files\Amazon\CloudHSM\lib\'" ` signthisclass.jar ``` Für OpenJDK 11, OpenJDK 17 und OpenJDK 21 ``` jarsigner -keystore example_keystore.store ` -signedjar signthisclass_signed.jar ` -sigalg sha512withrsa ` -storetype CloudHSM ` -J-classpath '-JC:\Program Files\Amazon\CloudHSM\java\*'` "-J-Djava.library.path='C:\Program Files\Amazon\CloudHSM\lib\'" ` signthisclass.jar ``` ------ Verwenden Sie den folgenden Befehl, um eine signierte JAR zu überprüfen: ------ #### [ Linux ] Für Open JDK8 ``` jarsigner -verify \ -keystore example_keystore.store \ -sigalg sha512withrsa \ -storetype CloudHSM \ -J-classpath '-J/opt/cloudhsm/java/*:/usr/lib/jvm/java-1.8.0/lib/tools.jar' \ -J-Djava.library.path=/opt/cloudhsm/lib \ signthisclass_signed.jar ``` Für OpenJDK 11, OpenJDK 17 und OpenJDK 21 ``` jarsigner -verify \ -keystore example_keystore.store \ -sigalg sha512withrsa \ -storetype CloudHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib \ signthisclass_signed.jar ``` ------ #### [ Windows ] Für OpenJDK 8 ``` jarsigner -verify ` -keystore example_keystore.store ` -sigalg sha512withrsa ` -storetype CloudHSM ` -J-classpath '-JC:\Program Files\Amazon\CloudHSM\java\*;C:\Program Files\Java\jdk1.8.0_331\lib\tools.jar' ` "-J-Djava.library.path='C:\Program Files\Amazon\CloudHSM\lib\'" ` signthisclass_signed.jar ``` Für OpenJDK 11, OpenJDK 17 und OpenJDK 21 ``` jarsigner -verify ` -keystore example_keystore.store ` -sigalg sha512withrsa ` -storetype CloudHSM ` -J-classpath '-JC:\Program Files\Amazon\CloudHSM\java\*` "-J-Djava.library.path='C:\Program Files\Amazon\CloudHSM\lib\'" ` signthisclass_signed.jar ``` ------ # Bekannte Probleme bei der AWS CloudHSM Integration von Java Keytool und Jarsigner mithilfe des Client SDK 5 Die folgende Liste enthält die aktuelle Liste der bekannten Probleme bei Integrationen mit Java Keytool AWS CloudHSM und Jarsigner, die das Client SDK 5 verwenden. 1. Wir unterstützen keine EC-Schlüssel mit Keytool und Jarsigner. # Verwenden Sie Client SDK 3 zur Integration AWS CloudHSM mit Java Keytool und Jarsigner AWS CloudHSM Der Schlüsselspeicher ist ein spezieller JCE-Schlüsselspeicher, der Zertifikate verwendet, die mit Schlüsseln auf Ihrem Hardware-Sicherheitsmodul (HSM) verknüpft sind, und zwar über Tools von Drittanbietern wie und. `keytool` `jarsigner` AWS CloudHSM speichert keine Zertifikate auf dem HSM, da es sich bei Zertifikaten um öffentliche, nicht vertrauliche Daten handelt. Der AWS CloudHSM Schlüsselspeicher speichert die Zertifikate in einer lokalen Datei und ordnet die Zertifikate den entsprechenden Schlüsseln auf Ihrem HSM zu. Wenn Sie den AWS CloudHSM Schlüsselspeicher verwenden, um neue Schlüssel zu generieren, werden keine Einträge in der lokalen Schlüsselspeicherdatei generiert — die Schlüssel werden auf dem HSM erstellt. Wenn Sie den AWS CloudHSM -Schlüsselspeicher verwenden, um nach Schlüsseln zu suchen, wird die Suche an das HSM übergeben. Wenn Sie Zertifikate im AWS CloudHSM Schlüsselspeicher speichern, überprüft der Anbieter, ob ein key pair mit dem entsprechenden Alias auf dem HSM vorhanden ist, und ordnet dann das bereitgestellte Zertifikat dem entsprechenden key pair zu. **Topics** + [Voraussetzungen](keystore-prerequisites.md) + [Verwenden Sie den Schlüsselspeicher mit Keytool](using_keystore_with_keytool.md) + [Verwenden Sie den Schlüsselspeicher mit Jarsigner](using_keystore_jarsigner.md) + [Bekannte Probleme](known-issues-keytool-jarsigner.md) + [Registrieren Sie bereits vorhandene Schlüssel im Schlüsselspeicher](register-pre-existing-keys-with-keystore.md) # Voraussetzungen für die Integration AWS CloudHSM mit Java Keytool und Jarsigner mithilfe des Client SDK 3 Um den AWS CloudHSM Schlüsselspeicher verwenden zu können, müssen Sie zuerst das JCE SDK initialisieren und konfigurieren. AWS CloudHSM Gehen Sie dazu wie folgt vor. ## Schritt 1: Installieren der JCE Um das JCE, einschließlich der AWS CloudHSM Client-Voraussetzungen, zu installieren, folgen Sie den Schritten zur [Installation der](java-library-install.md) Java-Bibliothek. ## Schritt 2: Hinzufügen von HSM-Anmeldeinformationen zu Umgebungsvariablen Richten Sie Umgebungsvariablen so ein, dass sie Ihre HSM-Anmeldeinformationen enthalten. ``` export HSM_PARTITION=PARTITION_1 export HSM_USER= export HSM_PASSWORD= ``` **Anmerkung** Die CloudHSM JCE bietet verschiedene Anmeldeoptionen. Um den AWS CloudHSM Schlüsselspeicher mit Anwendungen von Drittanbietern zu verwenden, müssen Sie die implizite Anmeldung mit Umgebungsvariablen verwenden. Wenn Sie die explizite Anmeldung über Anwendungscode verwenden möchten, müssen Sie mithilfe des AWS CloudHSM Schlüsselspeichers Ihre eigene Anwendung erstellen. Weitere Informationen finden Sie im Artikel zur [Verwendung des AWS CloudHSM Schlüsselspeichers](alternative-keystore.md). ## Schritt 3: Registrieren Sie den JCE-Anbieter Um den JCE-Anbieter in der CloudProvider Java-Konfiguration zu registrieren. 1. Öffnen Sie die java.security-Konfigurationsdatei in Ihrer Java-Installation zur Bearbeitung. 1. Fügen Sie in der Konfigurationsdatei java.security `com.cavium.provider.CaviumProvider` als letzten Provider hinzu. Wenn sich beispielsweise neun Provider in der Datei java.security befinden, fügen Sie den folgenden Provider als letzten Provider in dem Abschnitt hinzu. Das Hinzufügen des Cavium-Providers mit höherer Priorität kann sich negativ auf die Leistung Ihres Systems auswirken. `security.provider.10=com.cavium.provider.CaviumProvider` **Anmerkung** Intensive Nutzer können daran gewöhnt sein, `-providerName`-, `-providerclass`- und `-providerpath`-Befehlszeilenoptionen bei Verwendung von keytool anzugeben, anstatt die Sicherheitskonfigurationsdatei zu aktualisieren. Wenn Sie versuchen, beim Generieren von Schlüsseln mit dem AWS CloudHSM Schlüsselspeicher Befehlszeilenoptionen anzugeben, führt dies zu Fehlern. # Verwenden Sie den AWS CloudHSM Schlüsselspeicher mit Keytool und verwenden Sie das Client SDK 3 [ Keytool](https://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html) ist ein beliebtes Befehlszeilenprogramm für allgemeine Schlüssel- und Zertifikataufgaben auf Linux-Systemen. Ein vollständiges Tutorial zu keytool liegt außerhalb des Umfangs der AWS CloudHSM -Dokumentation. In diesem Artikel werden die spezifischen Parameter erläutert, die Sie mit verschiedenen Keytool-Funktionen verwenden sollten, wenn Sie sie über den AWS CloudHSM Schlüsselspeicher AWS CloudHSM als Vertrauensbasis verwenden. Wenn Sie Keytool mit dem AWS CloudHSM Schlüsselspeicher verwenden, geben Sie die folgenden Argumente für jeden Keytool-Befehl an: ``` -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib ``` Wenn Sie mithilfe des Schlüsselspeichers eine neue Schlüsselspeicherdatei erstellen möchten, finden Sie AWS CloudHSM weitere Informationen unter. [Verwenden Sie das SDK 3 für den Client AWS CloudHSM KeyStore AWS CloudHSM](alternative-keystore.md#using_cloudhsm_keystore) Um einen vorhandenen Schlüsselspeicher zu verwenden, geben Sie seinen Namen (einschließlich Pfad) mit dem Argument -keystore zu keytool an. Wenn Sie in einem Keytool-Befehl eine nicht existierende Schlüsselspeicherdatei angeben, erstellt der AWS CloudHSM Schlüsselspeicher eine neue Schlüsselspeicherdatei. # Erstellen Sie neue AWS CloudHSM Schlüssel mit Keytool Sie können Keytool verwenden, um jede Art von Schlüssel zu generieren, die vom AWS CloudHSM JCE SDK unterstützt werden. Eine vollständige Liste der Schlüssel und Längen finden Sie im Artikel [ Unterstützte Schlüssel](java-lib-supported.md#java-keys) in der Java-Bibliothek. **Wichtig** Ein mit Keytool generierter Schlüssel wird in der Software generiert und dann AWS CloudHSM als extrahierbarer, persistenter Schlüssel importiert. [Anweisungen zum Erstellen nicht extrahierbarer Schlüssel direkt auf dem Hardware-Sicherheitsmodul (HSM) und deren anschließende Verwendung mit Keytool oder Jarsigner finden Sie im Codebeispiel unter Registrierung bereits vorhandener Schlüssel mit dem Schlüsselspeicher. AWS CloudHSM](register-pre-existing-keys-with-keystore.md) Wir empfehlen nachdrücklich, nicht exportierbare Schlüssel außerhalb von keytool zu generieren und dann entsprechende Zertifikate in den Schlüsselspeicher zu importieren. Wenn Sie extrahierbare RSA- oder EC-Schlüssel über Keytool und Jarsigner verwenden, exportieren die Anbieter Schlüssel aus dem und verwenden den Schlüssel dann lokal für Signaturvorgänge. AWS CloudHSM Wenn mehrere Client-Instanzen mit Ihrem CloudHSM-Cluster verbunden sind, beachten Sie, dass das Importieren eines Zertifikats im Schlüsselspeicher einer Clientinstanz die Zertifikate nicht automatisch auf anderen Client-Instanzen verfügbar macht. Um den Schlüssel und die zugehörigen Zertifikate auf jeder Client-Instanz zu registrieren, müssen Sie eine Java-Anwendung ausführen, wie unter [Generieren eines CSR mit Keytool](generate_csr_using_keytool.md) beschrieben. Alternativ können Sie die erforderlichen Änderungen auf einem Client vornehmen und die resultierende Schlüsselspeicherdatei auf jede andere Client-Instanz kopieren. **Beispiel 1:** Um einen symmetrischen AES-256-Schlüssel zu generieren und ihn in einer Schlüsselspeicherdatei mit dem Namen „example\$1keystore.store“ im Arbeitsverzeichnis zu speichern. Durch eine eindeutige Bezeichnung ersetzen. ** ``` keytool -genseckey -alias -keyalg aes \ -keysize 256 -keystore example_keystore.store \ -storetype CloudHSM -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib/ ``` **Beispiel 2:** Um ein RSA 2048-Schlüsselpaar zu generieren und es in einer Schlüsselspeicherdatei mit dem Namen „example\$1keystore.store“ im Arbeitsverzeichnis zu speichern. Durch eine eindeutige Bezeichnung ersetzen. ** ``` keytool -genkeypair -alias \ -keyalg rsa -keysize 2048 \ -sigalg sha512withrsa \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib/ ``` **Beispiel 3:** Um einen P256-ED-Schlüssel zu generieren und ihn in einer Schlüsselspeicherdatei mit dem Namen „example\$1keystore.store“ im Arbeitsverzeichnis zu speichern. Durch eine eindeutige Bezeichnung ersetzen. ** ``` keytool -genkeypair -alias \ -keyalg ec -keysize 256 \ -sigalg SHA512withECDSA \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib/ ``` Sie finden eine Liste der [unterstützten Signaturalgorithmen](java-lib-supported.md#java-sign-verify) in der Java-Bibliothek. # Löschen Sie einen AWS CloudHSM Schlüssel mit Keytool Der AWS CloudHSM Schlüsselspeicher unterstützt das Löschen von Schlüsseln nicht. Um einen Schlüssel zu löschen, müssen Sie die `deleteKey` Funktion AWS CloudHSM des Befehlszeilentools von verwenden[Löschen Sie einen AWS CloudHSM Schlüssel mit KMU](key_mgmt_util-deleteKey.md). # Generieren Sie eine AWS CloudHSM CSR mit Keytool Sie erhalten die größte Flexibilität beim Generieren einer Zertifikatsignieranforderung (Certificate Signing Request, CSR), wenn Sie die [OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5](openssl-library.md) verwenden. Der folgende Befehl verwendet keytool, um eine CSR für ein Schlüsselpaar mit dem Alias, `example-key-pair`, zu generieren. ``` keytool -certreq -alias \ -file example_csr.csr \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib/ ``` **Anmerkung** Um ein Schlüsselpaar von keytool zu verwenden, muss dieses Schlüsselpaar einen Eintrag in der angegebenen Schlüsselspeicherdatei haben. Wenn Sie ein Schlüsselpaar verwenden möchten, das außerhalb von keytool generiert wurde, müssen Sie die Schlüssel- und Zertifikatmetadaten in den Schlüsselspeicher importieren. Anweisungen zum Importieren der Keystore-Daten finden Sie unter [Import von Zwischen- und Stammzertifikaten in AWS CloudHSM Key](import_cert_using_keytool.md) Store mit Keytool. # Verwenden Sie Keytool, um Zwischen- und Stammzertifikate in den Schlüsselspeicher zu importieren AWS CloudHSM Um ein CA-Zertifikat zu importieren AWS CloudHSM, müssen Sie die Überprüfung einer vollständigen Zertifikatskette für ein neu importiertes Zertifikat aktivieren. Im Folgenden wird ein Beispielbefehl gezeigt. ``` keytool -import -trustcacerts -alias rootCAcert \ -file rootCAcert.cert -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib/ ``` Wenn Sie mehrere Client-Instances mit Ihrem AWS CloudHSM Cluster verbinden, wird durch den Import eines Zertifikats in den Schlüsselspeicher einer Client-Instance das Zertifikat nicht automatisch auf anderen Client-Instances verfügbar gemacht. Sie müssen das Zertifikat auf jeder Client-Instanz importieren. # Verwenden Sie Keytool, um Zertifikate aus dem AWS CloudHSM Schlüsselspeicher zu löschen Der folgende Befehl zeigt ein Beispiel für das Löschen eines AWS CloudHSM Zertifikats aus einem Java-Keytool-Schlüsselspeicher. ``` keytool -delete -alias mydomain -keystore \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib/ ``` Wenn Sie mehrere Client-Instances mit Ihrem AWS CloudHSM Cluster verbinden, wird durch das Löschen eines Zertifikats im Schlüsselspeicher einer Client-Instanz das Zertifikat nicht automatisch aus anderen Client-Instances entfernt. Sie müssen das Zertifikat auf jeder Client-Instanz löschen. # Importieren Sie ein funktionierendes Zertifikat mit AWS CloudHSM Keytool in den Schlüsselspeicher Sobald eine Zertifikatsignieranforderung (CSR) signiert ist, können Sie sie in den AWS CloudHSM -Schlüsselspeicher importieren und mit dem entsprechenden Schlüsselpaar verknüpfen. Der folgende Befehl bietet ein Beispiel. ``` keytool -importcert -noprompt -alias \ -file example_certificate.crt \ -keystore example_keystore.store -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib/ ``` Der Alias sollte ein Schlüsselpaar mit einem zugeordneten Zertifikat im Schlüsselspeicher sein. Wenn der Schlüssel außerhalb von keytool oder auf einer anderen Client-Instanz generiert wird, müssen Sie zuerst die Schlüssel- und Zertifikatmetadaten in den Schlüsselspeicher importieren. Anweisungen zum Importieren der Zertifikatsmetadaten finden Sie im Codebeispiel unter [Registrierung bereits vorhandener Schlüssel mit dem AWS CloudHSM Schlüsselspeicher](register-pre-existing-keys-with-keystore.md). Die Zertifikatkette muss überprüfbar sein. Wenn Sie das Zertifikat nicht überprüfen können, müssen Sie möglicherweise das Signaturzertifikat (Zertifizierungsstelle) in den Schlüsselspeicher importieren, damit die Kette überprüft werden kann. # Exportieren Sie ein Zertifikat AWS CloudHSM mit Keytool Im folgenden Beispiel wird ein Zertifikat im Binärformat X.509 generiert. Um ein menschenlesbares Zertifikat von zu exportieren AWS CloudHSM, fügen Sie `-rfc` es dem `-exportcert` Befehl hinzu. ``` keytool -exportcert -alias \ -file example_exported_certificate.crt \ -keystore example_keystore.store \ -storetype CLOUDHSM \ -J-classpath '-J/opt/cloudhsm/java/*' \ -J-Djava.library.path=/opt/cloudhsm/lib/ ``` # Verwenden Sie den AWS CloudHSM Schlüsselspeicher mit Jarsigner und verwenden Sie das Client SDK 3 Jarsigner ist ein beliebtes Befehlszeilenprogramm zum Signieren von JAR-Dateien mithilfe eines Schlüssels, der sicher auf einem Hardware-Sicherheitsmodul (HSM) gespeichert ist. Ein vollständiges Tutorial zu Jarsigner ist in dieser Dokumentation nicht enthalten. AWS CloudHSM In diesem Abschnitt werden die Jarsigner-Parameter erläutert, die Sie verwenden sollten, um Signaturen AWS CloudHSM als Vertrauensbasis über den Schlüsselspeicher zu signieren und zu verifizieren. AWS CloudHSM # Richten Sie AWS CloudHSM Schlüssel und Zertifikate mit Jarsigner ein Bevor Sie AWS CloudHSM JAR-Dateien mit Jarsigner signieren können, stellen Sie sicher, dass Sie die folgenden Schritte eingerichtet oder abgeschlossen haben: 1. Folgen Sie den Anweisungen unter [AWS CloudHSM -Schlüsselspeichervoraussetzungen ](keystore-prerequisites.md). 1. Richten Sie Ihre Signaturschlüssel und die zugehörigen Zertifikate und die Zertifikatskette ein, die im AWS CloudHSM Schlüsselspeicher der aktuellen Server- oder Client-Instanz gespeichert werden sollen. Erstellen Sie die Schlüssel auf dem AWS CloudHSM und importieren Sie dann die zugehörigen Metadaten in Ihren AWS CloudHSM Schlüsselspeicher. Verwenden Sie das Codebeispiel unter [Registrierung bereits vorhandener Schlüssel beim AWS CloudHSM Schlüsselspeicher](register-pre-existing-keys-with-keystore.md), um Metadaten in den Schlüsselspeicher zu importieren. Informationen zum Einrichten der Schlüssel und Zertifikate mit keytool finden Sie unter [Erstellen Sie neue AWS CloudHSM Schlüssel mit Keytool](create_key_keytool.md). Wenn Sie mehrere Client-Instanzen verwenden, um Ihre zu signieren JARs, erstellen Sie den Schlüssel und importieren Sie die Zertifikatskette. Kopieren Sie dann die resultierende Schlüsselspeicherdatei auf jede Client-Instanz. Wenn Sie häufig neue Schlüssel generieren, ist es möglicherweise einfacher, Zertifikate einzeln in jede Client-Instanz zu importieren. 1. Die gesamte Zertifikatskette sollte überprüfbar sein. Damit die Zertifikatskette verifizierbar ist, müssen Sie möglicherweise das CA-Zertifikat und die Zwischenzertifikate zum AWS CloudHSM Schlüsselspeicher hinzufügen. Anweisungen zur [Verwendung von Java-Code zur Überprüfung der Zertifikatskette finden Sie im Codeausschnitt unter Signieren einer JAR-Datei mit AWS CloudHSM und Jarsigner](jarsigner_sign_jar_using_hsm_jarsigner.md). Wenn Sie möchten, können Sie keytool verwenden, um Zertifikate zu importieren. Anweisungen zur Verwendung von Keytool finden Sie unter Verwenden von [Keytool zum Importieren von Zwischen- und](import_cert_using_keytool.md) Stammzertifikaten in Key Store. AWS CloudHSM # Signieren Sie eine JAR-Datei mit AWS CloudHSM und Jarsigner Verwenden Sie den folgenden Befehl, um eine JAR-Datei mit AWS CloudHSM einem Jarsigner zu signieren: ``` jarsigner -keystore example_keystore.store \ -signedjar signthisclass_signed.jar \ -sigalg sha512withrsa \ -storetype CloudHSM \ -J-classpath '-J/opt/cloudhsm/java/*:/usr/lib/jvm/java-1.8.0/lib/tools.jar' \ -J-Djava.library.path=/opt/cloudhsm/lib \ signthisclass.jar ``` Verwenden Sie den folgenden Befehl, um eine signierte JAR zu überprüfen: ``` jarsigner -verify \ -keystore example_keystore.store \ -sigalg sha512withrsa \ -storetype CloudHSM \ -J-classpath '-J/opt/cloudhsm/java/*:/usr/lib/jvm/java-1.8.0/lib/tools.jar' \ -J-Djava.library.path=/opt/cloudhsm/lib \ signthisclass_signed.jar ``` # Bekannte Probleme bei der AWS CloudHSM Integration von Java, Keytool und Jarsigner mithilfe des Client SDK 3 Die folgende Liste enthält die aktuelle Liste der bekannten Probleme bei Integrationen mit Java Keytool AWS CloudHSM und Jarsigner, die das Client SDK 3 verwenden. + Beim Generieren von Schlüsseln mit Keytool kann der erste Anbieter in der Anbieterkonfiguration nicht verwendet werden. CaviumProvider + Beim Generieren von Schlüsseln mit keytool wird der erste (unterstützte) Provider in der Sicherheitskonfigurationsdatei verwendet, um den Schlüssel zu generieren. Dies ist in der Regel ein Software-Provider. Der generierte Schlüssel erhält dann einen Alias und wird während des Hinzufügens des Schlüssels als persistenter (Token-) Schlüssel in das AWS CloudHSM HSM importiert. + Wenn Sie Keytool mit AWS CloudHSM Schlüsselspeicher verwenden `-providerName``-providerclass`, geben Sie keine `-providerpath` Optionen oder in der Befehlszeile an. Geben Sie diese Optionen in der Sicherheitsanbieterdatei an, wie in den [Key Store-Voraussetzungen](keystore-prerequisites.md) beschrieben. + Wenn Sie nicht extrahierbare EC-Schlüssel über Keytool und Jarsigner verwenden, muss der SunEC-Anbieter removed/disabled aus der Liste der Anbieter in der Datei java.security stammen. Wenn Sie extrahierbare EC-Schlüssel über Keytool und Jarsigner verwenden, exportieren die Anbieter Schlüsselbits aus dem HSM und verwenden den Schlüssel lokal für Signiervorgänge. AWS CloudHSM Wir empfehlen nicht, exportierbare Schlüssel mit keytool oder Jarsigner zu verwenden. # Registrieren Sie bereits vorhandene Schlüssel im Schlüsselspeicher AWS CloudHSM Für maximale Sicherheit und Flexibilität bei Attributen und Kennzeichnungen empfehlen wir Ihnen, Ihre AWS CloudHSM Signaturschlüssel mit [key\$1mgmt\$1util](generate-keys.md) zu generieren. Sie können auch eine Java-Anwendung verwenden, um den Schlüssel in AWS CloudHSM zu generieren. Der folgende Abschnitt enthält ein Codebeispiel, das zeigt, wie ein neues key pair auf dem HSM generiert und es mit vorhandenen Schlüsseln registriert wird, die in den AWS CloudHSM Schlüsselspeicher importiert wurden. Die importierten Schlüssel stehen für die Verwendung mit Tools von Drittanbietern wie keytool und Jarsigner zur Verfügung. Wenn Sie einen bereits vorhandenen Schlüssel verwenden möchten, ändern Sie das Codebeispiel so, dass es nach einem Schlüssel nach Benennung sucht, anstatt einen neuen Schlüssel zu generieren. Ein Beispielcode für das Nachschlagen eines Schlüssels anhand seiner Bezeichnung ist im [KeyUtilitiesRunner.java-Beispiel](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java) unter verfügbar. GitHub **Wichtig** Bei der Registrierung eines Schlüssels, der in AWS CloudHSM einem lokalen Schlüsselspeicher gespeichert ist, wird der Schlüssel nicht exportiert. Wenn der Schlüssel registriert ist, registriert der Schlüsselspeicher den Alias (oder die Benennung) des Schlüssels und korreliert lokal Speicherzertifikatobjekte mit einem Schlüsselpaar auf dem AWS CloudHSM. Solange das Schlüsselpaar als nicht exportierbar erstellt wird, verlassen die Schlüsselbits das HSM nicht. ``` // // Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy of this // software and associated documentation files (the "Software"), to deal in the Software // without restriction, including without limitation the rights to use, copy, modify, // merge, publish, distribute, sublicense, and/or sell copies of the Software, and to // permit persons to whom the Software is furnished to do so. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, // INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // package com.amazonaws.cloudhsm.examples; import com.cavium.key.CaviumKey; import com.cavium.key.parameter.CaviumAESKeyGenParameterSpec; import com.cavium.key.parameter.CaviumRSAKeyGenParameterSpec; import com.cavium.asn1.Encoder; import com.cavium.cfm2.Util; import javax.crypto.KeyGenerator; import java.io.ByteArrayInputStream; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileNotFoundException; import java.math.BigInteger; import java.security.*; import java.security.cert.Certificate; import java.security.cert.CertificateException; import java.security.cert.CertificateFactory; import java.security.cert.X509Certificate; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import java.security.KeyStore.PasswordProtection; import java.security.KeyStore.PrivateKeyEntry; import java.security.KeyStore.Entry; import java.util.Calendar; import java.util.Date; import java.util.Enumeration; // // KeyStoreExampleRunner demonstrates how to load a keystore, and associate a certificate with a // key in that keystore. // // This example relies on implicit credentials, so you must setup your environment correctly. // // https://docs.aws.amazon.com/cloudhsm/latest/userguide/java-library-install.html#java-library-credentials // public class KeyStoreExampleRunner { private static byte[] COMMON_NAME_OID = new byte[] { (byte) 0x55, (byte) 0x04, (byte) 0x03 }; private static byte[] COUNTRY_NAME_OID = new byte[] { (byte) 0x55, (byte) 0x04, (byte) 0x06 }; private static byte[] LOCALITY_NAME_OID = new byte[] { (byte) 0x55, (byte) 0x04, (byte) 0x07 }; private static byte[] STATE_OR_PROVINCE_NAME_OID = new byte[] { (byte) 0x55, (byte) 0x04, (byte) 0x08 }; private static byte[] ORGANIZATION_NAME_OID = new byte[] { (byte) 0x55, (byte) 0x04, (byte) 0x0A }; private static byte[] ORGANIZATION_UNIT_OID = new byte[] { (byte) 0x55, (byte) 0x04, (byte) 0x0B }; private static String helpString = "KeyStoreExampleRunner%n" + "This sample demonstrates how to load and store keys using a keystore.%n%n" + "Options%n" + "\t--help\t\t\tDisplay this message.%n" + "\t--store \t\tPath of the keystore.%n" + "\t--password \t\tPassword for the keystore (not your CU password).%n" + "\t--label