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. # JCE-Anbieter für AWS CloudHSM Client SDK 3 Der AWS CloudHSM JCE-Anbieter ist eine Provider-Implementierung, die auf dem Java Cryptographic Extension (JCE) Provider-Framework basiert. JCE ermöglicht es Ihnen, kryptografische Operationen mit dem Java Development Kits (JDK) durchzuführen. In diesem Handbuch wird der AWS CloudHSM JCE-Anbieter manchmal als JCE-Anbieter bezeichnet. Verwenden Sie den JCE-Anbieter und das JDK, um kryptografische Operationen auf das HSM auszulagern. **Topics** + [Installieren Sie den JCE-Anbieter für AWS CloudHSM Client SDK 3](java-library-install.md) + [Grundlagen der Schlüsselverwaltung im JCE-Anbieter für Client SDK 3 AWS CloudHSM](java-library-key-basics.md) + [Unterstützte Mechanismen für Client SDK 3 für AWS CloudHSM Client SDK 3](java-lib-supported.md) + [Unterstützte Java-Schlüsselattribute für AWS CloudHSM Client SDK 3](java-lib-attributes.md) + [Codebeispiele für die AWS CloudHSM Softwarebibliothek für Java für Client SDK 3](java-samples_3.md) + [AWS CloudHSM KeyStore Java-Klasse für Client SDK 3](alternative-keystore.md) # Installieren Sie den JCE-Anbieter für AWS CloudHSM Client SDK 3 Bevor Sie den JCE-Anbieter verwenden können, benötigen Sie den AWS CloudHSM Client. Der Client ist ein Daemon, der eine end-to-end verschlüsselte Kommunikation mit dem HSMs in Ihrem Cluster herstellt. Der JCE-Anbieter kommuniziert lokal mit dem Client. Wenn Sie das AWS CloudHSM Client-Paket noch nicht installiert und konfiguriert haben, tun Sie dies jetzt, indem Sie die Schritte unter [Installieren des Clients (Linux)](cmu-install-and-configure-client-linux.md) befolgen. Nachdem Sie den Client installiert und konfiguriert haben, verwenden Sie den folgenden Befehl ein, um ihn zu starten. Beachten Sie, dass der JCE-Anbieter nur unter Linux und kompatiblen Betriebssystemen unterstützt wird. ------ #### [ Amazon Linux ] ``` $ sudo start cloudhsm-client ``` ------ #### [ Amazon Linux 2 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ CentOS 7 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ CentOS 8 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ RHEL 7 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ RHEL 8 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ Ubuntu 16.04 LTS ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ Ubuntu 18.04 LTS ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ Ubuntu 20.04 LTS ] ``` $ sudo systemctl start cloudhsm-client ``` ------ Verwenden Sie die folgenden Abschnitte, um den Anbieter zu installieren, zu überprüfen und Anmeldeinformationen für ihn bereitzustellen. **Topics** + [Schritt 1: Installieren Sie den JCE-Anbieter](#install-java-library) + [Schritt 2: Überprüfen Sie die Installation](#validate-install) + [Schritt 3: Geben Sie dem JCE-Anbieter Anmeldeinformationen an](#java-library-credentials) ## Schritt 1: Installieren Sie den JCE-Anbieter Verwenden Sie die folgenden Befehle, um den JCE-Anbieter herunterzuladen und zu installieren. Dieser Anbieter wird nur von Linux und kompatiblen Betriebssystemen unterstützt. **Anmerkung** Informationen zum Upgraden finden Sie unter [Aktualisieren Sie das Client-SDK 3](client-upgrade.md). ------ #### [ Amazon Linux ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-jce-latest.el6.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-jce-latest.el6.x86_64.rpm ``` ------ #### [ Amazon Linux 2 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-jce-latest.el7.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-jce-latest.el7.x86_64.rpm ``` ------ #### [ CentOS 7 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-jce-latest.el7.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-jce-latest.el7.x86_64.rpm ``` ------ #### [ CentOS 8 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-jce-latest.el8.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-jce-latest.el8.x86_64.rpm ``` ------ #### [ RHEL 7 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-jce-latest.el7.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-jce-latest.el7.x86_64.rpm ``` ------ #### [ RHEL 8 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-jce-latest.el8.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-jce-latest.el8.x86_64.rpm ``` ------ #### [ Ubuntu 16.04 LTS ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Xenial/cloudhsm-client-jce_latest_amd64.deb ``` ``` $ sudo apt install ./cloudhsm-client-jce_latest_amd64.deb ``` ------ #### [ Ubuntu 18.04 LTS ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Bionic/cloudhsm-client-jce_latest_u18.04_amd64.deb ``` ``` $ sudo apt install ./cloudhsm-client-jce_latest_u18.04_amd64.deb ``` ------ Nachdem Sie die vorangegangenen Befehle ausgeführt haben, finden Sie die folgenden JCE-Anbieter-Dateien: + `/opt/cloudhsm/java/cloudhsm-.jar` + `/opt/cloudhsm/java/cloudhsm-test-.jar` + `/opt/cloudhsm/java/hamcrest-all-1.3.jar` + `/opt/cloudhsm/java/junit.jar` + `/opt/cloudhsm/java/log4j-api-2.17.1.jar` + `/opt/cloudhsm/java/log4j-core-2.17.1.jar` + `/opt/cloudhsm/lib/libcaviumjca.so` ## Schritt 2: Überprüfen Sie die Installation Führen Sie grundlegende Funktionen des HSM aus, um die Installation zu überprüfen. **Um die Installation des JCE-Anbieters zu überprüfen** 1. (Optional) Falls Sie Java nicht bereits in Ihrer Umgebung installiert haben, verwenden Sie den folgenden Befehl zur Installation. ------ #### [ Linux (and compatible libraries) ] ``` $ sudo yum install java-1.8.0-openjdk ``` ------ #### [ Ubuntu ] ``` $ sudo apt-get install openjdk-8-jre ``` ------ 1. Verwenden Sie die folgenden Befehle, um die erforderlichen Umgebungsvariablen festzulegen. Ersetzen Sie ** und ** durch die Anmeldeinformationen eines Krypto-Benutzers (CU). ``` $ export LD_LIBRARY_PATH=/opt/cloudhsm/lib ``` ``` $ export HSM_PARTITION=PARTITION_1 ``` ``` $ export HSM_USER= ``` ``` $ export HSM_PASSWORD= ``` 1. Führen Sie den folgenden Befehl aus, um den Test der grundlegenden Funktionen zu starten. Wenn dies erfolgreich ist, sollte die Ausgabe des Befehls ähnlich wie die folgende sein. ``` $ java8 -classpath "/opt/cloudhsm/java/*" org.junit.runner.JUnitCore TestBasicFunctionality JUnit version 4.11 .2018-08-20 17:53:48,514 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:33) - Adding provider. 2018-08-20 17:53:48,612 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:42) - Logging in. 2018-08-20 17:53:48,612 INFO [main] cfm2.LoginManager (LoginManager.java:104) - Looking for credentials in HsmCredentials.properties 2018-08-20 17:53:48,612 INFO [main] cfm2.LoginManager (LoginManager.java:122) - Looking for credentials in System.properties 2018-08-20 17:53:48,613 INFO [main] cfm2.LoginManager (LoginManager.java:130) - Looking for credentials in System.env SDK Version: 2.03 2018-08-20 17:53:48,655 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:54) - Generating AES Key with key size 256. 2018-08-20 17:53:48,698 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:63) - Encrypting with AES Key. 2018-08-20 17:53:48,705 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:84) - Deleting AES Key. 2018-08-20 17:53:48,707 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:92) - Logging out. Time: 0.205 OK (1 test) ``` ## Schritt 3: Geben Sie dem JCE-Anbieter Anmeldeinformationen an HSMs Sie müssen Ihre Java-Anwendung authentifizieren, bevor die Anwendung sie verwenden kann. Jede Anwendung kann eine Sitzung verwenden. HSMs authentifizieren Sie eine Sitzung, indem Sie entweder die explizite oder die implizite Anmeldemethode verwenden. **Explizite Anmeldemethode** – Mit dieser Methode können Sie CloudHSM-Anmeldeinformationen direkt in der Anwendung bereitstellen. Es verwendet die `LoginManager.login()`-Methode, bei der Sie den CU-Benutzernamen, das Passwort und die HSM-Partitions-ID übergeben. Weitere Informationen zur Verwendung der expliziten Anmeldemethode finden Sie im Code-Beispiel [Anmelden bei einem HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java). **Implizite Anmeldemethode** – Mit dieser Methode können Sie CloudHSM-Anmeldeinformationen entweder in einer neuen Property-Datei, über Systemeigenschaften oder als Umgebungsvariablen festlegen. + **Neue Eigenschaftsdatei** – Erstellen Sie eine neue Datei namens `HsmCredentials.properties` und fügen Sie sie zum `CLASSPATH` Ihrer Anwendung hinzu. Die Datei sollte Folgendes enthalten: ``` HSM_PARTITION = PARTITION_1 HSM_USER = HSM_PASSWORD = ``` + **Systemeigenschaften** – Anmeldeinformationen über Systemeigenschaften fest, wenn Sie Ihre Anwendung ausführen. Die folgenden Beispiele zeigen zwei verschiedene Möglichkeiten: ``` $ java -DHSM_PARTITION=PARTITION_1 -DHSM_USER= -DHSM_PASSWORD= ``` ``` System.setProperty("HSM_PARTITION","PARTITION_1"); System.setProperty("HSM_USER",""); System.setProperty("HSM_PASSWORD",""); ``` + **Umgebungsvariablen** – Anmeldeinformationen als Umgebungsvariablen festlegen. ``` $ export HSM_PARTITION=PARTITION_1 $ export HSM_USER= $ export HSM_PASSWORD= ``` Anmeldeinformationen sind möglicherweise nicht verfügbar, wenn die Anwendung sie nicht bereitstellt oder wenn Sie eine Operation ausführen, bevor der HSM die Sitzung authentifiziert. In diesen Fällen sucht die CloudHSM-Softwarebibliothek für Java in der folgenden Reihenfolge nach den Anmeldeinformationen: 1. `HsmCredentials.properties` 1. Systemeigenschaften 1. Umgebungsvariablen **Fehlerbehandlung** Die Fehlerbehandlung ist bei der expliziten Anmeldung einfacher als bei der impliziten Anmeldemethode. Wenn Sie die Klasse `LoginManager` verwenden, haben Sie mehr Kontrolle darüber, wie Ihre Anwendung mit Fehlern umgeht. Die implizite Anmeldemethode macht es schwierig, die Fehlerbehandlung zu verstehen, wenn die Anmeldeinformationen ungültig sind oder Probleme bei der HSMs Authentifizierung der Sitzung auftreten. # Grundlagen der Schlüsselverwaltung im JCE-Anbieter für Client SDK 3 AWS CloudHSM Die Grundlagen der Schlüsselverwaltung im JCE-Anbieter umfassen den Import von Schlüsseln, den Export von Schlüsseln, das Laden von Schlüsseln per Handle oder das Löschen von Schlüsseln. Weitere Informationen zur Schlüsselverwaltung finden Sie im Codebeispiel [Schlüssel verwalten](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java). Weitere Codebeispiele für JCE-Anbieter finden Sie auch in [Codebeispiele](java-samples_3.md). # Unterstützte Mechanismen für Client SDK 3 für AWS CloudHSM Client SDK 3 Dieses Thema enthält Informationen zu den unterstützten Mechanismen für den JCE-Anbieter mit dem AWS CloudHSM Client-SDK 3. Informationen zu den Schnittstellen und Engine-Klassen der Java Cryptography Architecture (JCA), die von unterstützt werden AWS CloudHSM, finden Sie in den folgenden Themen. **Topics** + [Unterstützte Schlüssel](#java-keys) + [Unterstützte Verschlüsselungen](#java-ciphers) + [Unterstützte Digests](#java-digests) + [Unterstützte Hash-basierter Nachrichtenauthentifizierungscode (HMAC)-Algorithmen](#java-mac) + [Unterstützte Mechanismen sign/verify](#java-sign-verify) + [Anmerkungen zum Mechanismus](#w2aac25c23c25c11c17) ## Unterstützte Schlüssel Mit der AWS CloudHSM Softwarebibliothek für Java können Sie die folgenden Schlüsseltypen generieren. + AES – 128-, 192- und 256-Bit AES-Schlüssel. + DESede — 92-Bit-3DES-Schlüssel. Eine bevorstehende Änderung finden Sie im Hinweis [1](#java-keys-note-1) unten. + ECC-Schlüsselpaare für die NIST secp256r1- (P-256), secp384r1- (P-384) und secp256k1-Kurven (Blockchain). + RSA – 2048-Bit- bis 4096-Bit-RSA-Schlüssel, in Schritten von je 256 Bit. Zusätzlich zu den Standardparametern unterstützen wir die folgenden Parameter für die einzelnen generierten Schlüssel. + **Label**: Eine Schlüsselbezeichnung anhand der Sie nach Schlüsseln suchen können. + **isExtractable**: Gibt an, ob ein Schlüssel vom HSM exportiert werden kann. + **isPersistent**: Gibt an, ob der Schlüssel nach Beenden der aktuellen Sitzung weiterhin im HSM bleibt. **Anmerkung** Die Java-Bibliothek Version 3.1 bietet die Möglichkeit, Parameter genauer zu spezifizieren. Weitere Informationen finden Sie unter [Unterstützte Java-Attribute](java-lib-attributes.md). ## Unterstützte Verschlüsselungen Die AWS CloudHSM Softwarebibliothek für Java unterstützt die folgenden Kombinationen aus Algorithmus, Modus und Polsterung. | Algorithmus | Mode | Padding | Hinweise | | --- | --- | --- | --- | | AES | CBC | `AES/CBC/NoPadding` `AES/CBC/PKCS5Padding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. | | AES | ECB | `AES/ECB/NoPadding` `AES/ECB/PKCS5Padding` | Implementiert Cipher.ENCRYPT\$1MODE und Cipher.DECRYPT\$1MODE. Transformation AES verwenden. | | AES | CTR | `AES/CTR/NoPadding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. | | AES | GCM | AES/GCM/NoPadding | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`, `Cipher.WRAP_MODE` und `Cipher.UNWRAP_MODE`.HSM ignoriert den Initialisierungsvektor (IV) der Anforderung während der AES-GCM-Datenverschlüsselung und verwendet stattdessen einen selbst generierten IV. Nach Abschluss der Operation müssen Sie `Cipher.getIV()` abrufen, um den IV zu erhalten. | | AESWrap | ECB | `AESWrap/ECB/ZeroPadding` `AESWrap/ECB/NoPadding` `AESWrap/ECB/PKCS5Padding` | Implementiert `Cipher.WRAP_MODE` und `Cipher.UNWRAP_MODE`. Transformation AES verwenden. | | DESede (Dreifaches DES) | CBC | `DESede/CBC/NoPadding` `DESede/CBC/PKCS5Padding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. Die Schlüsselerstellungsvorgänge akzeptieren die Größen 168 oder 192 Bits. Intern sind jedoch alle DESede Schlüssel 192 Bit groß. Eine bevorstehende Änderung finden Sie im Hinweis [1](#java-keys-note-1) unten. | | DESede (Dreifaches DES) | ECB | `DESede/ECB/NoPadding``DESede/ECB/PKCS5Padding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. Die Schlüsselerstellungsvorgänge akzeptieren die Größen 168 oder 192 Bits. Intern sind jedoch alle DESede Schlüssel 192 Bit groß. Eine bevorstehende Änderung finden Sie im Hinweis [1](#java-keys-note-1) unten. | | RSA | ECB | `RSA/ECB/NoPadding``RSA/ECB/PKCS1Padding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. Eine bevorstehende Änderung finden Sie im Hinweis [1](#java-keys-note-1) unten. | | RSA | ECB | `RSA/ECB/OAEPPadding` `RSA/ECB/OAEPWithSHA-1ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-224ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-256ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-384ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-512ANDMGF1Padding` | Implementiert `Cipher.ENCRYPT_MODE`, `Cipher.DECRYPT_MODE`, `Cipher.WRAP_MODE` und `Cipher.UNWRAP_MODE`. `OAEPPadding` ist `OAEP` mit den `SHA-1` Padding-Typ. | | RSAAESWrap | ECB | OAEPPADDING | Implementiert Cipher.WRAP\$1Mode und Cipher.UNWRAP\$1MODE. | ## Unterstützte Digests Die AWS CloudHSM Softwarebibliothek für Java unterstützt die folgenden Message Digests. + `SHA-1` + `SHA-224` + `SHA-256` + `SHA-384` + `SHA-512` **Anmerkung** Daten mit weniger als 16 KB werden im HSM mit einem Hash-Wert versehen. Größere Daten werden lokal in der Software mit einem Hash-Wert versehen. ## Unterstützte Hash-basierter Nachrichtenauthentifizierungscode (HMAC)-Algorithmen Die AWS CloudHSM Softwarebibliothek für Java unterstützt die folgenden HMAC-Algorithmen. + `HmacSHA1` + `HmacSHA224` + `HmacSHA256` + `HmacSHA384` + `HmacSHA512` ## Unterstützte Mechanismen sign/verify Die AWS CloudHSM Softwarebibliothek für Java unterstützt die folgenden Arten der Signatur und Überprüfung. **RSA-Signaturtypen** + `NONEwithRSA` + `SHA1withRSA` + `SHA224withRSA` + `SHA256withRSA` + `SHA384withRSA` + `SHA512withRSA` + `SHA1withRSA/PSS` + `SHA224withRSA/PSS` + `SHA256withRSA/PSS` + `SHA384withRSA/PSS` + `SHA512withRSA/PSS` **ECDSA-Signaturtypen** + `NONEwithECDSA` + `SHA1withECDSA` + `SHA224withECDSA` + `SHA256withECDSA` + `SHA384withECDSA` + `SHA512withECDSA` ## Anmerkungen zum Mechanismus [1] Gemäß den NIST-Richtlinien ist dies für Cluster im FIPS-Modus nach 2023 nicht zulässig. Für Cluster im Nicht-FIPS-Modus ist dies auch nach 2023 zulässig. Details dazu finden Sie unter [FIPS-140-Konformität: Mechanismus 2024 nicht mehr unterstützt](compliance-dep-notif.md#compliance-dep-notif-1). # Unterstützte Java-Schlüsselattribute für AWS CloudHSM Client SDK 3 In diesem Thema wird beschrieben, wie Sie eine proprietäre Erweiterung für die Java-Bibliothek, Version 3.1, verwenden, um Schlüsselattribute für das AWS CloudHSM Client SDK 3 festzulegen. Verwenden Sie diese Erweiterung, um unterstützte Schlüsselattribute und ihre Werte während der folgenden Vorgänge festzulegen: + Schlüsselgenerierung + Schlüsselimport + Schlüssel entpacken **Anmerkung** Die Erweiterung zum Festlegen benutzerdefinierter Schlüsselattribute ist eine optionale Funktion. Wenn Sie bereits über einen in der Java-Bibliothek Version 3.0 funktionierenden Code verfügen, müssen Sie diesen Code nicht ändern. Schlüssel, die Sie erstellen, enthalten weiterhin dieselben Attribute wie zuvor. **Topics** + [Grundlegendes zu Attributen](#java-understanding-attributes) + [Unterstützte Attribute](#java-attributes) + [Festlegen von Attributen für einen Schlüssel](#java-setting-attributes) + [Zusammenführung](#java-attributes-summary) ## Grundlegendes zu Attributen Mithilfe von Schlüsselattributen legen Sie fest, welche Aktionen für Schlüsselobjekte zulässig sind, einschließlich öffentlicher, privater oder geheimer Schlüssel. Schlüsselattribute und -werte definieren Sie bei der Erstellung von Schlüsselobjekten. Die Java Cryptography Extension (JCE) gibt jedoch nicht an, wie Sie Werte für Schlüsselattribute festlegen sollten. Daher sind die meisten Aktionen standardmäßig zulässig. Im Gegensatz dazu definiert der PKCS\$1 11-Standard einen umfassenden Satz von Attributen mit restriktiveren Standardeinstellungen. Ab der Java-Bibliothek Version 3.1 bietet CloudHSM eine proprietäre Erweiterung, mit der Sie restriktivere Werte für häufig verwendete Attribute festlegen können. ## Unterstützte Attribute Sie können Werte für die Attribute festlegen, die in der folgenden Tabelle aufgeführt sind. Als bewährte Methode legen Sie nur Werte für Attribute fest, die Sie einschränken möchten. Wenn Sie keinen Wert angeben, verwendet CloudHSM den in der folgenden Tabelle angegebenen Standardwert. Eine leere Zelle in der Spalte „Standardwert“ gibt an, dass dem Attribut kein spezifischer Standardwert zugewiesen ist. **** | Attribut | Standardwert | Hinweise | | --- | --- | --- | | | Symmetrischer Schlüssel | Öffentlicher Schlüssel im Schlüsselpaar | Privater Schlüssel im Schlüsselpaar | | | CKA\$1TOKEN | FALSE | FALSE | FALSE | Ein permanenter Schlüssel, der HSMs im gesamten Cluster repliziert und in Backups enthalten ist. CKA\$1TOKEN = FALSE impliziert einen Sitzungsschlüssel, der nur auf ein HSM geladen und automatisch gelöscht wird, wenn die Verbindung zum HSM unterbrochen wird. | | CKA\$1LABEL | | | | Eine benutzerdefinierte Zeichenfolge. Sie ermöglicht Ihnen, Schlüssel auf Ihrem HSM leicht zu identifizieren. | | CKA\$1EXTRACTABLE | TRUE | | TRUE | „True“ gibt an, dass Sie diesen Schlüssel aus dem HSM exportieren können. | | CKA\$1ENCRYPT | TRUE | TRUE | | „True“ gibt an, dass Sie den Schlüssel zur Verschlüsselung eines beliebigen Puffers verwenden können. | | CKA\$1DECRYPT | TRUE | | TRUE | „True“ gibt an, dass Sie den Schlüssel zur Entschlüsselung eines beliebigen Puffers verwenden können. Sie legen dies im Allgemeinen auf „FALSE“ fest für einen Schlüssel, dessen CKA\$1WRAP auf „True“ festgelegt ist. | | CKA\$1WRAP | TRUE | TRUE | | „True“ gibt an, dass Sie den Schlüssel zum Packen eines anderen Schlüssels verwenden können. Für private Schlüssel legen Sie dies in der Regel auf „FALSE“ fest. | | CKA\$1UNWRAP | TRUE | | TRUE | „True“ gibt an, dass Sie mit dem Schlüssel einen anderen Schlüssel entpacken (importieren) können. | | CKA\$1SIGN | TRUE | | TRUE | „True“ gibt an, dass Sie den Schlüssel verwenden können, um einen Hashwert zu signieren. Für öffentliche und private Schlüssel, die Sie archiviert haben, ist dies im Allgemeinen auf „FALSE“ festgelegt. | | CKA\$1VERIFY | TRUE | TRUE | | „True“ gibt an, dass Sie den Schlüssel verwenden können, um eine Signatur zu überprüfen. Für private Schlüssel ist dies im Allgemeinen auf „FALSE“ festgelegt. | | CKA\$1PRIVATE | TRUE | TRUE | TRUE | „True“ gibt an, dass ein Benutzer erst auf den Schlüssel zugreifen darf, wenn der Benutzer authentifiziert ist. Zur Verdeutlichung: Benutzer können erst dann auf Schlüssel in CloudHSM zugreifen, wenn sie authentifiziert sind, selbst wenn dieses Attribut auf „FALSE“ gesetzt ist. | **Anmerkung** Sie erhalten eine breitere Unterstützung für Attribute in der PKCS \$111-Bibliothek. Weitere Informationen finden Sie unter [Unterstützte PKCS \$111-Attribute](pkcs11-attributes.md). ## Festlegen von Attributen für einen Schlüssel `CloudHsmKeyAttributesMap` ist ein [Java-Map](https://devdocs.io/openjdk~8/java/util/map)-ähnliches Objekt, mit dem Sie Attributwerte für Schlüsselobjekte festlegen können. Die Methoden für `CloudHsmKeyAttributesMap` funktionieren ähnlich den Methoden, die für die Java-Map-Manipulation verwendet werden. Sie haben zwei Optionen, um benutzerdefinierte Werte für Attribute festzulegen: + Verwenden Sie die in der folgenden Tabelle aufgeführten Methoden + Verwenden Sie Builder-Muster, die später in diesem Dokument gezeigt werden Attributzuordnungsobjekte unterstützen die folgenden Methoden zum Festlegen von Attributen: **** | Operation | Rückgabewert | `CloudHSMKeyAttributesMap`-Methode | | --- | --- | --- | | Abrufen des Werts eines Schlüsselattributs für einen vorhandenen Schlüssel | Objekt (das den Wert enthält) oder null | **get**(keyAttribute) | | Eingeben des Werts eines Schlüsselattributs | Der vorherige Wert, der dem Schlüsselattribut zugeordnet ist, oder null, wenn keine Zuordnung für ein Schlüsselattribut vorhanden ist | **put**(keyAttribute, Wert) | | Eingeben von Werten für mehrere Schlüsselattribute | – | **putAll** () keyAttributesMap | | Entfernen eines Schlüssel-Wert-Paares aus der Attributzuordnung | Der vorherige Wert, der dem Schlüsselattribut zugeordnet ist, oder *null*, wenn keine Zuordnung für ein Schlüsselattribut vorhanden ist | **remove**(keyAttribute) | **Anmerkung** Alle Attribute, die Sie nicht explizit bestimmen, werden auf die Standardwerte festgelegt, die in der vorherigen Tabelle in [Unterstützte Attribute](#java-attributes) aufgeführt sind. ### Beispiel für Builder-Muster Entwickler finden es im Allgemeinen bequemer, Klassen über das Builder-Muster zu verwenden. Beispiele: ``` import com.amazonaws.cloudhsm.CloudHsmKeyAttributes; import com.amazonaws.cloudhsm.CloudHsmKeyAttributesMap; import com.amazonaws.cloudhsm.CloudHsmKeyPairAttributesMap; CloudHsmKeyAttributesMap keyAttributesSessionDecryptionKey = new CloudHsmKeyAttributesMap.Builder() .put(CloudHsmKeyAttributes.CKA_LABEL, "ExtractableSessionKeyEncryptDecrypt") .put(CloudHsmKeyAttributes.CKA_WRAP, false) .put(CloudHsmKeyAttributes.CKA_UNWRAP, false) .put(CloudHsmKeyAttributes.CKA_SIGN, false) .put(CloudHsmKeyAttributes.CKA_VERIFY, false) .build(); CloudHsmKeyAttributesMap keyAttributesTokenWrappingKey = new CloudHsmKeyAttributesMap.Builder() .put(CloudHsmKeyAttributes.CKA_LABEL, "TokenWrappingKey") .put(CloudHsmKeyAttributes.CKA_TOKEN, true) .put(CloudHsmKeyAttributes.CKA_ENCRYPT, false) .put(CloudHsmKeyAttributes.CKA_DECRYPT, false) .put(CloudHsmKeyAttributes.CKA_SIGN, false) .put(CloudHsmKeyAttributes.CKA_VERIFY, false) .build(); ``` Entwickler können auch vordefinierte Attributsätze verwenden, um bewährte Methoden in Schlüsselvorlagen leicht durchzusetzen. Beispiel: ``` //best practice template for wrapping keys CloudHsmKeyAttributesMap commonKeyAttrs = new CloudHsmKeyAttributesMap.Builder() .put(CloudHsmKeyAttributes.CKA_EXTRACTABLE, false) .put(CloudHsmKeyAttributes.CKA_DECRYPT, false) .build(); // initialize a new instance of CloudHsmKeyAttributesMap by copying commonKeyAttrs // but with an appropriate label CloudHsmKeyAttributesMap firstKeyAttrs = new CloudHsmKeyAttributesMap(commonKeyAttrs); firstKeyAttrs.put(CloudHsmKeyAttributes.CKA_LABEL, "key label"); // alternatively, putAll() will overwrite existing values to enforce conformance CloudHsmKeyAttributesMap secondKeyAttrs = new CloudHsmKeyAttributesMap(); secondKeyAttrs.put(CloudHsmKeyAttributes.CKA_DECRYPT, true); secondKeyAttrs.put(CloudHsmKeyAttributes.CKA_ENCRYPT, true); secondKeyAttrs.put(CloudHsmKeyAttributes.CKA_LABEL, “safe wrapping key”); secondKeyAttrs.putAll(commonKeyAttrs); // will overwrite CKA_DECRYPT to be FALSE ``` ### Festlegen von Attributen für ein Schlüsselpaar Verwenden Sie die Java-Klasse `CloudHsmKeyPairAttributesMap`, um Schlüsselattribute für ein Schlüsselpaar zu verarbeiten. `CloudHsmKeyPairAttributesMap` fasst zwei `CloudHsmKeyAttributesMap`-Objekte zusammen, eines für einen öffentlichen Schlüssel und eines für einen privaten Schlüssel. Um einzelne Attribute für den öffentlichen und den privaten Schlüssel separat festzulegen, können Sie die `put()`-Methode für das entsprechende `CloudHsmKeyAttributes`-Zuordnungsobjekt für diesen Schlüssel verwenden. Verwenden Sie die `getPublic()`-Methode, um die Attributzuordnung für den öffentlichen Schlüssel abzurufen, und die `getPrivate()`-Methode, um die Attributzuordnung für den privaten Schlüssel abzurufen. Geben Sie den Wert mehrerer Schlüsselattribute für öffentliche und private Schlüsselpaare zusammen ein, indem Sie die `putAll()`-Methode für eine Attributzuordnung von Schlüsselpaaren als Argument verwenden. ### Beispiel für Builder-Muster Entwickler finden es im Allgemeinen bequemer, Schlüsselattribute über das Builder-Muster festzulegen. Beispiel: ``` import com.amazonaws.cloudhsm.CloudHsmKeyAttributes; import com.amazonaws.cloudhsm.CloudHsmKeyAttributesMap; import com.amazonaws.cloudhsm.CloudHsmKeyPairAttributesMap; //specify attributes up-front CloudHsmKeyAttributesMap keyAttributes = new CloudHsmKeyAttributesMap.Builder() .put(CloudHsmKeyAttributes.CKA_SIGN, false) .put(CloudHsmKeyAttributes.CKA_LABEL, "PublicCertSerial12345") .build(); CloudHsmKeyPairAttributesMap keyPairAttributes = new CloudHsmKeyPairAttributesMap.Builder() .withPublic(keyAttributes) .withPrivate( new CloudHsmKeyAttributesMap.Builder() //or specify them inline .put(CloudHsmKeyAttributes.CKA_LABEL, "PrivateCertSerial12345") .put (CloudHSMKeyAttributes.CKA_WRAP, FALSE) .build() ) .build(); ``` **Anmerkung** [Weitere Informationen zu dieser proprietären Erweiterung finden Sie im [Javadoc-Archiv und](https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Docs/CloudHsm_CustomKeyAttributes_Javadoc.zip) im Beispiel auf.](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/CustomKeyAttributesRunner.java) GitHub Um Javadoc zu erkunden, laden Sie das Archiv herunter und erweitern Sie es. ## Zusammenführung Gehen Sie folgendermaßen vor, um Schlüsselattribute für Ihre Schlüsselvorgänge festzulegen: 1. Instanziieren Sie `CloudHsmKeyAttributesMap` für symmetrische Schlüssel oder `CloudHsmKeyPairAttributesMap` für Schlüsselpaare. 1. Definieren Sie das Attributobjekt aus Schritt 1 mit den erforderlichen Schlüsselattributen und -werten. 1. Instanziieren Sie eine `Cavium*ParameterSpec`-Klasse, die Ihrem spezifischen Schlüsseltyp entspricht, und übergeben Sie dieses konfigurierte Attributeobjekt an seinen Konstruktor. 1. Übergeben Sie dieses `Cavium*ParameterSpec`-Objekt an eine entsprechende Crypto-Klasse oder -Methode. Als Referenz enthält die folgende Tabelle die `Cavium*ParameterSpec`-Klassen und -Methoden, die benutzerdefinierte Schlüsselattribute unterstützen. **** | Schlüsseltyp | Parameter-Spezifikationsklasse | Beispiel-Konstruktoren | | --- | --- | --- | | Basisklasse | CaviumKeyGenAlgorithmParameterSpec | CaviumKeyGenAlgorithmParameterSpec(CloudHsmKeyAttributesMap keyAttributesMap) | | DES | CaviumDESKeyGenParameterSpec | CaviumDESKeyGenParameterSpec(int keySize, byte[] iv, CloudHsmKeyAttributesMap keyAttributesMap) | | RSA | CaviumRSAKeyGenParameterSpec | CaviumRSAKeyGenParameterSpec(int keysize, BigInteger publicExponent, CloudHsmKeyPairAttributesMap keyPairAttributesMap) | | Secret | CaviumGenericSecretKeyGenParameterSpec | CaviumGenericSecretKeyGenParameterSpec(int size, CloudHsmKeyAttributesMap keyAttributesMap) | | AES | CaviumAESKeyGenParameterSpec | CaviumAESKeyGenParameterSpec(int keySize, byte[] iv, CloudHsmKeyAttributesMap keyAttributesMap) | | EC | CaviumECGenParameterSpec | CaviumECGenParameterSpec(String stdName, CloudHsmKeyPairAttributesMap keyPairAttributesMap) | ### Beispielcode: Generieren und Packen eines Schlüssels Diese kurzen Codebeispiele veranschaulichen die Schritte für zwei verschiedene Vorgänge: Schlüsselgenerierung und Schlüsselverpackung: ``` // Set up the desired key attributes KeyGenerator keyGen = KeyGenerator.getInstance("AES", "Cavium"); CaviumAESKeyGenParameterSpec keyAttributes = new CaviumAESKeyGenParameterSpec( 256, new CloudHsmKeyAttributesMap.Builder() .put(CloudHsmKeyAttributes.CKA_LABEL, "MyPersistentAESKey") .put(CloudHsmKeyAttributes.CKA_EXTRACTABLE, true) .put(CloudHsmKeyAttributes.CKA_TOKEN, true) .build() ); // Assume we already have a handle to the myWrappingKey // Assume we already have the wrappedBytes to unwrap // Unwrap a key using Custom Key Attributes CaviumUnwrapParameterSpec unwrapSpec = new CaviumUnwrapParameterSpec(myInitializationVector, keyAttributes); Cipher unwrapCipher = Cipher.getInstance("AESWrap", "Cavium"); unwrapCipher.init(Cipher.UNWRAP_MODE, myWrappingKey, unwrapSpec); Key unwrappedKey = unwrapCipher.unwrap(wrappedBytes, "AES", Cipher.SECRET_KEY); ``` # Codebeispiele für die AWS CloudHSM Softwarebibliothek für Java für Client SDK 3 Dieses Thema enthält Ressourcen und Informationen zu Java-Codebeispielen für das AWS CloudHSM Client SDK 3. ## Voraussetzungen Bevor Sie die Beispiele ausführen, müssen Sie die Umgebung einrichten: + Installieren und konfigurieren Sie den [Java Cryptographic Extension (JCE)-Anbieter](java-library-install.md#install-java-library) und das [AWS CloudHSM -Client-Paket](cmu-install-and-configure-client-linux.md). + Legen Sie einen gültigen [HSM-Benutzernahmen und ein Passwort fest](manage-hsm-users.md). Crypto-Benutzer (CU)-Berechtigungen sind ausreichend für diese Aufgaben. Ihre Anwendung verwendet diese Anmeldeinformationen, um sich für die einzelnen Beispiele beim HSM anzumelden. + Entscheiden Sie, wie Anmeldeinformationen für den [JCE-Anbieter](java-library-install.md#java-library-credentials) bereitgestellt werden sollen. ## Codebeispiele Die folgenden Codebeispiele zeigen Ihnen, wie Sie den [AWS CloudHSM JCE-Anbieter](java-library.md) verwenden, um grundlegende Aufgaben auszuführen. Weitere Codebeispiele finden Sie unter [GitHub](https://github.com/aws-samples/aws-cloudhsm-jce-examples/). + [Anmeldung bei einem HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java) + [Verwalten von Schlüsseln](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java) + [Generieren eines AES-Schlüssels](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/SymmetricKeys.java) + [Verschlüsseln und Entschlüsseln mit AES-GCM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/AESGCMEncryptDecryptRunner.java) + [Verschlüsseln und Entschlüsseln mit AES-CTR]( https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/AESCTREncryptDecryptRunner.java) + [Mit D3DES-ECB verschlüsseln und entschlüsseln]( https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/DESedeECBEncryptDecryptRunner.java)** siehe Hinweis [1](#java-samples-code-note-1)** + [Packen und Entpacken von Schlüsseln mit AES-GCM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/AESGCMWrappingRunner.java) + [Verpacken und Entpacken von Schlüsseln mit AES](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/AESWrappingRunner.java) + [Schlüssel mit RSA packen und entpacken](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/RSAWrappingRunner.java) + [Unterstützte Schlüsselattribute verwenden](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/CustomKeyAttributesRunner.java) + [Schlüssel im Schlüsselspeicher aufzählen](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/KeyStoreExampleRunner.java) + [ Verwenden des CloudHSM-Schlüsselspeichers](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/CloudHSMKeyStoreExampleRunner.java) + [Signieren von Nachrichten in einem Multi-Thread-Beispiel](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/SignThreadedRunner.java) + [Signieren und Verifizieren mit EC-Schlüsseln](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/ECOperationsRunner.java) [1] Gemäß den NIST-Richtlinien ist dies für Cluster im FIPS-Modus nach 2023 nicht zulässig. Für Cluster im Nicht-FIPS-Modus ist dies auch nach 2023 zulässig. Details dazu finden Sie unter [FIPS-140-Konformität: Mechanismus 2024 nicht mehr unterstützt](compliance-dep-notif.md#compliance-dep-notif-1). # AWS CloudHSM KeyStore Java-Klasse für Client SDK 3 **Die AWS CloudHSM `KeyStore` Klasse stellt einen speziellen PKCS12 Schlüsselspeicher bereit, der den Zugriff auf AWS CloudHSM Schlüssel über Anwendungen wie **Keytool** und Jarsigner ermöglicht.** Dieser Schlüsselspeicher kann Zertifikate zusammen mit Ihren Schlüsseldaten speichern und sie mit den in AWS CloudHSM gespeicherten Schlüsseldaten korrelieren. **Anmerkung** Da es sich bei Zertifikaten um öffentliche Informationen handelt und um die Speicherkapazität für kryptografische Schlüssel zu maximieren, wird das Speichern von Zertifikaten AWS CloudHSM nicht unterstützt. HSMs Die AWS CloudHSM `KeyStore` Klasse implementiert das `KeyStore` Service Provider Interface (SPI) der Java Cryptography Extension (JCE). [Weitere Informationen zur Verwendung `KeyStore` finden Sie unter Class. KeyStore](https://docs.oracle.com/javase/8/docs/api/java/security/KeyStore.html) ## Wählen Sie den entsprechenden Schlüsselspeicher für AWS CloudHSM Client SDK 3 Der AWS CloudHSM Java Cryptographic Extension (JCE) -Anbieter verfügt über einen standardmäßigen, schreibgeschützten Passthrough-Schlüsselspeicher, der alle Transaktionen an das HSM weiterleitet. Dieser Standardschlüsselspeicher unterscheidet sich von dem Spezialschlüsselspeicher. AWS CloudHSM KeyStore In den meisten Situationen erhalten Sie eine bessere Laufzeitleistung und mehr Durchsatz, wenn Sie den Standard verwenden. Sie sollten den nur AWS CloudHSM KeyStore für Anwendungen verwenden, bei denen Sie Unterstützung für Zertifikate und zertifikatsbasierte Operationen benötigen und zusätzlich wichtige Operationen an das HSM auslagern möchten. Obwohl beide Schlüsselspeicher den JCE-Anbieter für Operationen verwenden, sind sie unabhängige Entitäten und tauschen keine Informationen miteinander aus. Laden Sie den Standard-Schlüsselspeicher für Ihre Java-Anwendung wie folgt: ``` KeyStore ks = KeyStore.getInstance("Cavium"); ``` Laden Sie das spezielle CloudHSM KeyStore wie folgt: ``` KeyStore ks = KeyStore.getInstance("CloudHSM") ``` ## Initialisieren Sie das SDK 3 für den Client AWS CloudHSM KeyStore Melden Sie sich auf AWS CloudHSM KeyStore die gleiche Weise an, wie Sie sich beim JCE-Anbieter anmelden. Sie können entweder Umgebungsvariablen oder die Systemeigenschaftendatei verwenden, und Sie sollten sich anmelden, bevor Sie CloudHSM KeyStore verwenden. Ein Beispiel für die Anmeldung bei einem HSM mit dem JCE-Anbieter finden Sie unter [Anmeldung an HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java). Falls gewünscht, können Sie ein Passwort angeben, um die lokale PKCS12 Datei zu verschlüsseln, die Schlüsselspeicherdaten enthält. Wenn Sie den AWS CloudHSM Keystore erstellen, legen Sie das Passwort fest und geben es an, wenn Sie die Methoden load, set und get verwenden. Instanziieren Sie ein neues CloudHSM-Objekt KeyStore wie folgt: ``` ks.load(null, null); ``` Schreiben Sie Schlüsselspeicherdaten mit der `store`-Methode in eine Datei. Von da an können Sie den vorhandenen Schlüsselspeicher mit der `load`-Methode mit der Quelldatei und dem Passwort wie folgt laden: ``` ks.load(inputStream, password); ``` ## Verwenden Sie das SDK 3 für den Client AWS CloudHSM KeyStore AWS CloudHSM [Ein KeyStore CloudHSM-Objekt wird in der Regel über eine Drittanbieteranwendung wie [jarsigner](https://docs.oracle.com/javase/8/docs/technotes/tools/windows/jarsigner.html) oder keytool verwendet.](https://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html) Sie können auch direkt mit Code auf das Objekt zugreifen. AWS CloudHSM KeyStore entspricht der [KeyStoreJCE-Klassenspezifikation](https://docs.oracle.com/javase/8/docs/api/java/security/KeyStore.html) und bietet die folgenden Funktionen. + `load` Lädt den Schlüsselspeicher aus dem angegebenen Eingabe-Stream. Wenn beim Speichern des Schlüsselspeichers ein Passwort festgelegt wurde, muss dasselbe Passwort angegeben werden, damit das Laden erfolgreich ist. Setzen Sie beide Parameter auf null, um einen neuen leeren Schlüsselspeicher zu initialisieren. ``` KeyStore ks = KeyStore.getInstance("CloudHSM"); ks.load(inputStream, password); ``` + `aliases` Gibt eine Aufzählung der Aliasnamen aller Einträge in der angegebenen Schlüsselspeicherinstanz zurück. Zu den Ergebnissen gehören Objekte, die lokal in der PKCS12 Datei gespeichert sind, und Objekte, die sich auf dem HSM befinden. **Beispiel-Code:** ``` KeyStore ks = KeyStore.getInstance("CloudHSM"); for(Enumeration entry = ks.aliases(); entry.hasMoreElements();) { String label = entry.nextElement(); System.out.println(label); } ``` + `ContainsAlias` Gibt „true“ zurück, wenn der Schlüsselspeicher Zugriff auf mindestens ein Objekt mit dem angegebenen Alias hat. Der Schlüsselspeicher überprüft Objekte, die lokal in der PKCS12 Datei gespeichert sind, und Objekte, die sich auf dem HSM befinden. + `DeleteEntry` Löscht einen Zertifikatseintrag aus der lokalen PKCS12 Datei. Das Löschen von Schlüsseldaten, die in einem HSM gespeichert sind, wird mit dem nicht unterstützt. AWS CloudHSM KeyStore Sie können Schlüssel mit dem [Key\$1mgmt\$1util](https://docs.aws.amazon.com/cloudhsm/latest/userguide/key_mgmt_util.html)-Tool von CloudHSM löschen. + `GetCertificate` Gibt das Zertifikat zurück, das einem Alias zugeordnet ist, falls verfügbar. Wenn der Alias nicht existiert oder auf ein Objekt verweist, das kein Zertifikat ist, gibt die Funktion NULL zurück. ``` KeyStore ks = KeyStore.getInstance("CloudHSM"); Certificate cert = ks.getCertificate(alias) ``` + `GetCertificateAlias` Gibt den Namen (Alias) des ersten Schlüsselspeichereintrags zurück, dessen Daten mit dem angegebenen Zertifikat übereinstimmen. ``` KeyStore ks = KeyStore.getInstance("CloudHSM"); String alias = ks.getCertificateAlias(cert) ``` + `GetCertificateChain` Gibt die Zertifikatkette zurück, die dem angegebenen Alias zugeordnet ist. Wenn der Alias nicht existiert oder auf ein Objekt verweist, das kein Zertifikat ist, gibt die Funktion NULL zurück. + `GetCreationDate` Gibt das Erstellungsdatum des durch den angegebenen Alias identifizierten Eintrags zurück. Wenn kein Erstellungsdatum verfügbar ist, gibt die Funktion das Datum zurück, an dem das Zertifikat gültig wurde. + `GetKey` GetKey wird an das HSM übergeben und gibt ein Schlüsselobjekt zurück, das dem angegebenen Label entspricht. Da es das HSM `getKey` direkt abfragt, kann es für jeden Schlüssel auf dem HSM verwendet werden, unabhängig davon, ob er von der generiert wurde. KeyStore ``` Key key = ks.getKey(keyLabel, null); ``` + `IsCertificateEntry` Überprüft, ob der Eintrag mit dem angegebenen Alias einen Zertifikateintrag darstellt. + `IsKeyEntry` Überprüft, ob der Eintrag mit dem angegebenen Alias einen Schlüsseleintrag darstellt. Die Aktion durchsucht sowohl die PKCS12 Datei als auch das HSM nach dem Alias. + `SetCertificateEntry` Weist dem angegebenen Alias das angegebene Zertifikat zu. Wenn der angegebene Alias bereits verwendet wird, um einen Schlüssel oder ein Zertifikat zu identifizieren, wird ein `KeyStoreException` ausgelöst. Sie können JCE-Code verwenden, um das Schlüsselobjekt abzurufen, und dann die KeyStore `SetKeyEntry` Methode verwenden, um das Zertifikat dem Schlüssel zuzuordnen. + `SetKeyEntry` mit `byte[]`-Schlüssel **Diese API wird derzeit vom Client-SDK 3 nicht unterstützt.** + `SetKeyEntry` mit `Key`-Objekt Weist den angegebenen Schlüssel dem angegebenen Alias zu und speichert ihn im HSM. Wenn das `Key`-Objekt nicht vom Typ `CaviumKey` ist, wird der Schlüssel als extrahierbarer Sitzungsschlüssel in das HSM importiert. Wenn das `Key`-Objekt vom Typ `PrivateKey` ist, muss es von einer entsprechenden Zertifikatkette begleitet werden. Wenn der Alias bereits vorhanden ist, wird ein `SetKeyEntry`- Aufruf ausgelöst, und `KeyStoreException` verhindert, dass der Schlüssel überschrieben wird. Wenn der Schlüssel überschrieben werden muss, verwenden Sie hierfür KMU oder JCE. + `EngineSize` Gibt die Anzahl der Einträge im Schlüsselspeicher zurück. + `Store` Speichert den Schlüsselspeicher für den angegebenen Ausgabestrom als PKCS12 Datei und sichert ihn mit dem angegebenen Passwort. Darüber hinaus bleiben alle geladenen Schlüssel (die über `setKey`-Aufrufe gesetzt werden) bestehen.