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 5
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. Informationen zur Problembehandlung finden Sie unter. [Bekannte Probleme mit dem JCE SDK für AWS CloudHSM](ki-jce-sdk.md)
Informationen zur Verwendung von Client-SDK 3 finden Sie unter [Verwenden der vorherigen SDK-Version zum Arbeiten mit AWS CloudHSM](choose-client-sdk.md).
**Topics**
+ [Installieren Sie den JCE-Anbieter für AWS CloudHSM Client SDK 5](java-library-install_5.md)
+ [Unterstützte Schlüsseltypen für den JCE-Anbieter für AWS CloudHSM Client SDK 5](java-lib-keys_5.md)
+ [Grundlagen der Schlüsselverwaltung im JCE-Anbieter für AWS CloudHSM Client SDK 5](java-library-key-basics_5.md)
+ [Unterstützte Mechanismen für den JCE-Anbieter für AWS CloudHSM Client SDK 5](java-lib-supported_5.md)
+ [Unterstützte Java-Schlüsselattribute für AWS CloudHSM Client SDK 5](java-lib-attributes_5.md)
+ [Codebeispiele für die AWS CloudHSM Softwarebibliothek für Java für Client SDK 5](java-samples.md)
+ [AWS CloudHSM JCE-Anbieter Javadocs](java-javadocs_5.md)
+ [AWS CloudHSM KeyStore Java-Klasse für Client SDK 5](alternative-keystore_5.md)
+ [Erweiterte Konfigurationen für AWS CloudHSM JCE für Client SDK 5](java-lib-configs.md)
# Installieren Sie den JCE-Anbieter für AWS CloudHSM Client SDK 5
Der JCE-Anbieter für AWS CloudHSM Client SDK 5 ist mit OpenJDK 8, OpenJDK 11, OpenJDK 17, OpenJDK 21 und OpenJDK 25 kompatibel. Sie können beide von der [OpenJDK-Website](https://openjdk.java.net/) herunterladen.
Verwenden Sie die folgenden Abschnitte, um den Anbieter zu installieren und Anmeldeinformationen für ihn bereitzustellen.
**Anmerkung**
Um einen einzelnen HSM-Cluster mit Client-SDK 5 auszuführen, müssen Sie zunächst die Einstellungen für die Haltbarkeit von Client-Schlüsseln verwalten, indem Sie die Einstellung `disable_key_availability_check` auf `True` festlegen. Weitere Informationen finden Sie unter [Schlüsselsynchronisierung](manage-key-sync.md) und [Client-SDK-5-Configure-Tool](configure-sdk-5.md).
**Topics**
+ [Schritt 1: Installieren Sie den JCE-Anbieter](#install-java-library_5)
+ [Schritt 2: Geben Sie Anmeldeinformationen für den JCE-Anbieter ein](#java-library-credentials_5)
## Schritt 1: Installieren Sie den JCE-Anbieter
1. Verwenden Sie die folgenden Befehle, um den JCE-Anbieter herunterzuladen und zu installieren.
------
#### [ Amazon Linux 2023 ]
Installieren Sie den JCE-Anbieter für Amazon Linux 2023 auf der x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-jce-latest.amzn2023.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.amzn2023.x86_64.rpm
```
Installieren Sie den JCE-Anbieter für Amazon Linux 2023 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-jce-latest.amzn2023.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.amzn2023.aarch64.rpm
```
------
#### [ Amazon Linux 2 ]
Installieren Sie den JCE-Anbieter für Amazon Linux 2 auf der x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-jce-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el7.x86_64.rpm
```
Installieren Sie den JCE-Anbieter für Amazon Linux 2 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-jce-latest.el7.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el7.aarch64.rpm
```
------
#### [ RHEL 10 (10.0\$1) ]
Installieren Sie den JCE-Anbieter für RHEL 10 auf einer x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-jce-latest.el10.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el10.x86_64.rpm
```
Installieren Sie den JCE-Anbieter für RHEL 10 auf der Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-jce-latest.el10.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el10.aarch64.rpm
```
------
#### [ RHEL 9 (9.2\$1) ]
Installieren Sie den JCE-Anbieter für RHEL 9 (9.2\$1) auf der x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-jce-latest.el9.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el9.x86_64.rpm
```
Installieren Sie den JCE-Anbieter für RHEL 9 (9.2\$1) auf der folgenden Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-jce-latest.el9.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el9.aarch64.rpm
```
------
#### [ RHEL 8 (8.3\$1) ]
Installieren Sie den JCE-Anbieter für RHEL 8 auf einer x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-jce-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el8.x86_64.rpm
```
Installieren Sie den JCE-Anbieter für RHEL 8 auf der Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-jce-latest.el8.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el8.aarch64.rpm
```
------
#### [ Ubuntu 24.04 LTS ]
Installieren Sie den JCE-Anbieter für Ubuntu 24.04 LTS auf der x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-jce_latest_u24.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-jce_latest_u24.04_amd64.deb
```
Installieren Sie den JCE-Anbieter für Ubuntu 24.04 LTS auf der Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-jce_latest_u24.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-jce_latest_u24.04_arm64.deb
```
------
#### [ Ubuntu 22.04 LTS ]
Installieren Sie den JCE-Provider für Ubuntu 22.04 LTS auf der x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-jce_latest_u22.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-jce_latest_u22.04_amd64.deb
```
Installieren Sie den JCE-Provider für Ubuntu 22.04 LTS auf der Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-jce_latest_u22.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-jce_latest_u22.04_arm64.deb
```
------
#### [ Windows Server ]
Installieren Sie den JCE-Anbieter für Windows Server auf der x86\$164-Architektur, öffnen Sie ihn PowerShell als Administrator und führen Sie den folgenden Befehl aus:
```
PS C:\> wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Windows/AWSCloudHSMJCE-latest.msi -Outfile C:\AWSCloudHSMJCE-latest.msi
```
```
PS C:\> Start-Process msiexec.exe -ArgumentList '/i C:\AWSCloudHSMJCE-latest.msi /quiet /norestart /log C:\client-install.txt' -Wait
```
------
1. Bootstrap für Client-SDK 5 Weitere Informationen zu Bootstrapping finden Sie unter [Bootstrap für das Client-SDK](cluster-connect.md#connect-how-to).
1. Suchen Sie die folgenden JCE-Anbieter-Dateien:
------
#### [ Linux ]
+ `/opt/cloudhsm/java/cloudhsm-.jar`
+ `/opt/cloudhsm/bin/configure-jce`
+ `/opt/cloudhsm/bin/jce-info`
------
#### [ Windows ]
+ `C:\Program Files\Amazon\CloudHSM\java\cloudhsm-.jar>`
+ `C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe`
+ `C:\Program Files\Amazon\CloudHSM\bin\jce_info.exe`
------
## Schritt 2: Geben Sie Anmeldeinformationen für den JCE-Anbieter ein
Bevor Ihre Java-Anwendung ein HSM verwenden kann, muss das HSM die Anwendung zuerst authentifizieren. HSMs authentifizieren Sie sich entweder mit einer expliziten oder einer impliziten Anmeldemethode.
**Explizite Anmeldemethode** – Mit dieser Methode können Sie AWS CloudHSM -Anmeldeinformationen direkt in der Anwendung bereitstellen. Es verwendet die Methode aus dem [https://docs.oracle.com/javase/8/docs/api/java/security/AuthProvider.html](https://docs.oracle.com/javase/8/docs/api/java/security/AuthProvider.html), bei der Sie einen CU-Benutzernamen und ein Passwort im Pin-Muster übergeben. Weitere Informationen finden Sie unter Codebeispiel für [Anmeldung bei einem HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java).
**Implizite Anmeldemethode** – Mit dieser Methode können Sie AWS CloudHSM -Anmeldeinformationen entweder in einer neuen Property-Datei, über Systemeigenschaften oder als Umgebungsvariablen festlegen.
+ **Systemeigenschaften** – Anmeldeinformationen über Systemeigenschaften fest, wenn Sie Ihre Anwendung ausführen. Die folgenden Beispiele zeigen zwei verschiedene Möglichkeiten:
------
#### [ Linux ]
```
$ java -DHSM_USER= -DHSM_PASSWORD=
```
```
System.setProperty("HSM_USER","");
System.setProperty("HSM_PASSWORD","");
```
------
#### [ Windows ]
```
PS C:\> java -DHSM_USER= -DHSM_PASSWORD=
```
```
System.setProperty("HSM_USER","");
System.setProperty("HSM_PASSWORD","");
```
------
+ **Umgebungsvariablen** – Anmeldeinformationen als Umgebungsvariablen festlegen.
**Anmerkung**
Beim Setzen von Umgebungsvariablen müssen Sie alle Sonderzeichen maskieren, die von Ihrer Shell interpretiert werden könnten.
------
#### [ Linux ]
```
$ export HSM_USER=
$ export HSM_PASSWORD=
```
------
#### [ Windows ]
```
PS C:\> $Env:HSM_USER=""
PS C:\> $Env: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. Systemeigenschaften
1. Umgebungsvariablen
# Unterstützte Schlüsseltypen für den JCE-Anbieter für AWS CloudHSM Client SDK 5
Mit der AWS CloudHSM Softwarebibliothek für Java können Sie die folgenden Schlüsseltypen generieren.
****
| Schlüsseltyp | Description |
| --- | --- |
| AES | Generieren der 128-, 192- und 256-Bit-AES-Schlüssel. |
| Dreifaches DES (3DES, DESede) | Generieren Sie einen 192-Bit-Triple-DES-Schlüssel. [*](#java-lib-keys_5-note-1) |
| EC | Generieren Sie EC-Schlüsselpaare – die NIST-Kurven secp224r1 (P-224), secp256r1 (P-256), secp256k1 (Blockchain), secp384r1 (P-384) und secp521r1 (P-521). |
| GENERIC\$1SECRET | Generieren Sie generische Geheimnisse mit 1 bis 800 Byte. |
| HMAC | Hash-Unterstützung für SHA1,, SHA224, SHA256, SHA384. SHA512 |
| RSA | Generieren Sie RSA-Schlüssel mit 2048 bis 4096 Bit, in Schritten von 256 Bit. |
\$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).
# Grundlagen der Schlüsselverwaltung im JCE-Anbieter für AWS CloudHSM Client SDK 5
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/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java).
Weitere Codebeispiele für JCE-Anbieter finden Sie auch in [Codebeispiele](java-samples.md).
# Unterstützte Mechanismen für den JCE-Anbieter für AWS CloudHSM Client SDK 5
Dieses Thema enthält Informationen zu den unterstützten Mechanismen für den JCE-Anbieter mit dem AWS CloudHSM Client-SDK 5. 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**
+ [Schlüssel- und Schlüsselpaarfunktionen generieren](#java-gen-key-pairs-5)
+ [Cipher-Funktionen](#java-ciphers_5)
+ [Funktionen zum Signieren und Überprüfen](#java-sign-verify_5)
+ [Digest-Funktionen](#java-digests_5)
+ [Funktionen des Hash-basierten Nachrichtenauthentifizierungscodes (HMAC)](#java-mac_5)
+ [Funktionen des verschlüsselten Nachrichtenauthentifizierungscodes (CMAC)](#java-cmac_5)
+ [Die wichtigsten Funktionen der Vereinbarung](#java-key-derivation_5)
+ [Mithilfe von Schlüsselfabriken können Schlüssel in Schlüsselspezifikationen umgewandelt werden](#java-key-factories)
+ [Anmerkungen zum Mechanismus](#w2aac25c21c25c15c23)
## Schlüssel- und Schlüsselpaarfunktionen generieren
Die AWS CloudHSM Softwarebibliothek für Java ermöglicht es Ihnen, die folgenden Operationen zum Generieren von Schlüssel- und Schlüsselpaarfunktionen zu verwenden.
+ `RSA`
+ `EC`
+ `AES`
+ `DESede (Triple DES)`siehe Hinweis [1](#java-gen-key-pairs-5-note-1)
+ `GenericSecret`
## Cipher-Funktionen
Die AWS CloudHSM Softwarebibliothek für Java unterstützt die folgenden Kombinationen aus Algorithmus, Modus und Auffüllung.
| Algorithmus | Mode | Padding | Hinweise |
| --- | --- | --- | --- |
| AES | CBC | `AES/CBC/NoPadding` `AES/CBC/PKCS5Padding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. Implementiert `Cipher.UNWRAP_MODE for AES/CBC NoPadding` |
| AES | ECB | `AES/ECB/PKCS5Padding` `AES/ECB/NoPadding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. |
| AES | CTR | `AES/CTR/NoPadding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. |
| AES | GCM | `AES/GCM/NoPadding` | Implementiert `Cipher.WRAP_MODE`, `Cipher.UNWRAP_MODE`, `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_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/NoPadding` `AESWrap/ECB/PKCS5Padding` `AESWrap/ECB/ZeroPadding` | Implementiert `Cipher.WRAP_MODE` und `Cipher.UNWRAP_MODE`. |
| DESede (Dreifaches DES) | CBC | `DESede/CBC/PKCS5Padding` `DESede/CBC/NoPadding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. Eine bevorstehende Änderung finden Sie im Hinweis [1](#java-gen-key-pairs-5-note-1) unten. |
| DESede (Dreifaches DES) | ECB | `DESede/ECB/NoPadding` `DESede/ECB/PKCS5Padding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. Eine bevorstehende Änderung finden Sie im Hinweis [1](#java-gen-key-pairs-5-note-1) unten. |
| RSA | ECB | `RSA/ECB/PKCS1Padding` **siehe Hinweis [1](#java-gen-key-pairs-5-note-1)** `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.WRAP_MODE`, `Cipher.UNWRAP_MODE`, `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. |
| RSA | ECB | `RSA/ECB/NoPadding` | Implementiert `Cipher.ENCRYPT_MODE` und `Cipher.DECRYPT_MODE`. |
| RSAAESWrap | ECB | `RSAAESWrap/ECB/OAEPPadding` `RSAAESWrap/ECB/OAEPWithSHA-1ANDMGF1Padding` `RSAAESWrap/ECB/OAEPWithSHA-224ANDMGF1Padding` `RSAAESWrap/ECB/OAEPWithSHA-256ANDMGF1Padding` `RSAAESWrap/ECB/OAEPWithSHA-384ANDMGF1Padding` `RSAAESWrap/ECB/OAEPWithSHA-512ANDMGF1Padding` | Implementiert `Cipher.WRAP_MODE` und `Cipher.UNWRAP_MODE`. |
## Funktionen zum Signieren und Überprüfen
Die AWS CloudHSM Softwarebibliothek für Java unterstützt die folgenden Arten der Signatur und Überprüfung. Mit Client-SDK 5 und Signaturalgorithmen mit Hashing werden die Daten lokal in der Software gehasht, bevor sie zur Signatur/Überprüfung an das HSM gesendet werden. Das bedeutet, dass die Größe der Daten, die vom SDK gehasht werden können, unbegrenzt ist.
**RSA-Signaturtypen**
+ `NONEwithRSA`
+ `RSASSA-PSS`
+ `SHA1withRSA`
+ `SHA1withRSA/PSS`
+ `SHA1withRSAandMGF1`
+ `SHA224withRSA`
+ `SHA224withRSAandMGF1`
+ `SHA224withRSA/PSS`
+ `SHA256withRSA`
+ `SHA256withRSAandMGF1`
+ `SHA256withRSA/PSS`
+ `SHA384withRSA`
+ `SHA384withRSAandMGF1`
+ `SHA384withRSA/PSS`
+ `SHA512withRSA`
+ `SHA512withRSAandMGF1`
+ `SHA512withRSA/PSS`
**ECDSA-Signaturtypen**
+ `NONEwithECDSA`
+ `SHA1withECDSA`
+ `SHA224withECDSA`
+ `SHA256withECDSA`
+ `SHA384withECDSA`
+ `SHA512withECDSA`
## Digest-Funktionen
Die AWS CloudHSM Softwarebibliothek für Java unterstützt die folgenden Message Digests. Mit Client-SDK 5 werden die Daten lokal in der Software gehasht. Das bedeutet, dass die Größe der Daten, die vom SDK gehasht werden können, unbegrenzt ist.
+ `SHA-1`
+ `SHA-224`
+ `SHA-256`
+ `SHA-384`
+ `SHA-512`
## Funktionen des Hash-basierten Nachrichtenauthentifizierungscodes (HMAC)
Die AWS CloudHSM Softwarebibliothek für Java unterstützt die folgenden HMAC-Algorithmen.
+ `HmacSHA1`(Maximale Datengröße in Byte: 16288)
+ `HmacSHA224`(Maximale Datengröße in Byte: 16256)
+ `HmacSHA256`(Maximale Datengröße in Byte: 16288)
+ `HmacSHA384`(Maximale Datengröße in Byte: 16224)
+ `HmacSHA512`(Maximale Datengröße in Byte: 16224)
## Funktionen des verschlüsselten Nachrichtenauthentifizierungscodes (CMAC)
CMACs (Verschlüsselungsbasierte Nachrichtenauthentifizierungscodes) Erstellen Sie Nachrichtenauthentifizierungscodes (MACs) mithilfe einer Blockchiffre und eines geheimen Schlüssels. Sie unterscheiden HMACs sich dadurch, dass sie eine blocksymmetrische Schlüsselmethode anstelle einer Hashing-Methode verwenden. MACs
Die AWS CloudHSM Softwarebibliothek für Java unterstützt die folgenden CMAC-Algorithmen.
+ `AESCMAC`
## Die wichtigsten Funktionen der Vereinbarung
Die AWS CloudHSM Softwarebibliothek für Java unterstützt ECDH mit Key Derivation Functions (KDF). Die folgenden KDF-Typen werden unterstützt:
+ `ECDHwithX963SHA1KDF`Unterstützt den X9.63 KDF-Algorithmus SHA1 [2](#kdf2)
+ `ECDHwithX963SHA224KDF`Unterstützt den X9.63 KDF-Algorithmus SHA224 [2](#kdf2)
+ `ECDHwithX963SHA256KDF`Unterstützt den X9.63 KDF-Algorithmus SHA256 [2](#kdf2)
+ `ECDHwithX963SHA384KDF`Unterstützt den X9.63 KDF-Algorithmus SHA384 [2](#kdf2)
+ `ECDHwithX963SHA512KDF`Unterstützt den X9.63 KDF-Algorithmus SHA512 [2](#kdf2)
## Mithilfe von Schlüsselfabriken können Schlüssel in Schlüsselspezifikationen umgewandelt werden
Sie können Key Factorys verwenden, um Schlüssel in Schlüsselspezifikationen umzuwandeln. AWS CloudHSM hat zwei Arten von Schlüsselfabriken für JCE:
**SecretKeyFactory:** Wird verwendet, um symmetrische Schlüssel zu importieren oder abzuleiten. Mithilfe SecretKeyFactory können Sie einen unterstützten Schlüssel oder einen unterstützten Schlüssel übergeben, in KeySpec den symmetrische Schlüssel importiert oder abgeleitet werden sollen. AWS CloudHSM Im Folgenden finden Sie die unterstützten Spezifikationen für: KeyFactory
+ Für die `generateSecret` Methode SecretKeyFactory von For werden die folgenden [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)Klassen unterstützt:
+ **KeyAttributesMap**kann verwendet werden, um Schlüsselbytes mit zusätzlichen Attributen als CloudHSM-Schlüssel zu importieren. Ein Beispiel finden Sie [hier](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java).
+ **[SecretKeySpec](https://docs.oracle.com/javase/8/docs/api/javax/crypto/spec/SecretKeySpec.html)**kann verwendet werden, um eine symmetrische Schlüsselspezifikation als CloudHSM-Schlüssel zu importieren.
+ **AesCmacKdfParameterSpec**kann verwendet werden, um symmetrische Schlüssel mit einem anderen CloudHSM AES-Schlüssel abzuleiten.
**Anmerkung**
SecretKeyFactory[Die `translateKey` Methode verwendet jeden Schlüssel, der die Schlüsselschnittstelle implementiert.](https://docs.oracle.com/javase/8/docs/api/java/security/Key.html)
**KeyFactory:** Wird für den Import asymmetrischer Schlüssel verwendet. Mithilfe KeyFactory können Sie einen unterstützten Schlüssel oder einen unterstützten Schlüssel übergeben, in KeySpec den ein asymmetrischer Schlüssel importiert werden soll. AWS CloudHSM Weitere Informationen finden Sie in folgenden verwandten Ressourcen:
+ Für die `generatePublic` Methode KeyFactory von For werden die folgenden [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)Klassen unterstützt:
+ CloudHSM KeyAttributesMap für RSA und EC KeyTypes, einschließlich:
+ CloudHSM KeyAttributesMap für RSA und EC public. KeyTypes Ein Beispiel finden Sie [hier](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java).
+ [X509 EncodedKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/X509EncodedKeySpec.html) für RSA und EC Public Key
+ [RSAPublicKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/RSAPublicKeySpec.html)für RSA Public Key
+ [ECPublicKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/ECPublicKeySpec.html)für EC Public Key
+ Für die `generatePrivate` Methode KeyFactory von For werden die folgenden [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)Klassen unterstützt:
+ CloudHSM KeyAttributesMap für RSA und EC KeyTypes, einschließlich:
+ CloudHSM KeyAttributesMap für RSA und EC public. KeyTypes Ein Beispiel finden Sie [hier](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java).
+ [PKCS8EncodedKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/PKCS8EncodedKeySpec.html)sowohl für EC als auch für RSA Private Key
+ [RSAPrivateCrtKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/RSAPrivateCrtKeySpec.html)für RSA Private Key
+ [ECPrivateKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/ECPrivateKeySpec.html)für privaten EC-Schlüssel
KeyFactoryDie `translateKey` Methode von For nimmt jeden Schlüssel auf, der das [Key Interface](https://docs.oracle.com/javase/8/docs/api/java/security/Key.html) implementiert.
## 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).
[2] Die wichtigsten Ableitungsfunktionen (KDFs) sind in der [NIST-Sonderveröffentlichung](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar3.pdf) 800-56A Revision 3 spezifiziert.
# Unterstützte Java-Schlüsselattribute für AWS CloudHSM Client SDK 5
Dieses Thema enthält Informationen zu unterstützten Java-Schlüsselattributen für das AWS CloudHSM Client SDK 5. Dieses Thema beschreibt, wie Sie eine proprietäre Erweiterung für den JCE-Anbieter verwenden, um Schlüsselattribute festzulegen. Verwenden Sie diese Erweiterung, um unterstützte Schlüsselattribute und ihre Werte während der folgenden Vorgänge festzulegen:
+ Schlüsselgenerierung
+ Schlüsselimport
Beispiele für die Verwendung von Schlüsselattributen finden Sie unter [Codebeispiele für die AWS CloudHSM Softwarebibliothek für Java für Client SDK 5](java-samples.md).
**Topics**
+ [Grundlegendes zu Attributen](#java-understanding-attributes_5)
+ [Unterstützte Attribute](#java-attributes_5)
+ [Festlegen von Attributen für einen Schlüssel](#java-setting-attributes_5)
## 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 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 dem JCE-Anbieter 3.1 steht eine proprietäre Erweiterung AWS CloudHSM zur Verfügung, 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, wird der in der Tabelle unten angegebene Standardwert AWS CloudHSM verwendet. 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 | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| DECRYPT | 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 WRAP auf wahr festgelegt ist. |
| DERIVE | | | | Ermöglicht die Verwendung eines Schlüssels zur Ableitung anderer Schlüssel. |
| ENCRYPT | TRUE | TRUE | | „True“ gibt an, dass Sie den Schlüssel zur Verschlüsselung eines beliebigen Puffers verwenden können. |
| EXTRACTABLE | TRUE | | TRUE | „True“ gibt an, dass Sie diesen Schlüssel aus dem HSM exportieren können. |
| ID | | | | Ein benutzerdefinierter Wert, der zur Identifizierung des Schlüssels verwendet wird. |
| KEY\$1TYPE | | | | Wird verwendet, um den Schlüsseltyp zu identifizieren (AES DESede, generisches Geheimnis, EC oder RSA). |
| LABEL | | | | Eine benutzerdefinierte Zeichenfolge, mit der Sie Schlüssel auf Ihrem HSM bequem identifizieren können. Um den bewährten Methoden zu folgen, verwenden Sie für jeden Schlüssel eine eindeutige Bezeichnung, damit er später leichter zu finden ist. |
| LOCAL | | | | Weist auf einen vom HSM generierten Schlüssel hin. |
| OBJECT\$1CLASS | | | | Wird verwendet, um die Objektklasse eines Schlüssels (SecretKey, PublicKey oder PrivateKey) zu identifizieren. |
| PRIVATE | TRUE | TRUE | TRUE | „True“ gibt an, dass ein Benutzer erst auf den Schlüssel zugreifen darf, wenn der Benutzer authentifiziert ist. Aus Gründen der Übersichtlichkeit können Benutzer AWS CloudHSM erst auf Schlüssel zugreifen, wenn sie authentifiziert wurden, auch wenn dieses Attribut auf FALSE gesetzt ist. |
| SIGN | 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. |
| SIZE | | | | Ein Attribut, das die Größe eines Schlüssels definiert. Weitere Informationen zu den unterstützten Schlüsselgrößen finden Sie unter [Unterstützte Mechanismen für das Client-SDK 5.](https://docs.aws.amazon.com/cloudhsm/latest/userguide/java-lib-supported_5.html#java-keys_5) |
| TOKEN | FALSE | FALSE | FALSE | Ein permanenter Schlüssel, der HSMs im gesamten Cluster repliziert und in Backups enthalten ist. TOKEN = FALSCH impliziert einen flüchtigen Schlüssel, der automatisch gelöscht wird, wenn die Verbindung zum HSM unterbrochen oder abgemeldet wird. |
| UNWRAP | TRUE | | TRUE | „True“ gibt an, dass Sie mit dem Schlüssel einen anderen Schlüssel entpacken (importieren) können. |
| VERIFY | 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. |
| WRAP | 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. |
| WRAP\$1WITH\$1TRUSTED | FALSE | | FALSE | Wahr bedeutet, dass ein Schlüssel nur mit Schlüsseln, deren TRUSTED-Attribut auf wahr gesetzt ist, ein- und ausgepackt werden kann. Sobald bei einem Schlüssel WRAP\$1WITH\$1TRUSTED auf wahr gesetzt wurde, ist dieses Attribut schreibgeschützt und kann nicht auf Falsch gesetzt werden. Weitere Informationen zum Trust-Wrapping finden Sie unter [Verwenden vertrauenswürdiger Schlüssel zur Steuerung von Schlüssel-Unwraps](https://docs.aws.amazon.com/cloudhsm/latest/userguide/cloudhsm_using_trusted_keys_control_key_wrap.html). |
**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
`KeyAttributesMap` ist ein Java-Map-ähnliches Objekt, mit dem Sie Attributwerte für Schlüsselobjekte festlegen können. Die Methoden für `KeyAttributesMap` 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 | `KeyAttributesMap`-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_5) aufgeführt sind.
### Festlegen von Attributen für ein Schlüsselpaar
Verwenden Sie die Java-Klasse `KeyPairAttributesMap`, um Schlüsselattribute für ein Schlüsselpaar zu verarbeiten. `KeyPairAttributesMap` fasst zwei `KeyAttributesMap`-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 `KeyAttributes`-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.
# Codebeispiele für die AWS CloudHSM Softwarebibliothek für Java für Client SDK 5
Dieses Thema enthält Ressourcen und Informationen zu Java-Codebeispielen für das AWS CloudHSM Client SDK 5.
## Voraussetzungen
Bevor Sie die Beispiele ausführen, müssen Sie die Umgebung einrichten:
+ Installieren und konfigurieren Sie den [Java Cryptographic Extension (JCE)](java-library-install_5.md#install-java-library_5)-Anbieter.
+ 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_5.md#java-library-credentials_5) 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/tree/sdk5).
+ [Anmeldung bei einem HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java)
+ [Verwalten von Schlüsseln](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java)
+ [Generieren von symmetrischen Schlüsseln](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/SymmetricKeys.java)
+ [Generieren von asymmetrischen Schlüsseln](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AsymmetricKeys.java)
+ [Verschlüsseln und Entschlüsseln mit AES-GCM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/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/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AESCTREncryptDecryptRunner.java)
+ [Mit DESede -ECB verschlüsseln und entschlüsseln](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/DESedeECBEncryptDecryptRunner.java), siehe Hinweis [1](#java-samples-code-5-note-1)
+ [Signieren und Verifizieren mit RSA-Schlüsseln](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/RSAOperationsRunner.java)
+ [Signieren und Verifizieren mit EC-Schlüsseln](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/ECOperationsRunner.java)
+ [Unterstützte Schlüsselattribute verwenden](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyAttributesRunner.java)
+ [Verwenden des CloudHSM-Schlüsselspeichers](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyStoreExampleRunner.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 JCE-Anbieter Javadocs
Verwenden Sie den JCE-Anbieter Javadocs, um Nutzungsinformationen zu Java-Typen und -Methoden abzurufen, die im AWS CloudHSM JCE SDK definiert sind. Informationen zum Herunterladen der neuesten Javadocs für AWS CloudHSM finden Sie im [AWS CloudHSM neueste Version des Client-SDK](latest-releases.md) Abschnitt auf der Download-Seite.
Sie können Javadocs in eine integrierte Entwicklungsumgebung (IDE) importieren oder sie in einem Webbrowser anzeigen.
# AWS CloudHSM KeyStore Java-Klasse für Client SDK 5
Die AWS CloudHSM `KeyStore` Klasse stellt einen PKCS12 Schlüsselspeicher für spezielle Zwecke bereit. Dieser Schlüsselspeicher kann Zertifikate zusammen mit Ihren Schlüsseldaten speichern und sie mit den in AWS CloudHSM gespeicherten Schlüsseldaten korrelieren. 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://devdocs.io/openjdk~8/java/security/keystore)
**Anmerkung**
Da es sich bei Zertifikaten um öffentliche Informationen handelt und um die Speicherkapazität für kryptografische Schlüssel zu maximieren, AWS CloudHSM wird das Speichern von Zertifikaten auf HSMs nicht unterstützt.
## Wählen Sie den entsprechenden Schlüsselspeicher für AWS CloudHSM Client SDK 5
Der Anbieter AWS CloudHSM Java Cryptographic Extension (JCE) bietet ein spezielles AWS CloudHSM an. KeyStore Die AWS CloudHSM `KeyStore` Klasse unterstützt das Auslagern wichtiger Operationen in das HSM, die lokale Speicherung von Zertifikaten und zertifikatsbasierte Operationen.
Laden Sie das spezielle CloudHSM KeyStore wie folgt:
```
KeyStore ks = KeyStore.getInstance("CloudHSM")
```
## Initialisieren Sie das Client-SDK 5 AWS CloudHSM KeyStore
Melden Sie sich genauso AWS CloudHSM KeyStore 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/sdk5/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 unser Client SDK 5 AWS CloudHSM KeyStore AWS CloudHSM
AWS CloudHSM KeyStore entspricht der [KeyStoreJCE-Klassenspezifikation](https://devdocs.io/openjdk~8/java/security/keystore) 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 der `destroy`-Methode der [Destroyable](https://devdocs.io/openjdk~8/javax/security/auth/destroyable#destroy--)-Schnittstelle löschen.
```
((Destroyable) key).destroy();
```
+ `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 5 nicht unterstützt.**
+ `setKeyEntry` mit `Key`-Objekt
Weist den angegebenen Schlüssel dem angegebenen Alias zu und speichert ihn im HSM. Wenn der Schlüssel noch nicht im HSM vorhanden ist, wird er 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.
# Erweiterte Konfigurationen für AWS CloudHSM JCE für Client SDK 5
Der AWS CloudHSM JCE-Anbieter umfasst die folgenden erweiterten Konfigurationen, die nicht Teil der allgemeinen Konfigurationen sind, die die meisten Kunden verwenden.
+ [Verbindung zu mehreren Clustern herstellen](java-lib-configs-multi.md)
+ [Schlüsselextraktion mit JCE](java-lib-configs-getencoded.md)
+ [Versuchen Sie erneut, die Konfiguration für JCE zu konfigurieren](java-lib-configs-retry.md)
# Verbindung zu mehreren AWS CloudHSM Clustern mit dem JCE-Anbieter herstellen
Diese Konfiguration ermöglicht es einer einzelnen Client-Instance, mit mehreren AWS CloudHSM Clustern zu kommunizieren. Wenn Sie eine einzelne Instance haben, die nur mit einem einzigen Cluster kommuniziert, kann diese Konfiguration in einigen Anwendungsfällen zu Kosteneinsparungen führen. Die `CloudHsmProvider` Klasse AWS CloudHSM ist die Implementierung der [Provider-Klasse von Java Security](https://docs.oracle.com/javase/8/docs/api/java/security/Provider.html). Jede Instanz dieser Klasse stellt eine Verbindung zu Ihrem gesamten AWS CloudHSM Cluster dar. Sie instanziieren diese Klasse und fügen sie der Liste der Java-Security-Anbieter hinzu, sodass Sie mit ihr über Standard-JCE-Klassen interagieren können.
Das folgende Beispiel instanziiert diese Klasse und fügt sie der Liste der Java-Security-Anbieter hinzu:
```
if (Security.getProvider(CloudHsmProvider.PROVIDER_NAME) == null) {
Security.addProvider(new CloudHsmProvider());
}
```
`CloudHsmProvider` kann auf zwei Arten konfiguriert werden:
1. Mit Datei konfigurieren (Standardkonfiguration)
1. Mit Code konfigurieren
In den folgenden Themen werden diese Konfigurationen und das Herstellen einer Verbindung zu mehreren Clustern beschrieben.
**Topics**
+ [Konfigurieren Sie die AWS CloudHSM `CloudHsmProvider` Klasse mit einer Datei (Standardkonfiguration)](java-lib-configs-default.md)
+ [Konfigurieren Sie die AWS CloudHSM `CloudHsmProvider` Klasse mithilfe von Code](java-lib-configs-using-code.md)
+ [Connect zu mehreren AWS CloudHSM Clustern her](java-lib-connecting-to-multiclusters.md)
# Konfigurieren Sie die AWS CloudHSM `CloudHsmProvider` Klasse mit einer Datei (Standardkonfiguration)
Die AWS CloudHSM `CloudHsmProvider` Klasse wird standardmäßig mit einer Datei konfiguriert.
Wenn Sie `CloudHsmProvider` mit dem Standardkonstruktor instanziieren, sucht er unter Linux standardmäßig nach einer Konfigurationsdatei im `/opt/cloudhsm/etc/cloudhsm-jce.cfg`-Pfad. Diese Konfigurationsdatei kann mit der Datei `configure-jce` konfiguriert werden.
Ein mit dem Standardkonstruktor erstelltes Objekt verwendet den standardmäßigen CloudHSM-Anbieternamen `CloudHSM`. Der Anbietername ist nützlich, um mit JCE zu interagieren und ihm mitzuteilen, welcher Anbieter für verschiedene Operationen verwendet werden soll. Ein Beispiel für die Verwendung des CloudHSM-Anbieternamens für den Chiffriervorgang lautet wie folgt:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "CloudHSM");
```
# Konfigurieren Sie die AWS CloudHSM `CloudHsmProvider` Klasse mithilfe von Code
Ab Version 5.8.0 des Client SDK können Sie die AWS CloudHSM `CloudHsmProvider` Klasse auch mithilfe von Java-Code konfigurieren. Dazu verwenden Sie ein Objekt der `CloudHsmProviderConfig`-Klasse. Sie können `CloudHsmProviderConfigBuilder` verwenden, um dieses Objekt zu erstellen.
`CloudHsmProvider` hat einen anderen Konstruktor, der das `CloudHsmProviderConfig`-Objekt aufnimmt, wie das folgende Beispiel zeigt.
**Example**
```
CloudHsmProviderConfig config = CloudHsmProviderConfig.builder()
.withCluster(
CloudHsmCluster.builder()
.withHsmCAFilePath(hsmCAFilePath)
.withClusterUniqueIdentifier("CloudHsmCluster1")
.withServer(CloudHsmServer.builder().withHostIP(hostName).build())
.build())
.build();
CloudHsmProvider provider = new CloudHsmProvider(config);
```
In diesem Beispiel lautet der Name des JCE-Anbieters. `CloudHsmCluster1` Dies ist der Name, den die Anwendung dann verwenden kann, um mit JCE zu interagieren:
**Example**
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "CloudHsmCluster1");
```
Alternativ können Anwendungen auch das oben erstellte Anbieter-Objekt verwenden, um JCE mitzuteilen, dass es diesen Anbieter für die Operation verwenden soll:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider);
```
Wenn mit der `withClusterUniqueIdentifier`-Methode kein eindeutiger Bezeichner angegeben wird, wird ein zufällig generierter Anbietername für Sie erstellt. Um diesen zufällig generierten Bezeichner zu erhalten, können Anwendungen `provider.getName()` aufrufen, um den Bezeichner abzurufen.
# Connect zu mehreren AWS CloudHSM Clustern her
Jedes `CloudHsmProvider` steht für eine Verbindung zu Ihrem AWS CloudHSM Cluster. Wenn Sie mit einem anderen Cluster aus derselben Anwendung kommunizieren möchten, können Sie ein anderes Objekt von `CloudHsmProvider` mit Konfigurationen für Ihren anderen Cluster erstellen und mit diesem anderen Cluster entweder über das Anbieterobjekt oder über den Anbieternamen interagieren, wie im folgenden Beispiel gezeigt.
**Example**
```
CloudHsmProviderConfig config = CloudHsmProviderConfig.builder()
.withCluster(
CloudHsmCluster.builder()
.withHsmCAFilePath(hsmCAFilePath)
.withClusterUniqueIdentifier("CloudHsmCluster1")
.withServer(CloudHsmServer.builder().withHostIP(hostName).build())
.build())
.build();
CloudHsmProvider provider1 = new CloudHsmProvider(config);
if (Security.getProvider(provider1.getName()) == null) {
Security.addProvider(provider1);
}
CloudHsmProviderConfig config2 = CloudHsmProviderConfig.builder()
.withCluster(
CloudHsmCluster.builder()
.withHsmCAFilePath(hsmCAFilePath2)
.withClusterUniqueIdentifier("CloudHsmCluster2")
.withServer(CloudHsmServer.builder().withHostIP(hostName2).build())
.build())
.build();
CloudHsmProvider provider2 = new CloudHsmProvider(config2);
if (Security.getProvider(provider2.getName()) == null) {
Security.addProvider(provider2);
}
```
Nachdem Sie beide Anbieter (beide Cluster) oben konfiguriert haben, können Sie entweder über das Anbieterobjekt oder über den Anbieternamen mit ihnen interagieren.
Ausgehend von diesem Beispiel, das zeigt, wie man mit jemandem spricht`cluster1`, könnten Sie das folgende Beispiel für eine AES/GCM/NoPadding Operation verwenden:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider1);
```
Und in derselben Anwendung zur Generierung von „AES“-Schlüsseln auf dem zweiten Cluster mit dem Anbieternamen könnten Sie auch das folgende Beispiel verwenden:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider2.getName());
```
# Schlüsselextraktion mit JCE für AWS CloudHSM
Die Java Cryptography Extension (JCE) verwendet eine Architektur, mit der verschiedene Kryptografie-Implementierungen integriert werden können. AWS CloudHSM liefert einen solchen JCE-Anbieter aus, der kryptografische Operationen an das HSM auslagert. Damit die meisten anderen JCE-Anbieter mit Schlüsseln arbeiten können, die in AWS CloudHSM gespeichert sind, müssen sie die Schlüsselbytes von Ihnen HSMs im Klartext in den Speicher Ihres Computers extrahieren, damit sie sie verwenden können. HSMs Erlauben normalerweise nur das Extrahieren von Schlüsseln als verpackte Objekte, nicht als Klartext. Um Anwendungsfälle der anbieterübergreifenden Integration zu unterstützen, ist jedoch eine optionale Konfigurationsoption möglich, mit der die Extraktion der Schlüsselbytes im Klartext AWS CloudHSM ermöglicht wird.
**Wichtig**
JCE lagert Operationen immer dann aus, AWS CloudHSM wenn der AWS CloudHSM CloudHSM-Anbieter angegeben oder ein AWS CloudHSM Schlüsselobjekt verwendet wird. Sie müssen Schlüssel nicht im Klartext extrahieren, wenn Sie erwarten, dass Ihre Operation innerhalb des HSM stattfindet. Die Schlüsselextraktion im Klartext ist nur erforderlich, wenn Ihre Anwendung aufgrund von Einschränkungen durch eine Drittanbieterbibliothek oder einen JCE-Anbieter keine sicheren Mechanismen wie das sogenannte Wrapping und Unwrapping eines Schlüssels verwenden kann.
Der AWS CloudHSM JCE-Anbieter ermöglicht standardmäßig das Extrahieren von **öffentlichen Schlüsseln**, sodass er mit externen JCE-Anbietern funktioniert. Die folgenden Methoden sind immer zulässig:
| Klasse | Methode | Format (getEncoded) |
| --- | --- | --- |
| EcPublicKey | getEncoded() | X.509 |
| | getW() | – |
| RSAPublicSchlüssel | getEncoded() | X.509 |
| | getPublicExponent() | – |
| CloudHsmRsaPrivateCrtKey | getPublicExponent() | – |
Der AWS CloudHSM JCE-Anbieter erlaubt standardmäßig keine Extraktion von Schlüsselbytes im Klartext für **private** oder **geheime** Schlüssel. Wenn Ihr Anwendungsfall dies erfordert, können Sie die Extraktion von Schlüsselbytes im Klartext für **private** oder **geheime** Schlüssel unter den folgenden Bedingungen aktivieren:
1. Das `EXTRACTABLE`-Attribut für private und geheime Schlüssel ist auf **true** gesetzt.
+ Standardmäßig ist das `EXTRACTABLE`-Attribut für private und geheime Schlüssel auf **true** gesetzt. `EXTRACTABLE`-Schlüssel sind Schlüssel, die aus dem HSM exportiert werden dürfen. Weitere Informationen finden Sie unter Unterstützte Java-Attribute für [Client-SDK 5](java-lib-attributes_5.md).
1. Das `WRAP_WITH_TRUSTED`-Attribut für private und geheime Schlüssel ist auf **falsch** gesetzt.
+ `getEncoded`, `getPrivateExponent` und `getS` können nicht mit privaten Schlüsseln verwendet werden, die nicht in Klartext exportiert werden können. `WRAP_WITH_TRUSTED` erlaubt nicht, dass Ihre privaten Schlüssel in Klartext aus dem HSM exportiert werden. Weitere Informationen finden Sie unter [Verwenden vertrauenswürdiger Schlüssel zur Steuerung des Entpackens von Schlüsseln](manage-keys-using-trusted-keys.md).
# Erlaubt dem JCE-Anbieter, geheime private Schlüssel aus zu extrahieren AWS CloudHSM
Gehen Sie wie folgt vor, damit der AWS CloudHSM JCE-Anbieter Ihre privaten Schlüssel extrahieren kann.
**Wichtig**
Diese Konfigurationsänderung ermöglicht das Extrahieren aller `EXTRACTABLE`-Schlüsselbytes aus Ihrem HSM-Cluster im Klartext. Aus Sicherheitsgründen sollten Sie erwägen, Schlüssel mithilfe von [Methoden zum Wrapping von Schlüsseln](java-lib-supported_5.md) sicher aus dem HSM zu extrahieren. Dadurch wird ein unbeabsichtigtes Extrahieren Ihrer Schlüsselbytes aus dem HSM verhindert.
1. Verwenden Sie die folgenden Befehle, um das Extrahieren Ihrer **privaten** oder **geheimen** Schlüssel in JCE zu ermöglichen:
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/configure-jce --enable-clear-key-extraction-in-software
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe" --enable-clear-key-extraction-in-software
```
------
1. Sobald Sie die Extraktion Ihres eindeutigen Schlüssels aktivieren, sind die folgenden Methoden zur Extraktion privater Schlüssel in den Speicher aktiviert.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/get-encoded-take-out-private-keys.html)
Wenn Sie das Standardverhalten wiederherstellen und JCE nicht erlauben möchten, Schlüssel im Klartext zu exportieren, führen Sie den folgenden Befehl aus:
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/configure-jce --disable-clear-key-extraction-in-software
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe" --disable-clear-key-extraction-in-software
```
------
# Befehle für JCE wiederholen für AWS CloudHSM
AWS CloudHSM Das Client-SDK 5.8.0 und höher verfügen über eine integrierte automatische Wiederholungsstrategie, mit der HSM-gedrosselte Operationen von der Clientseite aus wiederholt werden. Wenn ein HSM Operationen drosselt, weil es mit der Ausführung früherer Operationen zu beschäftigt ist und keine weiteren Anfragen annehmen kann, versucht der Client, gedrosselte Operationen bis zu dreimal zu wiederholen, während er SDKs sich exponentiell zurückzieht. Diese automatische Wiederholungsstrategie kann auf einen von zwei Modi eingestellt werden: **aus** und **Standard**.
+ **aus**: Das Client-SDK führt bei gedrosselten Vorgängen durch das HSM keine Wiederholungsstrategie durch.
+ **Standard**: Dies ist der Standardmodus für das Client-SDK 5.8.0 und höher. In diesem Modus wiederholt der Client automatisch gedrosselte Operationen, indem er SDKs sich exponentiell zurückzieht.
Weitere Informationen finden Sie unter [HSM-Drosselung](troubleshoot-hsm-throttling.md).
## Stellen Sie den Modus für Wiederholungsbefehle auf Aus
------
#### [ Linux ]
**So setzen Sie Wiederholungsbefehle auf **off** für Client-SDK 5 unter Linux**
+ Sie können den folgenden Befehl verwenden, um die Konfiguration der Wiederholungen auf den **off**-Modus zu setzen:
```
$ sudo /opt/cloudhsm/bin/configure-jce --default-retry-mode off
```
------
#### [ Windows ]
**So setzen Sie Wiederholungsbefehle auf **off** für Client-SDK 5 unter Windows**
+ Sie können den folgenden Befehl verwenden, um die Konfiguration der Wiederholungen auf den **off**-Modus zu setzen:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe" --default-retry-mode off
```
------