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.
# Verwenden Sie das Client SDK 5 für die Arbeit mit AWS CloudHSM
AWS CloudHSM umfasst zwei Hauptversionen des Client-SDK:
+ Client-SDK 5: Dies ist unser neuestes und standardmäßiges Client-SDK. Informationen zu den Vorteilen und Nutzen, die es bietet, finden Sie unter [Vorteile von AWS CloudHSM Client SDK 5](client-sdk-5-benefits.md).
+ Client-SDK 3: Dies ist unser älteres Client-SDK. Es enthält einen vollständigen Satz von Komponenten für die Kompatibilität von plattform- und sprachbasierten Anwendungen und Verwaltungstools.
Anweisungen zur Migration von Client SDK 3 auf Client SDK 5 finden Sie unter[Migration von AWS CloudHSM Client SDK 3 zu Client SDK 5](client-sdk-migration.md).
In diesem Thema wird das Client SDK 5 beschrieben. Informationen darüber, welche Version des Client-SDK Sie verwenden, finden Sie unter
**Topics**
+ [Vorteile von AWS CloudHSM Client SDK 5](client-sdk-5-benefits.md)
+ [AWS CloudHSM Client SDK 5 unterstützte Plattformen](client-supported-platforms.md)
+ [PKCS \$111 -Bibliothek für AWS CloudHSM Client SDK 5](pkcs11-library.md)
+ [OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5](openssl-library.md)
+ [OpenSSL-Anbieter für AWS CloudHSM Client SDK 5](openssl-provider-library.md)
+ [Schlüsselspeicheranbieter (KSP) für AWS CloudHSM Client SDK 5](ksp-library.md)
+ [JCE-Anbieter für AWS CloudHSM Client SDK 5](java-library.md)
# Vorteile von AWS CloudHSM Client SDK 5
Im Vergleich zu AWS CloudHSM Client SDK 3 ist Client SDK 5 einfacher zu verwalten, bietet eine bessere Konfigurierbarkeit und eine höhere Zuverlässigkeit. Client-SDK 5 bietet außerdem einige zusätzliche wichtige Vorteile gegenüber Client-SDK 3.
**Konzipiert für Serverless-Architekturen**
Das Client-SDK 5 benötigt keinen Client-Daemon, sodass Sie keinen Hintergrunddienst mehr verwalten müssen. Dies hilft Benutzern in einigen wichtigen Punkten:
+ Vereinfacht den Startvorgang der Anwendung. Um mit CloudHSM zu beginnen, müssen Sie lediglich das SDK konfigurieren, bevor Sie Ihre Anwendung ausführen.
+ Sie benötigen keinen ständig laufenden Prozess, was die Integration mit Serverless-Komponenten wie Lambda und Elastic Container Service (ECS) erleichtert.
**Bessere Integrationen von Drittanbietern und einfachere Portabilität**
Das Client-SDK 5 folgt genau der JCE-Spezifikation und bietet eine einfachere Portabilität zwischen verschiedenen JCE-Anbietern sowie bessere Integrationen von Drittanbietern
**Verbesserte Benutzererfahrung und Konfigurierbarkeit**
Das Client-SDK 5 verbessert die Lesbarkeit von Protokollnachrichten und bietet klarere Ausnahmen und Mechanismen zur Fehlerbehandlung, was die Self-Service-Suche für Benutzer erheblich erleichtert. SDK 5 bietet auch eine Vielzahl von Konfigurationen, die auf der [Seite Configure Tool](https://docs.aws.amazon.com/cloudhsm/latest/userguide/configure-sdk-5.html) aufgeführt sind.
**Breitere Plattformunterstützung**
Client-SDK 5 bietet mehr Unterstützung für moderne Betriebsplattformen. Dies beinhaltet Unterstützung für ARM-Technologien und eine bessere Unterstützung für [JCE](https://docs.aws.amazon.com/cloudhsm/latest/userguide/java-library_5.html), [PKCS \$111](https://docs.aws.amazon.com/cloudhsm/latest/userguide/pkcs11-library.html) und [OpenSSL](https://docs.aws.amazon.com/cloudhsm/latest/userguide/openssl-library.html). Weitere Informationen finden Sie unter [Unterstützte Plattformen](client-supported-platforms.md).
**IPv6 Verbindungsunterstützung**
Das Client-SDK 5.14\$1 unterstützt Verbindungen zu HSMs Dual-Stack unter Verwendung von. IPv6
**Zusätzliche Funktionen und Mechanismen**
Client-SDK 5 enthält zusätzliche Funktionen und Mechanismen, die in Client-SDK 3 nicht verfügbar sind, und Client-SDK 5 wird in Zukunft weitere Mechanismen hinzufügen.
# AWS CloudHSM Client SDK 5 unterstützte Plattformen
Die AWS CloudHSM Basisunterstützung ist für jede Version des Client-SDK unterschiedlich. Die Plattformunterstützung für Komponenten in einem SDK entspricht in der Regel der Basisunterstützung, jedoch nicht immer. Um die Plattformunterstützung für eine bestimmte Komponente zu ermitteln, stellen Sie zunächst sicher, dass die gewünschte Plattform im Basisbereich für das SDK angezeigt wird, und suchen Sie dann im Komponentenabschnitt nach Ausschlüssen oder anderen relevanten Informationen.
AWS CloudHSM unterstützt nur 64-Bit-Betriebssysteme.
Die Plattformunterstützung ändert sich im Laufe der Zeit. Frühere Versionen des CloudHSM-Client SDK unterstützen möglicherweise nicht alle hier aufgeführten Betriebssysteme. Ermitteln Sie anhand der Versionshinweise die Betriebssystemunterstützung für frühere Versionen des CloudHSM-Client SDK. Weitere Informationen finden Sie unter [Downloads für das AWS CloudHSM Client-SDK](client-history.md).
Informationen zu den unterstützten Plattformen für das vorherige Client-SDK finden Sie unter [AWS CloudHSM Unterstützte Plattformen vom Client SDK 3](sdk3-support.md).
Für das Client-SDK 5 ist kein Client-Daemon erforderlich.
**Topics**
+ [Linux-Unterstützung für Client-SDK 5](sdk8-linux.md)
+ [Windows-Unterstützung für Client-SDK 5](sdk8-windows.md)
+ [Serverless-Unterstützung für Client-SDK 5](sdk8-serverless.md)
+ [HSM-Kompatibilität für Client SDK 5](sdk5-hsm-types.md)
# Linux-Unterstützung für AWS CloudHSM Client SDK 5
AWS CloudHSM Das Client SDK 5 unterstützt die folgenden Linux-Betriebssysteme und -Plattformen.
| Unterstützte Plattformen | X86\$164-Architektur | ARM-Architektur |
| --- | --- | --- |
| Amazon Linux 2 | Ja | Ja |
| Amazon Linux 2023 | Ja | Ja |
| Red Hat Enterprise Linux 8 (8.3\$1) | Ja | Ja |
| RedHat Enterprise Linux 9 (9,2 und höher) | Ja | Ja |
| RedHat Enterprise Linux 10 (10.0\$1) | Ja | Ja |
| Ubuntu 22.04 LTS | Ja | Ja |
| Ubuntu 24.04 LTS | Ja | Ja |
+ SDK 5.16 war die letzte Version, die Unterstützung für die Ubuntu 20.04 LTS-Plattform bot. [Weitere Informationen finden Sie auf der Ubuntu-Website.](https://ubuntu.com/blog/ubuntu-20-04-lts-end-of-life-standard-support-is-coming-to-an-end-heres-how-to-prepare)
+ SDK 5.12 war die letzte Version, die CentOS 7 (7.8\$1) Plattformunterstützung bot. Weitere Informationen finden Sie auf der [CentOS-Website](https://blog.centos.org/2023/04/end-dates-are-coming-for-centos-stream-8-and-centos-linux-7/).
+ SDK 5.12 war die letzte Version, die Unterstützung für die Plattform Red Hat Enterprise Linux 7 (7.8\$1) bot. Weitere Informationen finden Sie auf der [Red](https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux/rhel-7-end-of-maintenance) Hat Website.
+ SDK 5.4.2 war die letzte Version, die CentOS 8-Plattformunterstützung bot. Weitere Informationen finden Sie auf der [CentOS-Website](https://www.centos.org/centos-linux-eol/).
# Windows-Unterstützung für AWS CloudHSM Client SDK 5
AWS CloudHSM Das Client SDK 5 unterstützt die folgenden Versionen von Windows Server.
+ Microsoft Windows Server 2016
+ Microsoft Windows Server 2019
+ Microsoft Windows Server 2022
+ Microsoft Windows Server 2025
# Serverlose Unterstützung für AWS CloudHSM Client SDK 5
AWS CloudHSM Das Client SDK 5 unterstützt die folgenden AWS serverlosen Dienste.
+ AWS Lambda
+ Docker/ECS
# HSM-Kompatibilität für AWS CloudHSM Client SDK 5
In der folgenden Tabelle wird die Kompatibilität AWS CloudHSM des Client SDK 5 für HSMs beschrieben.
| hsm1.medium | hsm2m. mittel |
| --- | --- |
| Kompatibel mit Client SDK Version 5.0.0 und höher. | Kompatibel mit der Client-SDK-Version 5.9.0 und höher. |
# PKCS \$111 -Bibliothek für AWS CloudHSM Client SDK 5
PKCS \$111 ist ein Standard für die Ausführung kryptografischer Operationen an Hardware-Sicherheitsmodulen (). HSMs AWS CloudHSM bietet Implementierungen der PKCS \$111 -Bibliothek, die mit PKCS \$111, Version 2.40, kompatibel sind.
Informationen zu Bootstrapping finden Sie unter [Verbinden mit dem Cluster](cluster-connect.md). Informationen zur Problembehandlung finden Sie unter. [Bekannte Probleme mit der PKCS \$111 -Bibliothek für AWS CloudHSMBekannte Probleme für den PKCS\$111-Bibliothek](ki-pkcs11-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 die PKCS \$111 -Bibliothek](pkcs11-library-install.md)
+ [Authentifizieren Sie sich bei der PKCS \$111 -Bibliothek](pkcs11-pin.md)
+ [Schlüsseltypen](pkcs11-key-types.md)
+ [Mechanismen](pkcs11-mechanisms.md)
+ [API-Operationen](pkcs11-apis.md)
+ [Schlüsselattribute](pkcs11-attributes.md)
+ [Codebeispiele](pkcs11-samples.md)
+ [Erweiterte -Konfigurationen](pkcs11-library-configs.md)
+ [Speicherung von Zertifikaten](pkcs11-certificate-storage.md)
# Installieren Sie die PKCS \$111 -Bibliothek für AWS CloudHSM Client SDK 5
Dieses Thema enthält Anweisungen zur Installation der neuesten Version der PKCS \$111 -Bibliothek für die AWS CloudHSM Client SDK 5-Versionsserie. Weitere Informationen zum Client-SDK oder zur PKCS \$111-Bibliothek finden Sie unter [Verwenden des Client-SDK](use-hsm.md) und der [PKCS \$111-Bibliothek](pkcs11-library.md).
Mit dem Client-SDK 5 müssen Sie keinen Client-Daemon installieren oder ausführen.
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).
Weitere Informationen über die PKCS \$111-Bibliothek in Client-SDK 5 finden Sie unter [PKCS \$111-Bibliothek](pkcs11-library.md).
**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).
**Installieren und Konfigurieren der PKCS \$111-Bibliothek**
1. Verwenden Sie die folgenden Befehle zum Herunterladen und Installieren der PKCS \$111-Bibliothek.
------
#### [ Amazon Linux 2023 ]
Installieren Sie die PKCS \$111 -Bibliothek für Amazon Linux 2023 auf der X86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-pkcs11-latest.amzn2023.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.amzn2023.x86_64.rpm
```
Installieren Sie die PKCS \$111 -Bibliothek für Amazon Linux 2023 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-pkcs11-latest.amzn2023.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.amzn2023.aarch64.rpm
```
------
#### [ Amazon Linux 2 ]
Installieren Sie die PKCS \$111-Bibliothek für Amazon Linux 2 auf der X86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-pkcs11-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el7.x86_64.rpm
```
Installieren Sie die PKCS \$111 -Bibliothek für Amazon Linux 2 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-pkcs11-latest.el7.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el7.aarch64.rpm
```
------
#### [ RHEL 10 (10.0\$1) ]
Installieren Sie die PKCS \$111 -Bibliothek für RHEL 10 auf der X86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-pkcs11-latest.el10.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el10.x86_64.rpm
```
Installieren Sie die PKCS \$111 -Bibliothek für RHEL 10 auf der folgenden Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-pkcs11-latest.el10.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el10.aarch64.rpm
```
------
#### [ RHEL 9 (9.2\$1) ]
Installieren Sie die PKCS \$111 -Bibliothek für RHEL 9 auf der X86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-pkcs11-latest.el9.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el9.x86_64.rpm
```
Installieren Sie die PKCS \$111 -Bibliothek für RHEL 9 auf folgender Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-pkcs11-latest.el9.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el9.aarch64.rpm
```
------
#### [ RHEL 8 (8.3\$1) ]
Installieren Sie die PKCS \$111 -Bibliothek für RHEL 8 auf der X86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-pkcs11-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el8.x86_64.rpm
```
Installieren Sie die PKCS \$111 -Bibliothek für RHEL 8 auf der folgenden Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-pkcs11-latest.el8.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el8.aarch64.rpm
```
------
#### [ Ubuntu 24.04 LTS ]
Installieren Sie die PKCS \$111 -Bibliothek für Ubuntu 24.04 LTS auf der X86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-pkcs11_latest_u24.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-pkcs11_latest_u24.04_amd64.deb
```
Installieren Sie die PKCS \$111 -Bibliothek für Ubuntu 24.04 LTS auf der Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-pkcs11_latest_u24.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-pkcs11_latest_u24.04_arm64.deb
```
------
#### [ Ubuntu 22.04 LTS ]
Installieren Sie die PKCS \$111-Bibliothek für Ubuntu 22.04 LTS auf der X86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-pkcs11_latest_u22.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-pkcs11_latest_u22.04_amd64.deb
```
Installieren Sie die PKCS \$111 -Bibliothek für Ubuntu 22.04 LTS auf der Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-pkcs11_latest_u22.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-pkcs11_latest_u22.04_arm64.deb
```
------
#### [ Windows Server ]
Installieren Sie die PKCS \$111 -Bibliothek für Windows Server auf der X86\$164-Architektur:
1. Laden Sie die [PKCS \$111-Bibliothek](https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Windows/AWSCloudHSMPKCS11-latest.msi) für Client-SDK 5 herunter.
1. Führen Sie das PKCS \$111 -Bibliotheksinstallationsprogramm (**AWSCloudHSMPKCS11-latest.msi**) mit Windows-Administratorrechten aus.
------
1. Verwenden Sie das Configure-Tool, um den Speicherort des ausstellenden Zertifikats anzugeben. Detaillierte Anweisungen finden Sie unter [Geben Sie den Speicherort des ausstellenden Zertifikats an](cluster-connect.md#specify-cert-location).
1. Um eine Verbindung zu Ihrem Cluster herzustellen, siehe [Bootstrap für das Client-SDK](cluster-connect.md#connect-how-to).
1. Die PKCS \$111-Bibliotheksdateien finden Sie an den folgenden Speicherorten:
+ Linux-Binärdateien, Konfigurationsskripten und Protokolldateien:
```
/opt/cloudhsm
```
Windows-Binärdateien:
```
C:\Program Files\Amazon\CloudHSM
```
Windows-Konfigurationsskripten und Protokolldateien:
```
C:\ProgramData\Amazon\CloudHSM
```
# Authentifizieren Sie sich bei der PKCS \$111 -Bibliothek für AWS CloudHSM Client SDK 5
Wenn Sie die PKCS \$111 -Bibliothek verwenden, wird Ihre Anwendung unter einem bestimmten [Crypto User (CU)](manage-hsm-users.md) in Ihrem Konto ausgeführt. HSMs AWS CloudHSM Ihre Anwendung kann nur die Schlüssel anzeigen und verwalten, die der CU besitzt und freigibt. Sie können eine vorhandene CU in Ihrer Anwendung verwenden HSMs oder eine neue CU für Ihre Anwendung erstellen. Informationen zur [Verwaltung CUs finden Sie unter HSM-Benutzer mit CloudHSM CLI verwalten und HSM-Benutzer](manage-hsm-users-chsm-cli.md) [mit CloudHSM Management Utility (CMU](manage-hsm-users-cmu.md)) verwalten
Um den CU für die PKCS \$111-Bibliothek anzugeben, verwenden Sie den Pin-Parameter der PKCS \$111-Funktion [C\$1Login](http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/os/pkcs11-base-v2.40-os.html#_Toc385057915). Denn der AWS CloudHSM Pin-Parameter hat das folgende Format:
```
:
```
Mit dem folgenden Befehl wird beispielsweise dem PKCS \$111-Bibliothek-Pin der CU mit dem Benutzernamen `CryptoUser` und dem Passwort `CUPassword123!` zugewiesen.
```
CryptoUser:CUPassword123!
```
# Unterstützte Schlüsseltypen für die PKCS \$111 -Bibliothek für das AWS CloudHSM Client-SDK 5
Die PKCS \$111 -Bibliothek für AWS CloudHSM Client SDK 5 unterstützt die folgenden Schlüsseltypen.
****
| Schlüsseltyp | Description |
| --- | --- |
| AES | Generieren der 128-, 192- und 256-Bit-AES-Schlüssel. |
| Dreifaches DES (3DES,) DESede | Generieren von 192-Bit-Triple-DES-Schlüsseln. Eine bevorstehende Änderung finden Sie im Hinweis [1](#key-types-1) unten. |
| EC | Generieren Sie Schlüssel mit den 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. |
| 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).
# Unterstützte Mechanismen für die PKCS \$111 -Bibliothek für AWS CloudHSM das Client-SDK 5
Die PKCS \$111-Bibliothek entspricht Version 2.40 der PKCS \$111-Spezifikation. Um eine kryptographische Funktion mit PKCS\$111 aufzurufen, rufen Sie eine Funktion mit einem bestimmten Mechanismus auf. In den folgenden Abschnitten werden die vom AWS CloudHSM Client SDK 5 unterstützten Kombinationen von Funktionen und Mechanismen zusammengefasst.
Die PKCS \$111-Bibliothek unterstützt die folgenden Algorithmen:
+ **Verschlüsselung und Entschlüsselung** — AES-CBC, AES-CTR, AES-ECB, AES-GCM, -CBC, -ECB, RSA-OAEP und RSA-PKCS DES3 DES3
+ **Signieren und Verifizieren** – RSA, HMAC und ECDSA; mit und ohne Hashing
+ ** SHA1 SHA256 SHA384Hash/Digest SHA224 —,,, und** SHA512
+ **Key Wrap** – AES Key Wrap[1](#mech1), AES-GCM, RSA-AES und RSA-OAEP
+ **Schlüsselableitung** — SP800 -108 Counter KDF und ECDH mit KDF (Unterstützte KDF-Algorithmen sind X9.63 mit,,,,) SHA1 SHA224 SHA256 SHA384 SHA512
**Topics**
+ [Schlüssel- und Schlüsselpaarfunktionen generieren](#pkcs11-mech-function-genkey)
+ [Funktionen zum Signieren und Überprüfen](#pkcs11-mech-function-signverify)
+ [Funktionen zur Signierung, Wiederherstellung und Überprüfung der Wiederherstellung](#pkcs11-mech-function-sr-vr)
+ [Digest-Funktionen](#pkcs11-mech-function-digest)
+ [Funktionen zum Verschlüsseln und Entschlüsseln](#pkcs11-mech-function-enc-dec)
+ [Schlüsselfunktionen ableiten](#pkcs11-mech-function-derive-key)
+ [Funktionen „Packen“ und „Entpacken“](#pkcs11-mech-function-wrap-unwrap)
+ [Maximale Datengröße für jeden Mechanismus](#pkcs11-mech-max)
+ [Anmerkungen zum Mechanismus](#pkcs11-mech-annotations)
## Schlüssel- und Schlüsselpaarfunktionen generieren
AWS CloudHSM Mit der Softwarebibliothek für die PKCS \$111 -Bibliothek können Sie die folgenden Mechanismen für die Funktionen Schlüssel generieren und Schlüsselpaar verwenden.
+ `CKM_RSA_PKCS_KEY_PAIR_GEN`
+ `CKM_RSA_X9_31_KEY_PAIR_GEN` – Dieser Mechanismus ist funktionell identisch mit dem `CKM_RSA_PKCS_KEY_PAIR_GEN`-Mechanismus, aber bietet stärkere Garantien für die Generierung von `p` und `q`.
+ `CKM_EC_KEY_PAIR_GEN`
+ `CKM_GENERIC_SECRET_KEY_GEN`
+ `CKM_AES_KEY_GEN`
+ `CKM_DES3_KEY_GEN` – bevorstehende Änderung in der Fußnote [5](#mech5) aufgeführt.
## Funktionen zum Signieren und Überprüfen
Mit der AWS CloudHSM Softwarebibliothek für PKCS \$111 können Sie die folgenden Mechanismen für die Funktionen Signieren und Überprüfen verwenden. 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.
Mit Client-SDK 5 erfolgt das RSA- und ECDSA-Hashing lokal, sodass es kein Datenlimit gibt. Bei HMAC gibt es ein Datenlimit. Weitere Informationen finden Sie in der Fußnote [2](#mech2).
**RSA**
+ `CKM_RSA_X_509`
+ `CKM_RSA_PKCS` – Nur Single-Part-Operationen.
+ `CKM_RSA_PKCS_PSS` – Nur Single-Part-Operationen.
+ `CKM_SHA1_RSA_PKCS`
+ `CKM_SHA224_RSA_PKCS`
+ `CKM_SHA256_RSA_PKCS`
+ `CKM_SHA384_RSA_PKCS`
+ `CKM_SHA512_RSA_PKCS`
+ `CKM_SHA512_RSA_PKCS`
+ `CKM_SHA1_RSA_PKCS_PSS`
+ `CKM_SHA224_RSA_PKCS_PSS`
+ `CKM_SHA256_RSA_PKCS_PSS`
+ `CKM_SHA384_RSA_PKCS_PSS`
+ `CKM_SHA512_RSA_PKCS_PSS`
**ECDSA**
+ `CKM_ECDSA` – Nur Single-Part-Operationen.
+ `CKM_ECDSA_SHA1`
+ `CKM_ECDSA_SHA224`
+ `CKM_ECDSA_SHA256`
+ `CKM_ECDSA_SHA384`
+ `CKM_ECDSA_SHA512`
**HMAC**
+ `CKM_SHA_1_HMAC`[2](#mech2)
+ `CKM_SHA224_HMAC`[2](#mech2)
+ `CKM_SHA256_HMAC`[2](#mech2)
+ `CKM_SHA384_HMAC`[2](#mech2)
+ `CKM_SHA512_HMAC`[2](#mech2)
**CMAC**
+ `CKM_AES_CMAC`
## Funktionen zur Signierung, Wiederherstellung und Überprüfung der Wiederherstellung
Das Client-SDK 5 unterstützt die Funktionen Sign Recover und Verify Recover nicht.
## Digest-Funktionen
Mit der AWS CloudHSM Softwarebibliothek für PKCS \$111 können Sie die folgenden Mechanismen für Digest-Funktionen verwenden. 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.
+ `CKM_SHA_1`
+ `CKM_SHA224`
+ `CKM_SHA256`
+ `CKM_SHA384`
+ `CKM_SHA512`
## Funktionen zum Verschlüsseln und Entschlüsseln
Mit der AWS CloudHSM Softwarebibliothek für PKCS \$111 können Sie die folgenden Mechanismen für Verschlüsselungs- und Entschlüsselungsfunktionen verwenden.
+ `CKM_RSA_X_509`
+ `CKM_RSA_PKCS` – Nur Single-Part-Operationen. Bevorstehende Änderung in der Fußnote [5](#mech5) aufgeführt.
+ `CKM_RSA_PKCS_OAEP` – Nur Single-Part-Operationen.
+ `CKM_AES_ECB`
+ `CKM_AES_CTR`
+ `CKM_AES_CBC`
+ `CKM_AES_CBC_PAD`
+ `CKM_DES3_CBC` – bevorstehende Änderung in der Fußnote [5](#mech5) aufgeführt.
+ `CKM_DES3_ECB` – bevorstehende Änderung in der Fußnote [5](#mech5) aufgeführt.
+ `CKM_DES3_CBC_PAD` – bevorstehende Änderung in der Fußnote [5](#mech5) aufgeführt.
+ `CKM_AES_GCM` [1](#mech1), [2](#mech2)
+ `CKM_CLOUDHSM_AES_GCM`[3](#mech3)
## Schlüsselfunktionen ableiten
Die AWS CloudHSM Softwarebibliothek für die PKCS \$111 -Bibliothek unterstützt die folgenden wichtigen Ableitungsmechanismen:
+ `CKM_SP800_108_COUNTER_KDF`
+ `CKM_ECDH1_DERIVE`- Unterstützt die ECDH-Schlüsselableitung mit den folgenden herstellerdefinierten KDF-Typen: [6](#kdf6)
+ `CKD_CLOUDHSM_X963_SHA1_KDF`- X9.63 KDF mit SHA1 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA224_KDF`- X9.63 KDF mit SHA224 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA256_KDF`- X9.63 KDF mit SHA256 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA384_KDF`- X9.63 KDF mit SHA384 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA512_KDF`- X9.63 KDF mit SHA512 [7](#kdf7)
## Funktionen „Packen“ und „Entpacken“
Die AWS CloudHSM Softwarebibliothek für die PKCS \$111 -Bibliothek ermöglicht es Ihnen, die folgenden Mechanismen für die Funktionen Wrap und Unwrap zu verwenden.
Weitere Informationen zum AES-Packen mit Schlüssel finden Sie unter [AES Key Wrapping](manage-aes-key-wrapping.md).
+ `CKM_RSA_PKCS` – Nur Single-Part-Operationen. Bevorstehende Änderung in der Fußnote [5](#mech5) aufgeführt.
+ `CKM_RSA_PKCS_OAEP`[4](#mech4)
+ `CKM_AES_GCM`[1](#mech1), [3](#mech3)
+ `CKM_CLOUDHSM_AES_GCM`[3](#mech3)
+ `CKM_RSA_AES_KEY_WRAP`
+ `CKM_CLOUDHSM_AES_KEY_WRAP_NO_PAD`[3](#mech3)
+ `CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD`[3](#mech3)
+ `CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD`[3](#mech3)
## Maximale Datengröße für jeden Mechanismus
Die folgende Tabelle listet die maximale Datengröße für jeden Mechanismus auf:.
**Maximale Datensatzgröße**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/pkcs11-mechanisms.html)
## Anmerkungen zum Mechanismus
+ [1] Bei AES-GCM-Verschlüsselungen akzeptiert HSM keine Initialisierungsvektor (IV)-Daten von der Anwendung. Sie müssen einen erzeugten IV verwenden. Das vom HSM bereitgestellte 12 Byte IV wird in den referenzierten Speicherbereich geschrieben, auf den das pIV-Element der von Ihnen bereitgestellten `CK_GCM_PARAMS`-Parameterstruktur zeigt. Um Missverständnissen vorzubeugen: Das PKCS\$111-SDK in Version 1.1.1 und höher erzwingt, dass pIV auf einen auf Null zurückgesetzten Puffer verweist, wenn die AES-GCM-Verschlüsselung initialisiert wird.
+ [2] Wenn der Datenpuffer die maximale Datengröße überschreitet, führt die Operation bei der Bearbeitung von Daten mittels eines der folgenden Mechanismen zu einem Fehler. Für diese Mechanismen muss die gesamte Datenverarbeitung innerhalb des HSM erfolgen. Informationen zur maximalen Datengröße für jeden Mechanismus finden Sie unter[Maximale Datengröße für jeden Mechanismus](#pkcs11-mech-max).
+ [3] Anbieterdefinierter Mechanismus. Um die von anbieterdefinierten CloudHSM-Mechanismen zu verwenden, müssen PKCS \$111 -Anwendungen während der Kompilierung `/opt/cloudhsm/include/pkcs11/pkcs11t.h` enthalten.
`CKM_CLOUDHSM_AES_GCM`: Dieser proprietäre Mechanismus ist eine programmatisch sicherere Alternative zum Standard `CKM_AES_GCM`. Er stellt die vom HSM generierte IV dem Chiffretext voran, anstatt sie zurück in die `CK_GCM_PARAMS`- Struktur zu schreiben, die während der Chiffrierinitialisierung bereitgestellt wird. Sie können diesen Mechanismus mit `C_Encrypt`-, `C_WrapKey`-, `C_Decrypt`- und `C_UnwrapKey`-Funktionen verwenden. Bei Verwendung dieses Mechanismus muss die pIV-Variable in der `CK_GCM_PARAMS`-Struktur auf `NULL` gesetzt werden. Wenn Sie diesen Mechanismus mit `C_Decrypt` und `C_UnwrapKey` verwenden, wird erwartet, dass der IV dem Verschlüsselungstext vorangestellt wird, der entpackt werden soll.
`CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD`: AES-Verschlüsselung mit PKCS \$15 Padding.
`CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD`: AES-Verschlüsselung mit Zero Padding.
+ [4] Die folgenden `CK_MECHANISM_TYPE` und `CK_RSA_PKCS_MGF_TYPE` werden als `CK_RSA_PKCS_OAEP_PARAMS` für `CKM_RSA_PKCS_OAEP` unterstützt:
+ `CKM_SHA_1` mit `CKG_MGF1_SHA1`
+ `CKM_SHA224` mit `CKG_MGF1_SHA224`
+ `CKM_SHA256` mit `CKG_MGF1_SHA256`
+ `CKM_SHA384` mit `CKM_MGF1_SHA384`
+ `CKM_SHA512` mit `CKM_MGF1_SHA512`
+ [5] Gemäß den NIST-Leitlinien 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).
+ [6] Vom Hersteller definierte Typen. Um herstellerdefinierte CloudHSM-Typen verwenden zu können, müssen PKCS \$111 -Anwendungen bei der Kompilierung Folgendes enthalten`cloudhsm_pkcs11_vendor_defs.h`. Dies ist `/opt/cloudhsm/include/pkcs11/cloudhsm_pkcs11_vendor_defs.h` für Linux-basierte Plattformen und `C:\Program Files\Amazon\CloudHSM\include\pkcs11\cloudhsm_pkcs11_vendor_defs.h` für Windows-basierte Plattformen zu finden
+ [7] Die wichtigsten Ableitungsfunktionen (KDFs) sind in der [NIST-Sonderveröffentlichung 800-56A](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar3.pdf) Revision 3 spezifiziert.
# Unterstützte API-Operationen für die PKCS \$111 -Bibliothek für das Client-SDK 5 AWS CloudHSM
Die PKCS \$111 -Bibliothek unterstützt die folgenden PKCS \$111 -API-Operationen für das AWS CloudHSM Client-SDK 5.
+ `C_CloseAllSessions`
+ `C_CloseSession`
+ `C_CreateObject`
+ `C_Decrypt`
+ `C_DecryptFinal`
+ `C_DecryptInit`
+ `C_DecryptUpdate`
+ `C_DeriveKey`
+ `C_DestroyObject`
+ `C_Digest`
+ `C_DigestFinal`
+ `C_DigestInit`
+ `C_DigestUpdate`
+ `C_Encrypt`
+ `C_EncryptFinal`
+ `C_EncryptInit`
+ `C_EncryptUpdate`
+ `C_Finalize`
+ `C_FindObjects`
+ `C_FindObjectsFinal`
+ `C_FindObjectsInit`
+ `C_GenerateKey`
+ `C_GenerateKeyPair`
+ `C_GenerateRandom`
+ `C_GetAttributeValue`
+ `C_GetFunctionList`
+ `C_GetInfo`
+ `C_GetMechanismInfo`
+ `C_GetMechanismList`
+ `C_GetSessionInfo`
+ `C_GetSlotInfo`
+ `C_GetSlotList`
+ `C_GetTokenInfo`
+ `C_Initialize`
+ `C_Login`
+ `C_Logout`
+ `C_OpenSession`
+ `C_Sign`
+ `C_SignFinal`
+ `C_SignInit`
+ `C_SignUpdate`
+ `C_UnWrapKey`
+ `C_Verify`
+ `C_VerifyFinal`
+ `C_VerifyInit`
+ `C_VerifyUpdate`
+ `C_WrapKey`
# Schlüsselattribute in der PKCS \$111 -Bibliothek für AWS CloudHSM das Client-SDK 5
Ein AWS CloudHSM Schlüsselobjekt kann ein öffentlicher, privater oder geheimer Schlüssel sein. Für ein Schlüsselobjekt genehmigte Aktionen werden durch Attribute angegeben. Attribute werden bei der Erstellung des Schlüsselobjekts bestimmt. Wenn Sie die PKCS \$111 -Bibliothek für verwenden AWS CloudHSM, weisen wir Standardwerte zu, die im PKCS \$111 -Standard spezifiziert sind.
AWS CloudHSM unterstützt nicht alle in der PKCS \$111 -Spezifikation aufgeführten Attribute. Wir erfüllen die Spezifikation für alle von uns unterstützten Attribute. Diese Attribute sind in den entsprechenden Tabellen aufgeführt.
Kryptografische Funktionen wie `C_CreateObject`, `C_GenerateKey`, `C_GenerateKeyPair`, `C_UnwrapKey` und `C_DeriveKey` zum Erstellen, Ändern oder Kopieren von Objekten benötigen eine Attributvorlage für einen ihrer Parameter. Weitere Informationen zum Übertragen von Attributvorlagen während der Erstellung von Objekten finden Sie in den Beispielen unter [Generieren von Schlüsseln über die PKCS \$111-Bibliothek](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate).
Die folgenden Themen enthalten weitere Informationen zu AWS CloudHSM Schlüsselattributen.
**Topics**
+ [Tabellen mit Attributen](pkcs11-attributes-interpreting.md)
+ [Ändern von Attributen](modify-attr.md)
+ [Interpretieren von Fehlercodes](attr-errors.md)
# PKCS \$111 -Bibliotheksattributtabellen für AWS CloudHSM Client SDK 5
Die PKCS \$111 -Bibliothekstabellen für AWS CloudHSM enthalten eine Liste von Attributen, die sich je nach Schlüsseltyp unterscheiden. Sie gibt an, ob ein bestimmtes Attribut für einen bestimmten Schlüsseltyp unterstützt wird, wenn eine bestimmte kryptografische Funktion mit verwendet wird. AWS CloudHSM
**Legende**:
+ ✔ gibt an, dass CloudHSM das Attribut für den spezifischen Schlüsseltyp unterstützt.
+ ✖ gibt an, dass CloudHSM das Attribut für den spezifischen Schlüsseltyp nicht unterstützt.
+ R gibt an, dass der Attributwert für den spezifischen Schlüsseltyp als schreibgeschützt festgelegt ist.
+ S zeigt an, dass das Attribut von `GetAttributeValue` nicht gelesen werden kann, da hierbei Groß- und Kleinschreibung beachtet werden muss.
+ Eine leere Zelle in der Spalte „Standardwert“ gibt an, dass dem Attribut kein spezifischer Standardwert zugewiesen ist.
## GenerateKeyPair
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## GenerateKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## CreateObject
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## UnwrapKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## DeriveKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## GetAttributeValue
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
**Anmerkungen zu Attributen**
+ [1] Dieses Attribut wird teilweise von der Firmware unterstützt und muss explizit nur auf den Standardwert festgelegt werden.
+ [2] Obligatorisches Attribut.
# Ändern der PKCS \$111 -Bibliotheksattribute für das AWS CloudHSM Client-SDK 5
Einige PKCS \$111 -Bibliotheksattribute für ein AWS CloudHSM Objekt können nach der Erstellung des Objekts geändert werden, andere nicht. Verwenden Sie den Befehl [key set-attribute in der CloudHSM-CLI, um Attribute](cloudhsm_cli-key-set-attribute.md) zu ändern. Sie können auch eine Liste von Attributen ableiten, indem Sie den Befehl [key list](cloudhsm_cli-key-list.md) in der CloudHSM-CLI verwenden.
Die folgende Liste zeigt Attribute, die nach der Erstellung eines Objekts geändert werden dürfen.
+ `CKA_LABEL`
+ `CKA_TOKEN`
**Anmerkung**
Änderungen sind nur zum Umwandeln eines Sitzungsschlüssels in einen Token-Schlüssel zulässig. Verwenden Sie den Befehl [key set-attribute](cloudhsm_cli-key-set-attribute.md) in der CloudHSM-CLI, um den Attributwert zu ändern.
+ `CKA_ENCRYPT`
+ `CKA_DECRYPT`
+ `CKA_SIGN`
+ `CKA_VERIFY`
+ `CKA_WRAP`
+ `CKA_UNWRAP`
+ `CKA_LABEL`
+ `CKA_SENSITIVE`
+ `CKA_DERIVE`
**Anmerkung**
Dieses Attribut unterstützt die Schlüsselableitung. Es muss für alle öffentlichen Schlüssel `False` lauten und kann nicht auf `True` festgelegt werden. Für geheime und private EC-Schlüssel kann es auf `True` oder `False` einstellt werden.
+ `CKA_TRUSTED`
**Anmerkung**
Dieses Attribut kann nur vom Verschlüsselungsverantwortlichen (CO) auf `True` oder `False` festgelegt werden.
+ `CKA_WRAP_WITH_TRUSTED`
**Anmerkung**
Wenden Sie dieses Attribut auf einen exportierbaren Datenschlüssel an, um anzugeben, dass Sie diesen Schlüssel nur mit Schlüsseln packen können, die als `CKA_TRUSTED` markiert sind. Sobald Sie `CKA_WRAP_WITH_TRUSTED` auf „true“ setzen, wird das Attribut schreibgeschützt und Sie können das Attribut nicht mehr ändern oder entfernen.
# Interpretieren der Fehlercodes der PKCS \$111 -Bibliothek für das Client-SDK 5 AWS CloudHSM
Die Angabe eines PKCS \$111 -Bibliotheksattributs in der Vorlage, das von einem bestimmten Schlüssel nicht unterstützt wird, führt zu einem Fehler. Die folgende Tabelle enthält die Fehlercodes, die generiert werden, wenn Sie gegen die Spezifikationen verstoßen:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/attr-errors.html)
# Codebeispiele für die PKCS \$111 -Bibliothek für das AWS CloudHSM Client-SDK 5
Die Codebeispiele auf dieser Seite GitHub zeigen Ihnen, wie Sie grundlegende Aufgaben mithilfe der PKCS \$111 -Bibliothek für das AWS CloudHSM Client-SDK 5 ausführen.
## Voraussetzungen
Bevor Sie die Beispiele ausführen, führen Sie die folgenden Schritte aus, um Ihre Umgebung einzurichten:
+ Installieren und konfigurieren Sie die [PKCS \$111-Bibliothek](pkcs11-library-install.md) für das Client-SDK 5.
+ Richten Sie einen [Crypto-Benutzer (CU)](manage-hsm-users.md) ein. Ihre Anwendung verwendet dieses HSM-Konto, um die Codebeispiele auf dem HSM auszuführen.
## Codebeispiele
Codebeispiele für die AWS CloudHSM Softwarebibliothek für PKCS \$111 finden Sie unter. [GitHub](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples) Dieses Repository enthält Beispiele für allgemeine Vorgänge mit PKCS \$111, einschließlich Verschlüsselung, Entschlüsselung, Signieren und Verifizieren.
+ [Schlüssel generieren (AES, RSA, EC)](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate)
+ [Schlüsselattribute auflisten](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/attributes/)
+ [Verschlüsseln und Entschlüsseln von Daten mit AES GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/encrypt/aes_gcm.c)
+ [Verschlüsseln und Entschlüsseln von Daten mit AES\$1CTR](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/aes_ctr.c)
+ [Verschlüsseln und Entschlüsseln von Daten mit 3DES](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/des_ecb.c)
+ [Signieren und Verifizieren von Daten mit RSA](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/sign/rsa_sign.c)
+ [Ableiten von Schlüsseln mit HMAC KDF](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/derivation/hmac_kdf.c)
+ [Verpacken und Entpacken von Schlüsseln mit AES und PKCS \$15 Padding](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_wrapping.c)
+ [Verpacken und Entpacken von Schlüsseln mit AES ohne Padding](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_no_padding_wrapping.c)
+ [Verpacken und Entpacken von Schlüsseln mit AES und Zero Padding](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_zero_padding_wrapping.c)
+ [Packen und Entpacken von Schlüsseln mit AES-GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/wrapping/aes_gcm_wrapping.c)
+ [Schlüssel mit RSA packen und entpacken](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/rsa_wrapping.c)
# Erweiterte Konfigurationen für die PKCS \$111 -Bibliothek für AWS CloudHSM
Der AWS CloudHSM PKCS \$111 -Anbieter umfasst die folgende erweiterte Konfiguration, die nicht Teil der allgemeinen Konfigurationen ist, die die meisten Kunden verwenden. Diese Konfigurationen bieten zusätzliche Funktionen.
+ [Verbindung zu mehreren Steckplätzen mit PKCS \$111](pkcs11-library-configs-multi-slot.md)
+ [Versuchen Sie erneut, die Konfiguration für PKCS \$111 zu konfigurieren](pkcs11-library-configs-retry.md)
# Konfiguration mit mehreren Steckplätzen mit PKCS \$111 -Bibliothek für AWS CloudHSM
Ein einzelner Steckplatz in der PKCS \$111-Bibliothek des Client-SDK 5 steht für eine einzelne Verbindung zu einem Cluster in AWS CloudHSM. Mit Client SDK 5 können Sie Ihre PKCS11 Bibliothek so konfigurieren, dass mehrere Slots Benutzer über eine einzige PKCS \$111 -Anwendung mit mehreren CloudHSM-Clustern verbinden können.
Verwenden Sie die Anweisungen in diesem Thema, um dafür zu sorgen, dass Ihre Anwendung Multi-Slot-Funktionen verwendet, um eine Verbindung mit mehreren Clustern herzustellen.
**Topics**
+ [Voraussetzungen für mehrere Steckplätze für die PKCS \$111 -Bibliothek für AWS CloudHSM](#pkcs11-multi-slot-prereqs)
+ [Konfigurieren Sie die PKCS \$111 -Bibliothek für Multi-Slot-Funktionalität für AWS CloudHSM](pkcs11-multi-slot-config-run.md)
+ [Fügen Sie einen Cluster mit Multi-Slot-Funktionalität hinzu für AWS CloudHSM](pkcs11-multi-slot-add-cluster.md)
+ [Entfernen Sie einen Cluster mit Multi-Slot-Funktionalität für AWS CloudHSM](pkcs11-multi-slot-remove-cluster.md)
## Voraussetzungen für mehrere Steckplätze für die PKCS \$111 -Bibliothek für AWS CloudHSM
Bevor Sie mehrere Steckplätze für die PKCS \$111 -Bibliothek für konfigurieren AWS CloudHSM, müssen Sie die folgenden Voraussetzungen erfüllen.
+ Zwei oder mehr AWS CloudHSM Cluster, zu denen Sie eine Verbindung herstellen möchten, zusammen mit ihren Cluster-Zertifikaten.
+ Eine EC2-Instance mit Sicherheitsgruppen, die korrekt konfiguriert sind, um eine Verbindung zu allen oben genannten Clustern herzustellen. Weitere Informationen zum Einrichten eines Clusters und der Client-Instanz finden Sie unter [Erste Schritte mit AWS CloudHSM](getting-started.md).
+ Um die Multi-Steckplatz-Funktionalität einzurichten, müssen Sie die PKCS \$111-Bibliothek bereits heruntergeladen und installiert haben. Wenn Sie dies noch nicht getan haben, lesen Sie die Anweisungen unter [Installieren Sie die PKCS \$111 -Bibliothek für AWS CloudHSM Client SDK 5](pkcs11-library-install.md).
# Konfigurieren Sie die PKCS \$111 -Bibliothek für Multi-Slot-Funktionalität für AWS CloudHSM
Gehen Sie wie folgt vor, um Ihre PKCS \$111 -Bibliothek für für die Multi-Slot-Funktionalität zu konfigurieren: AWS CloudHSM
1. Identifizieren Sie die Cluster, zu denen Sie mithilfe der Multi-Steckplatz-Funktionalität eine Verbindung herstellen möchten.
1. Fügen Sie diese Cluster zu Ihrer PKCS \$111-Konfiguration hinzu, indem Sie den Anweisungen unter [Fügen Sie einen Cluster mit Multi-Slot-Funktionalität hinzu für AWS CloudHSM](pkcs11-multi-slot-add-cluster.md) folgen.
1. Wenn Ihre PKCS \$111-Anwendung das nächste Mal ausgeführt wird, wird sie über Multi-Steckplatz-Funktionen verfügen.
# Fügen Sie einen Cluster mit Multi-Slot-Funktionalität hinzu für AWS CloudHSM
Wenn Sie [mit PKCS \$111 for eine Verbindung zu mehreren Steckplätzen](pkcs11-library-configs-multi-slot.md) herstellen AWS CloudHSM, verwenden Sie den **configure-pkcs11 add-cluster** Befehl, um Ihrer Konfiguration einen Cluster hinzuzufügen.
## Syntax
```
configure-pkcs11 add-cluster [OPTIONS]
--cluster-id
[--region ]
[--endpoint ]
[--hsm-ca-cert ]
[--client-cert-hsm-tls-file ]
[--client-key-hsm-tls-file ]
[-h, --help]
```
## Beispiele
### Fügen Sie mithilfe des `cluster-id`-Parameters einen Cluster hinzu
**Example**
Verwenden Sie den **configure-pkcs11 add-cluster** zusammen mit dem `cluster-id`-Parameter, um Ihrer Konfiguration einen Cluster (mit der ID von `cluster-1234567`) hinzuzufügen.
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 add-cluster --cluster-id
```
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" add-cluster --cluster-id
```
**Tipp**
Wenn die Verwendung von **configure-pkcs11 add-cluster** mit dem `cluster-id`-Parameter nicht dazu führt, dass der Cluster hinzugefügt wird, finden Sie im folgenden Beispiel eine längere Version dieses Befehls, die auch die Parameter `--region` und `--endpoint` zur Identifizierung des hinzugefügten Clusters erfordert. Wenn zum Beispiel die Region des Clusters eine andere ist als die, die als Standard für Ihre AWS CLI konfiguriert ist, sollten Sie den `--region`-Parameter verwenden, um die richtige Region zu verwenden. Darüber hinaus haben Sie die Möglichkeit, den AWS CloudHSM API-Endpunkt anzugeben, der für den Anruf verwendet werden soll. Dies kann für verschiedene Netzwerkkonfigurationen erforderlich sein, z. B. für die Verwendung von VPC-Schnittstellenendpunkten, für die nicht den Standard-DNS-Hostnamen verwendet wird. AWS CloudHSM
### Fügen Sie einen Cluster mit den Parametern `cluster-id`, `endpoint`, und `region` hinzu
**Example**
Verwenden Sie **configure-pkcs11 add-cluster** zusammen mit den Parametern `cluster-id`, `endpoint` und `region`, um Ihrer Konfiguration einen Cluster (mit der ID von `cluster-1234567`) hinzuzufügen.
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 add-cluster --cluster-id --region --endpoint
```
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" add-cluster --cluster-id --region --endpoint
```
Weitere Hinweise zu den Parametern `--cluster-id`, `--region` und `--endpoint` finden Sie unter [AWS CloudHSM Konfigurationsparameter für das Client-SDK 5](configure-tool-params5.md).
## Parameters
**--cluster-id ****
Führt einen `DescribeClusters`-Aufruf aus, um alle IP-Adressen der HSM-Elastic-Network-Schnittstelle (ENI) im Cluster mit der Cluster-ID zu finden. Das System fügt die ENI-IP-Adressen zu den AWS CloudHSM Konfigurationsdateien hinzu.
Wenn Sie den `--cluster-id` Parameter von einer EC2-Instance innerhalb einer VPC verwenden, die keinen Zugriff auf das öffentliche Internet hat, müssen Sie einen VPC-Schnittstellen-Endpunkt erstellen, mit dem Sie eine Verbindung herstellen können. AWS CloudHSM Weitere Informationen über VPC-Endpunkte finden Sie unter [AWS CloudHSM und VPC-Endpunkte](cloudhsm-vpc-endpoint.md).
Erforderlich: Ja
**--endpoint ****
Geben Sie den AWS CloudHSM API-Endpunkt an, der für den `DescribeClusters` Aufruf verwendet wird. Sie müssen diese Option in Kombination mit `--cluster-id` festlegen.
Erforderlich: Nein
**--hsm-ca-cert ****
Gibt den Dateipfad zum HSM-CA-Zertifikat an.
Erforderlich: Nein
**--region ****
Geben Sie die Region Ihres Clusters an. Sie müssen diese Option in Kombination mit `--cluster-id` festlegen.
Wenn Sie den `--region`-Parameter nicht angeben, wählt das System die Region aus, indem es versucht, die Umgebungsvariablen `AWS_DEFAULT_REGION` oder `AWS_REGION` zu lesen. Wenn diese Variablen nicht festgelegt sind, überprüft das System die Region, die Ihrem Profil in Ihrer AWS-Config-Datei zugeordnet ist (normalerweise `~/.aws/config`), sofern Sie in der `AWS_CONFIG_FILE`-Umgebungsvariable keine andere Datei angegeben haben. Wenn keine der oben genannten Optionen festgelegt ist, verwendet das System standardmäßig die `us-east-1`-Region.
Erforderlich: Nein
**-- -Datei client-cert-hsm-tls ****
Pfad zum Client-Zertifikat, das für die gegenseitige Authentifizierung zwischen TLS Client und HSM verwendet wird.
Verwenden Sie diese Option nur, wenn Sie mindestens einen Vertrauensanker auf HSM mit CloudHSM CLI registriert haben. Sie müssen diese Option in Kombination mit `--client-key-hsm-tls-file` festlegen.
Erforderlich: Nein
**-- -Datei client-key-hsm-tls ****
Pfad zum Client-Schlüssel, der für die gegenseitige Authentifizierung zwischen TLS Client und HSM verwendet wird.
Verwenden Sie diese Option nur, wenn Sie mindestens einen Vertrauensanker auf HSM mit CloudHSM CLI registriert haben. Sie müssen diese Option in Kombination mit `--client-cert-hsm-tls-file` festlegen.
Erforderlich: Nein
# Entfernen Sie einen Cluster mit Multi-Slot-Funktionalität für AWS CloudHSM
Wenn Sie [mit PKCS \$111 eine Verbindung zu mehreren Steckplätzen herstellen](pkcs11-library-configs-multi-slot.md), verwenden Sie den **configure-pkcs11 remove-cluster**-Befehl, um einen Cluster aus den verfügbaren PKCS \$111-Steckplätzen zu entfernen.
## Syntax
```
configure-pkcs11 remove-cluster [OPTIONS]
--cluster-id
[-h, --help]
```
## Beispiele
### Entfernen Sie mithilfe des `cluster-id`-Parameters einen Cluster
**Example**
Verwenden Sie den **configure-pkcs11 remove-cluster** zusammen mit dem `cluster-id`-Parameter, um aus Ihrer Konfiguration einen Cluster (mit der ID von `cluster-1234567`) zu entfernen.
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 remove-cluster --cluster-id
```
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" remove-cluster --cluster-id
```
Weitere Informationen zum Parameter `--cluster-id` erhalten Sie unter [AWS CloudHSM Konfigurationsparameter für das Client-SDK 5](configure-tool-params5.md).
## Parameter
**--cluster-id ****
Die ID des Clusters, der aus der Konfiguration entfernt werden soll
Erforderlich: Ja
# Wiederholen Sie die Befehle für die PKCS \$111 -Bibliothek 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-pkcs11 --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-pkcs11.exe" --default-retry-mode off
```
------
# Speicherung von Zertifikaten mit der PKCS \$111 -Bibliothek
Die AWS CloudHSM PKCS \$111 -Bibliothek unterstützt das Speichern von Zertifikaten mit öffentlichen Schlüsseln als „öffentliche Objekte“ (wie in PKCS \$111 2.40 definiert) auf hsm2m.medium-Clustern. Diese Funktion ermöglicht sowohl öffentlichen als auch privaten PKCS \$111 -Sitzungen das Erstellen, Abrufen, Ändern und Löschen von Zertifikaten mit öffentlichem Schlüssel.
Um den Zertifikatsspeicher mit der PKCS \$111 -Bibliothek zu verwenden, müssen Sie ihn in Ihrer Client-Konfiguration aktivieren. Nach der Aktivierung können Sie Zertifikatsobjekte von Ihren PKCS \$111 -Anwendungen aus verwalten. Bei Vorgängen, die sowohl für Zertifikate als auch für Schlüsselobjekte gelten, z. B. [C\$1 FindObjects](http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/os/pkcs11-base-v2.40-os.html#_Toc323205461), werden Ergebnisse sowohl aus dem Schlüssel- als auch aus dem Zertifikatsspeicher zurückgegeben.
**Topics**
+ [Zertifikatsspeicher aktivieren](pkcs11-certificate-storage-configuration.md)
+ [API zur Speicherung von Zertifikaten](pkcs11-certificate-storage-api.md)
+ [Attribute des Zertifikats](pkcs11-certificate-storage-attributes.md)
+ [Auditprotokolle für die Speicherung von Zertifikaten](pkcs11-certificate-storage-audit-logs.md)
# Zertifikatsspeicher aktivieren
Sie können die Zertifikatsspeicherung auf hsm2m.medium-Clustern mithilfe des Bibliothekskonfigurationstools PKCS \$111 aktivieren. Diese Funktion ist in den SDK-Versionen 5.13 und höher verfügbar. Eine Liste der Operationen, die den Zertifikatsobjekttyp unterstützen, finden Sie unter[API-Operationen zur Speicherung von Zertifikaten](pkcs11-certificate-storage-api.md).
Gehen Sie für Ihr Betriebssystem wie folgt vor, um die Zertifikatsspeicherung zu aktivieren:
------
#### [ Linux ]
+
****Aktivieren Sie den Zertifikatsspeicher****
Führen Sie den folgenden Befehl aus:
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 --enable-certificate-storage
```
------
#### [ Windows ]
+
****Aktivieren Sie den Zertifikatsspeicher****
Öffnen Sie eine Eingabeaufforderung und führen Sie den folgenden Befehl aus:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" --enable-certificate-storage
```
------
# API-Operationen zur Speicherung von Zertifikaten
Die folgenden PKCS \$111 -Operationen unterstützen den Zertifikatsobjekttyp (`CKO_CERTIFICATE`):
## Allgemeine Zertifikatsoperationen
**`C_CreateObject`**
Erstellt ein neues Zertifikatsobjekt.
**`C_DestroyObject`**
Löscht ein vorhandenes Zertifikatsobjekt.
**`C_GetAttributeValue`**
Ruft den Wert eines oder mehrerer Attribute eines Zertifikatsobjekts ab.
**`C_SetAttributeValue`**
Aktualisiert den Wert eines oder mehrerer Attribute eines Zertifikatsobjekts.
## Suchvorgänge für Zertifikatsobjekte
**`C_FindObjectsInit`**
Startet eine Suche nach Zertifikatsobjekten.
**`C_FindObjects`**
Setzt die Suche nach Zertifikatsobjekten fort.
**`C_FindObjectsFinal`**
Beendet die Suche nach Zertifikatsobjekten.
# Speicherattribute für Zertifikate
In der folgenden Tabelle sind die unterstützten Zertifikatsobjektattribute und ihre Werte aufgeführt:
| Attribut | Standardwert | Description |
| --- | --- | --- |
| `CKA_CLASS` | Erforderlich | Der Wert muss `CKO_CERTIFICATE` sein. |
| `CKA_TOKEN` | Wahr | Der Wert muss `True` sein. |
| `CKA_MODIFIABLE` | Wahr | Der Wert muss `True` sein. |
| `CKA_PRIVATE` | Falsch | Der Wert muss `False` sein. |
| `CKA_LABEL` | Leer | Beschränkt auf 127 Zeichen. |
| `CKA_COPYABLE` | Falsch | Der Wert muss `False` sein. |
| `CKA_DESTROYABLE` | Wahr | Der Wert muss `True` sein. |
| `CKA_CERTIFICATE_TYPE` | Erforderlich | Der Wert muss `CKC_X_509` sein. |
| `CKA_TRUSTED` | Falsch | Der Wert muss `False` sein. |
| `CKA_CERTIFICATE_CATEGORY` | `CK_CERTIFICATE_CATEGORY_UNSPECIFIED` | Der Wert muss `CK_CERTIFICATE_CATEGORY_UNSPECIFIED` sein. |
| `CKA_CHECK_VALUE` | Abgeleitet von `CKA_VALUE` | Automatisch festgelegt basierend auf`CKA_VALUE`. |
| `CKA_START_DATE` | Leer | Das Datum „nicht vor“ des Zertifikats. |
| `CKA_END_DATE` | Leer | Das Datum „nicht danach“ des Zertifikats. |
| `CKA_PUBLIC_KEY_INFO` | Leer | Die maximale Größe beträgt 16 Kilobyte. |
| `CKA_SUBJECT` | Erforderlich | Der Betreff des Zertifikats. |
| `CKA_ID` | Leer | Die maximale Größe beträgt 128 Byte. Eindeutigkeit wird nicht erzwungen. |
| `CKA_ISSUER` | Leer | Der Zertifikatsaussteller. |
| `CKA_SERIAL_NUMBER` | Leer | Die Seriennummer des Zertifikats. |
| `CKA_VALUE` | Erforderlich | Die maximale Größe beträgt 32 Kilobyte. |
# Auditprotokolle für die Speicherung von Zertifikaten
AWS CloudHSM schreibt Prüfprotokolle für Zertifikatsspeichervorgänge, die Daten ändern, in einen separaten Amazon CloudWatch Events-Protokollstream innerhalb der CloudWatch Protokollgruppe Ihres Clusters. Dieser Protokollstream ist nach dem Cluster benannt, nicht nach einem bestimmten HSM innerhalb des Clusters.
Hinweise zum Zugriff auf Audit-Logs in finden Sie CloudWatch unter[Arbeiten mit Amazon CloudWatch Logs und AWS CloudHSM Audit Logs](get-hsm-audit-logs-using-cloudwatch.md).
## Felder für Protokolleinträge
`object_handle`
Die eindeutige Kennung des Zertifikatsobjekts.
`op_code`
Der Vorgang wurde ausgeführt oder versucht. Mögliche Werte:
+ `CreateObject`
+ `DestroyObject`
+ `SetAttributeValues`
`response`
`OK`wenn der Vorgang erfolgreich war oder einer der folgenden Fehlertypen vorliegt:
+ `DuplicateAttribute`
+ `InvalidAttributeValue`
+ `ObjectNotFound`
+ `MaxObjectsReached`
+ `InternalFailure`
`attributes`
Die Attribute wurden, falls vorhanden, geändert.
`timestamp`
Die Zeit, zu der die Operation stattfand, in Millisekunden seit der Unix-Epoche.
## Prüfungsprotokollbeispiele
### CreateObject Beispiel
```
{
"object_handle": 463180677312929947,
"op_code": "CreateObject",
"response": "OK",
"attributes": null,
"timestamp": 1725482483671
}
```
### DestroyObject Beispiel
```
{
"object_handle": 463180677312929947,
"op_code": "DestroyObject",
"response": "OK",
"attributes": null,
"timestamp": 1725482484559
}
```
### SetAttributeValues Beispiel
```
{
"object_handle": 463180678453346687,
"op_code": "SetAttributeValues",
"response": "OK",
"attributes": [
"Label"
],
"timestamp": 1725482488004
}
```
### Erfolgloses CreateObject Beispiel
```
{
"object_handle": null,
"op_code": "CreateObject",
"response": "MaxObjectsReached",
"attributes": null,
"timestamp": 1726084937125
}
```
# OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5
Mit der AWS CloudHSM OpenSSL Dynamic Engine können Sie kryptografische Operationen über die OpenSSL-API auf Ihren CloudHSM-Cluster auslagern.
AWS CloudHSM stellt eine OpenSSL Dynamic Engine bereit, über die Sie in [AWS CloudHSM SSL/TLS-Offload unter Linux mit Tomcat mit JSSE](third-offload-linux-jsse.md) oder [AWS CloudHSM SSL/TLS-Offload unter Linux mit NGINX oder Apache mit OpenSSL](third-offload-linux-openssl.md) nachlesen können. Ein Beispiel zur Verwendung AWS CloudHSM mit OpenSSL finden Sie in [diesem AWS-Sicherheitsblog](https://aws.amazon.com/blogs/security/automate-the-deployment-of-an-nginx-web-service-using-amazon-ecs-with-tls-offload-in-cloudhsm/). Informationen zur Plattformunterstützung für finden Sie SDKs unter[AWS CloudHSM Client SDK 5 unterstützte Plattformen](client-supported-platforms.md). Informationen zur Problembehandlung finden Sie unter[Bekannte Probleme mit der OpenSSL Dynamic Engine für AWS CloudHSM](ki-openssl-sdk.md).
Verwenden Sie die folgenden Abschnitte, um die AWS CloudHSM dynamische Engine für OpenSSL mithilfe des Client SDK 5 zu installieren und zu konfigurieren.
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 die OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5](openssl5-install.md)
+ [Unterstützte Schlüsseltypen für OpenSSL Dynamic Engine for AWS CloudHSM Client SDK 5](openssl-key-types.md)
+ [Unterstützte Mechanismen für OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5](openssl-mechanisms.md)
+ [Erweiterte Konfigurationen für OpenSSL für AWS CloudHSM](openssl-library-configs.md)
# Installieren Sie die OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5
Verwenden Sie die folgenden Abschnitte, um die OpenSSL Dynamic Engine for AWS CloudHSM Client SDK 5 zu installieren.
**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).
**Zum Installieren und Konfigurieren von OpenSSL Dynamic Engine**
1. Verwenden Sie die folgenden Befehle zum Herunterladen und Installieren der OpenSSL-Engine.
------
#### [ Amazon Linux 2023 ]
Installieren Sie die OpenSSL Dynamic Engine für Amazon Linux 2023 auf einer x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-dyn-latest.amzn2023.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.amzn2023.x86_64.rpm
```
Installieren Sie die OpenSSL Dynamic Engine für Amazon Linux 2023 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-dyn-latest.amzn2023.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.amzn2023.aarch64.rpm
```
------
#### [ Amazon Linux 2 ]
Installieren Sie die OpenSSL Dynamic Engine für Amazon Linux 2 auf einer x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-dyn-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el7.x86_64.rpm
```
Installieren Sie die OpenSSL Dynamic Engine für Amazon Linux 2 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-dyn-latest.el7.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el7.aarch64.rpm
```
------
#### [ RHEL 9 (9.2\$1) ]
Installieren Sie die OpenSSL Dynamic Engine für RHEL 9 auf einer x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-dyn-latest.el9.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el9.x86_64.rpm
```
Installieren Sie die OpenSSL Dynamic Engine für RHEL 9 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-dyn-latest.el9.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el9.aarch64.rpm
```
------
#### [ RHEL 8 (8.3\$1) ]
Installieren Sie die OpenSSL Dynamic Engine für RHEL 8 auf einer x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-dyn-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el8.x86_64.rpm
```
Installieren Sie die OpenSSL Dynamic Engine für RHEL 8 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-dyn-latest.el8.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el8.aarch64.rpm
```
------
#### [ Ubuntu 24.04 LTS ]
Installieren Sie die OpenSSL Dynamic Engine für Ubuntu 24.04 LTS auf der x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-dyn_latest_u24.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-dyn_latest_u24.04_amd64.deb
```
Installieren Sie die OpenSSL Dynamic Engine für Ubuntu 24.04 LTS auf der Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-dyn_latest_u24.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-dyn_latest_u24.04_arm64.deb
```
------
#### [ Ubuntu 22.04 LTS ]
Installieren Sie die OpenSSL Dynamic Engine für Ubuntu 22.04 LTS auf der x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-dyn_latest_u22.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-dyn_latest_u22.04_amd64.deb
```
Installieren Sie die OpenSSL Dynamic Engine für Ubuntu 22.04 LTS auf der Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-dyn_latest_u22.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-dyn_latest_u22.04_arm64.deb
```
------
Sie haben die gemeinsam genutzte Bibliothek für die Dynamic Engine unter `/opt/cloudhsm/lib/libcloudhsm_openssl_engine.so` installiert.
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. Legen Sie eine Umgebungsvariable mit den Anmeldeinformationen eines Crypto-Benutzers (CU) fest. Hinweise zum Erstellen CUs finden Sie unter. [Einen AWS CloudHSM Benutzer mit CloudHSM CLI erstellen](cloudhsm_cli-user-create.md)
```
$ export CLOUDHSM_PIN=:
```
**Anmerkung**
Das Client-SDK 5 führt die `CLOUDHSM_PIN`-Umgebungsvariable zum Speichern der Anmeldeinformationen der CU ein. Im Client-SDK 3 speichern Sie die CU-Anmeldeinformationen in der `n3fips_password`-Umgebungsvariable. Client-SDK 5 unterstützt beide Umgebungsvariablen, wir empfehlen jedoch, `CLOUDHSM_PIN` zu verwenden.
Beim Setzen von `CLOUDHSM_PIN` Umgebungsvariablen müssen Sie alle Sonderzeichen maskieren, die von Ihrer Shell interpretiert werden könnten.
1. Verbinden Sie Ihre Installation von OpenSSL Dynamic Engine mit dem Cluster. Weitere Informationen finden Sie unter [Verbinden mit dem Cluster](cluster-connect.md).
1. Bootstrap für das Client-SDK 5. Weitere Informationen finden Sie unter [Bootstrap für das Client-SDK](cluster-connect.md#connect-how-to).
## Überprüfen Sie die OpenSSL Dynamic Engine für Client-SDK 5
Verwenden Sie den folgenden Befehl, um Ihre Installation der OpenSSL Dynamic Engine zu überprüfen.
```
$ openssl engine -t cloudhsm
```
Die folgende Ausgabe verifiziert Ihre Konfiguration:
```
(cloudhsm) CloudHSM OpenSSL Engine
[ available ]
```
# Unterstützte Schlüsseltypen für OpenSSL Dynamic Engine for AWS CloudHSM Client SDK 5
Die AWS CloudHSM OpenSSL Dynamic Engine unterstützt die folgenden Schlüsseltypen mit Client SDK 5.
****
| Schlüsseltyp | Description |
| --- | --- |
| EC | ECDSA sign/verify für die Schlüsseltypen P-256, P-384 und secp256k1. Informationen zum Generieren von EC-Schlüsseln, die mit der OpenSSL-Engine kompatibel sind, finden Sie unter [Exportieren Sie einen asymmetrischen Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-file.md). |
| RSA | Generierung von RSA-Schlüsseln für 2048-, 3072- und 4096-Bit-Schlüssel. RSA-Signieren/Verifizieren. Die Überprüfung wird auf die OpenSSL-Software übertragen. |
# Unterstützte Mechanismen für OpenSSL Dynamic Engine für AWS CloudHSM Client SDK 5
Die AWS CloudHSM OpenSSL Dynamic Engine unterstützt die folgenden Mechanismen für Sign- und Verify-Funktionen mit Client SDK 5.
## Funktionen zum Signieren und Überprüfen
Mit Client-SDK 5 werden die Daten lokal in der Software gehasht. Das bedeutet, dass die Größe der Daten, die gehasht werden können, unbegrenzt ist.
RSA-Signaturtypen
+ SHA1withRSA
+ SHA224withRSA
+ SHA256withRSA
+ SHA384withRSA
+ SHA512withRSA
ECDSA-Signaturtypen
+ SHA1withECDSA
+ SHA224withECDSA
+ SHA256withECDSA
+ SHA384withECDSA
+ SHA512withECDSA
# Erweiterte Konfigurationen für OpenSSL für AWS CloudHSM
Der AWS CloudHSM OpenSSL-Anbieter beinhaltet die folgende erweiterte Konfiguration, die nicht Teil der allgemeinen Konfigurationen ist, die die meisten Kunden verwenden. Diese Konfigurationen bieten zusätzliche Funktionen.
+ [Wiederholungsbefehle für OpenSSL](openssl-library-configs-retry.md)
# Befehle für OpenSSL 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
Sie können den folgenden Befehl verwenden, um Wiederholungsbefehle in den **off**-Modus zu setzen:
```
$ sudo /opt/cloudhsm/bin/configure-dyn --default-retry-mode off
```
# OpenSSL-Anbieter für AWS CloudHSM Client SDK 5
Mit dem AWS CloudHSM OpenSSL Provider können Sie kryptografische TLS-Operationen über die OpenSSL Provider-API auf Ihren CloudHSM-Cluster auslagern. Die Provider-Schnittstelle ist der empfohlene Ansatz für neue Bereitstellungen mit OpenSSL 3.2 und höher.
Verwenden Sie die folgenden Abschnitte, um den AWS CloudHSM OpenSSL Provider mithilfe des Client SDK 5 zu installieren und zu konfigurieren.
**Warnung**
Die Integration mit OpenSSL CLI wird derzeit vom AWS CloudHSM OpenSSL Provider nicht unterstützt. Informationen zu unterstützten [AWS CloudHSM SSL/TLS-Offload unter Linux mit NGINX oder mit OpenSSL Provider HAProxy](third-offload-linux-openssl-provider.md) Integrationen finden Sie unter.
## Unterstützte Plattformen
Der OpenSSL Provider benötigt OpenSSL 3.2 oder höher, verfügbar auf EL9 \$1, Ubuntu 24.04\$1 und Amazon Linux 2023\$1.
Überprüfen Sie die Kompatibilität: `openssl version`
**Topics**
+ [Unterstützte Plattformen](#openssl-provider-supported-platforms)
+ [Installieren Sie den OpenSSL Provider für AWS CloudHSM Client SDK 5](openssl-provider-install.md)
+ [Unterstützte Schlüsseltypen für OpenSSL Provider for AWS CloudHSM Client SDK 5](openssl-provider-key-types.md)
+ [Von OpenSSL Providern unterstützte Mechanismen](openssl-provider-mechanisms.md)
+ [Erweiterte Konfiguration des OpenSSL-Anbieters](openssl-provider-advanced-config.md)
# Installieren Sie den OpenSSL Provider für AWS CloudHSM Client SDK 5
Verwenden Sie die folgenden Abschnitte, um den OpenSSL Provider for AWS CloudHSM Client SDK 5 zu installieren.
**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](working-client-sync.md#client-sync-sdk8) und [Client-SDK-5-Configure-Tool](configure-sdk-5.md).
## Voraussetzungen
Der OpenSSL Provider benötigt die Clustertypen **hsm2m.medium** und mindestens CloudHSM Client SDK Version 5.17.0 oder höher.
## Installieren Sie den OpenSSL Provider
**Um den OpenSSL Provider zu installieren**
1. Verwenden Sie die folgenden Befehle, um den OpenSSL Provider herunterzuladen und zu installieren.
------
#### [ Amazon Linux 2023 ]
Installieren Sie den OpenSSL Provider für Amazon Linux 2023 auf der x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-openssl-provider-latest.amzn2023.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.amzn2023.x86_64.rpm
```
Installieren Sie den OpenSSL Provider für Amazon Linux 2023 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-openssl-provider-latest.amzn2023.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.amzn2023.aarch64.rpm
```
------
#### [ RHEL 9 (9.2\$1) ]
Installieren Sie den OpenSSL Provider für RHEL 9 auf einer x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-openssl-provider-latest.el9.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.el9.x86_64.rpm
```
Installieren Sie den OpenSSL Provider für RHEL 9 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-openssl-provider-latest.el9.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.el9.aarch64.rpm
```
------
#### [ RHEL 10 (10.0\$1) ]
Installieren Sie den OpenSSL Provider für RHEL 10 auf einer x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-openssl-provider-latest.el10.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.el10.x86_64.rpm
```
Installieren Sie den OpenSSL Provider für RHEL 10 auf der ARM64 Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-openssl-provider-latest.el10.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.el10.aarch64.rpm
```
------
#### [ Ubuntu 24.04 ]
Installieren Sie den OpenSSL Provider für Ubuntu 24.04 auf der x86\$164-Architektur:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-openssl-provider_latest_u24.04_amd64.deb
```
```
$ sudo dpkg -i ./cloudhsm-openssl-provider_latest_u24.04_amd64.deb
```
Installieren Sie den OpenSSL Provider für Ubuntu 24.04 auf der Architektur: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-openssl-provider_latest_u24.04_arm64.deb
```
```
$ sudo dpkg -i ./cloudhsm-openssl-provider_latest_u24.04_arm64.deb
```
------
Sie haben die Shared Library für den OpenSSL Provider unter `/opt/cloudhsm/lib/licloudhsm_openssl_provider.so` installiert.
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. Stellen Sie die `CLOUDHSM_PIN` Umgebungsvariable mit Ihren Crypto-Benutzeranmeldedaten (CU) ein:
```
$ export CLOUDHSM_PIN=:
```
1. Connect Sie Ihre Installation von OpenSSL Provider mit dem Cluster. Weitere Informationen finden Sie unter [Verbinden mit dem Cluster](cluster-connect.md).
## Überprüfen der Installation
Stellen Sie sicher, dass der OpenSSL Provider korrekt installiert ist:
```
$ CLOUDHSM_PIN=: openssl list -providers -provider cloudhsm
```
Sie sollten eine Ausgabe sehen, die der folgenden ähnelt:
```
Providers:
cloudhsm
name: AWS CloudHSM OpenSSL Provider
version: 5.17.0
status: active
default
name: OpenSSL Default Provider
version: 3.2.2
status: active
```
# Unterstützte Schlüsseltypen für OpenSSL Provider for AWS CloudHSM Client SDK 5
Der AWS CloudHSM OpenSSL Provider unterstützt die folgenden Schlüsseltypen mit Client SDK 5.
****
| Schlüsseltyp | Description |
| --- | --- |
| RSA | RSA sign/verify - und asymmetrische Verschlüsselungsoperationen. Die Überprüfung wird auf die OpenSSL-Software übertragen. Informationen zum Generieren von RSA-Schlüsseln, die mit dem OpenSSL Provider kompatibel sind, finden Sie unter. [Exportieren Sie einen asymmetrischen Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-file.md) |
| EC | ECDSA sign/verify für P-256-, P-384- und P-521-Kurven. Die Überprüfung wird auf die OpenSSL-Software übertragen. Informationen zum Generieren von EC-Schlüsseln, die mit dem OpenSSL Provider kompatibel sind, finden Sie unter. [Exportieren Sie einen asymmetrischen Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-file.md) |
# Von OpenSSL Providern unterstützte Mechanismen
Das AWS CloudHSM OpenSSL Provider SDK unterstützt einen umfassenden Satz kryptografischer Mechanismen für verschiedene Operationen, darunter digitale Signaturen, asymmetrische Verschlüsselung, symmetrische Verschlüsselung, Schlüsselaustausch und mehr.
## RSA-Signaturtypen
Der OpenSSL Provider unterstützt digitale RSA-Signaturen mit mehreren Hash-Algorithmen und Padding-Schemata:
SHA1withRSA
RSA-Signaturen mit dem SHA-1-Hash-Algorithmus
+ PKCS \$11 v1.5-Polsterung
+ PSS-Polsterung (Probabilistisches Signaturschema)
SHA224withRSA
RSA-Signaturen mit dem SHA-224-Hash-Algorithmus
+ PKCS \$11 v1.5-Polsterung
+ PSS-Polsterung
SHA256withRSA
RSA-Signaturen mit dem SHA-256-Hash-Algorithmus
+ PKCS \$11 v1.5-Polsterung
+ PSS-Polsterung
SHA384withRSA
RSA-Signaturen mit dem SHA-384-Hash-Algorithmus
+ PKCS \$11 v1.5-Polsterung
+ PSS-Polsterung
SHA512withRSA
RSA-Signaturen mit dem SHA-512-Hash-Algorithmus
+ PKCS \$11 v1.5-Polsterung
+ PSS-Polsterung
## ECDSA-Signaturtypen
Der OpenSSL Provider unterstützt digitale ECDSA-Signaturen mit mehreren Hash-Algorithmen:
SHA1withECDSA
ECDSA-Signaturen mit dem SHA-1-Hash-Algorithmus
SHA224withECDSA
ECDSA-Signaturen mit dem SHA-224-Hash-Algorithmus
SHA256withECDSA
ECDSA-Signaturen mit dem SHA-256-Hash-Algorithmus
SHA384withECDSA
ECDSA-Signaturen mit dem SHA-384-Hash-Algorithmus
SHA512withECDSA
ECDSA-Signaturen mit dem SHA-512-Hash-Algorithmus
# Erweiterte Konfiguration des OpenSSL-Anbieters
Das AWS CloudHSM OpenSSL Provider SDK bietet erweiterte Konfigurationsoptionen, um sein Verhalten an verschiedene Anwendungsfälle und Umgebungen anzupassen. Verwenden Sie das Konfigurationstool, um diese Optionen festzulegen.
+ [Konfiguration für OpenSSL Provider erneut versuchen](openssl-provider-configs-retry.md)
# Wiederholen Sie die Befehle für OpenSSL Provider 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-openssl-provider --default-retry-mode off
```
------
# Schlüsselspeicheranbieter (KSP) für AWS CloudHSM Client SDK 5
Key Storage Provider (KSP) ist eine kryptografische API, die für das Microsoft Windows-Betriebssystem spezifisch ist. Mit Key Storage Provider (KSP) können Entwickler kryptografische Techniken verwenden, um Windows-basierte Anwendungen zu sichern.
Informationen zu Bootstrapping finden Sie unter [Verbinden mit dem Cluster](cluster-connect.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 Key Storage Provider (KSP) für AWS CloudHSM Client SDK 5](ksp-library-install.md)
+ [Authentifizieren Sie sich beim Key Storage Provider (KSP) für AWS CloudHSM Client SDK 5](ksp-library-authentication.md)
+ [Unterstützte Schlüsseltypen für Key Storage Provider (KSP) für AWS CloudHSM Client SDK 5](ksp-library--key-types.md)
+ [Unterstützte API-Operationen Key Storage Provider (KSP) für AWS CloudHSM Client SDK 5](ksp-library-apis.md)
+ [Erweiterte Konfigurationen für KSP für AWS CloudHSM](ksp-library-configs.md)
# Installieren Sie den Key Storage Provider (KSP) für AWS CloudHSM Client SDK 5
Verwenden Sie die folgenden Abschnitte, um den Key Storage Provider (KSP) für das AWS CloudHSM Client SDK 5 zu installieren.
**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).
**So installieren und konfigurieren Sie den Key Storage Provider (KSP)**
1. Installieren Sie den Key Storage Provider (KSP) für Windows Server auf einer 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/AWSCloudHSMKSP-latest.msi -Outfile C:\AWSCloudHSMKSP-latest.msi
```
```
PS C:\> Start-Process msiexec.exe -ArgumentList '/i C:\AWSCloudHSMKSP-latest.msi /quiet /norestart /log C:\client-install.txt' -Wait
```
1. Verwenden Sie das Configure-Tool, um den Speicherort des ausstellenden Zertifikats anzugeben. Detaillierte Anweisungen finden Sie unter [Geben Sie den Speicherort des ausstellenden Zertifikats an](cluster-connect.md#specify-cert-location).
1. Um eine Verbindung zu Ihrem Cluster herzustellen, siehe [Bootstrap für das Client-SDK](cluster-connect.md#connect-how-to).
1. Sie finden die KSP-Dateien (Key Storage Provider) an den folgenden Speicherorten:
+ Windows-Binärdateien:
```
C:\Program Files\Amazon\CloudHSM
```
Windows-Konfigurationsskripten und Protokolldateien:
```
C:\ProgramData\Amazon\CloudHSM
```
# Authentifizieren Sie sich beim Key Storage Provider (KSP) für AWS CloudHSM Client SDK 5
Bevor Sie den Key Storage Provider (KSP) für AWS CloudHSM Client SDK 5 verwenden, müssen Sie die Anmeldeinformationen für das HSM auf Ihrem System einrichten. Sie haben zwei Optionen:
+ Windows Credentials Manager (für mehr Sicherheit empfohlen)
+ Systemumgebungsvariablen (einfachere Einrichtung)
## Windows-Anmeldeinformationsverwaltung
Sie können Anmeldeinformationen entweder mit dem `set_cloudhsm_credentials` Hilfsprogramm oder mit der Windows Credentials Manager-Oberfläche einrichten.
+ **Verwenden des Dienstprogramms `set_cloudhsm_credentials`**:
Das Windows-Installationsprogramm enthält das `set_cloudhsm_credentials` Hilfsprogramm. Sie können dieses Dienstprogramm verwenden, um HSM-Anmeldeinformationen bequem an die Windows-Anmeldeinformationsverwaltung zu übergeben. Wenn Sie dieses Hilfsprogramm aus dem Quellcode kompilieren möchten, können Sie den im Installer enthaltenen Python-Code verwenden.
1. Navigieren Sie zu `C:\Program Files\Amazon\CloudHSM\tools\`.
1. Führen Sie den folgenden Befehl aus:
```
set_cloudhsm_credentials.exe --username --password
```
+ **Verwenden der Schnittstelle der Anmeldeinformationsverwaltung**:
1. Öffnen Sie den Credential Manager:
+ Geben Sie `credential manager` in das Suchfeld der Taskleiste Folgendes ein
+ Wählen Sie **Credential Manager**
1. Wählen Sie **Windows-Anmeldeinformationen** aus, um Windows-Anmeldeinformationen zu verwalten.
1. Wählen Sie **Generische Anmeldeinformationen hinzufügen**
1. Geben Sie folgende Details ein:
+ **Internet- oder Netzwerkadresse**:`CLOUDHSM_PIN`.
+ **Nutzername**:**.
+ **Passwort**:**.
1. Klicken Sie auf **OK**
## Systemumgebungsvariablen
Sie können Systemumgebungsvariablen festlegen, um Ihr HSM und Ihren [Crypto-Benutzer](understanding-users.md#crypto-user-chsm-cli) (CU) zu identifizieren.
**Warnung**
Wenn Sie Anmeldeinformationen über Systemumgebungsvariablen festlegen, wird Ihr Passwort im Klartext auf Ihrem System gespeichert. Verwenden Sie aus Sicherheitsgründen stattdessen den Windows Credential Manager.
Sie können Umgebungsvariablen wie folgt festlegen:
+ Das Tool [https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx).
+ Die **Windows-Systemeigenschaften-Systemsteuerung** (Registerkarte „**Erweitert**“).
+ legt permanente Systemumgebungsvariablen fest. [Programmatische](https://msdn.microsoft.com/en-us/library/system.environment.setenvironmentvariable(v=vs.110).aspx) Methoden.
So legen Sie die Systemumgebungsvariable fest:
**`CLOUDHSM_PIN=:`**
Identifiziert einen [Crypto-Benutzer](understanding-users.md#crypto-user-chsm-cli) (CU, Crypto User) im HSM und stellt alle erforderlichen Anmeldeinformationen bereit. Ihre Anwendung führt die Authentifizierung durch und wird als dieser CU ausgeführt. Die Anwendung verfügt über die Berechtigungen dieses CU und kann nur die Schlüssel anzeigen und verwalten, die sich im Besitz dieses CU befinden und von ihm freigegeben werden. Verwenden Sie den Befehl [user create in der CloudHSM-CLI, um eine neue CU zu erstellen](cloudhsm_cli-user-create.md). Verwenden Sie den Befehl [user list](cloudhsm_cli-user-list.md) in der CloudHSM-CLI CUs, um nach vorhandenen zu suchen.
Beispiel:
```
setx /m CLOUDHSM_PIN test_user:password123
```
**Anmerkung**
Beim Setzen von CLOUDHSM\$1PIN-Umgebungsvariablen müssen Sie alle Sonderzeichen maskieren, die von Ihrer Shell interpretiert werden könnten.
# Unterstützte Schlüsseltypen für Key Storage Provider (KSP) für AWS CloudHSM Client SDK 5
Der AWS CloudHSM Key Storage Provider (KSP) unterstützt die folgenden Schlüsseltypen mit dem Client SDK 5.
****
| Schlüsseltyp | Description |
| --- | --- |
| EC | Generieren Sie Schlüssel mit den Kurven secp256r1 (P-256), secp384r1 (P-384) und secp521r1 (P-521). |
| RSA | Generieren Sie 2048-, 3072- und 4096-Bit-RSA-Schlüssel. |
# Unterstützte API-Operationen Key Storage Provider (KSP) für AWS CloudHSM Client SDK 5
Die Parameter im KSP werden von Microsoft KSP definiert. Weitere Informationen finden Sie in der [Microsoft-Dokumentation](https://learn.microsoft.com/en-us/windows/win32/api/ncrypt/).
Der Key Storage Provider (KSP) unterstützt die folgenden KSP-API-Operationen für das AWS CloudHSM Client-SDK 5.
+ [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)
+ [NCryptOpenKey](ksp-library-apis-open-key.md)
+ [NCryptCreatePersistedKey](ksp-library-apis-create-persisted-key.md)
+ [NCryptGetProperty](ksp-library-apis-get-property.md)
+ [NCryptSetProperty](ksp-library-apis-set-property.md)
+ [NCryptFinalizeKey](ksp-library-apis-finalize-key.md)
+ [NCryptDeleteKey](ksp-library-apis-delete-key.md)
+ [NCryptFreeObject](ksp-library-apis-free-object.md)
+ [NCryptFreeBuffer](ksp-library-apis-free-buffer.md)
+ [NCryptIsAlgSupported](ksp-library-apis-is-alg-supported.md)
+ [NCryptEnumAlgorithms](ksp-library-apis-enum-algorithms.md)
+ [NCryptEnumKeys](ksp-library-apis-enum-keys.md)
+ [NCryptExportKey](ksp-library-apis-export-key.md)
+ [NCryptSignHash](ksp-library-apis-sign-hash.md)
+ [NCryptVerifySignature](ksp-library-apis-verify-signature.md)
# NCryptOpenStorageProvider Funktion mit Key Storage Provider (KSP)
Die `NCryptOpenStorageProvider` Funktion lädt und initialisiert den Key Storage Provider (KSP).
## Parameters
`phProvider`[aus]
Ein Zeiger auf eine `NCRYPT_PROV_HANDLE` Variable, die das Anbieter-Handle speichert.
`pszProviderName`[in]
Ein Zeiger auf eine mit Null terminierte Unicode-Zeichenfolge, die den Schlüsselspeicheranbieter identifiziert. AWS CloudHSM Key Storage Provider (KSP) unterstützt die folgenden Werte:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-open-provider.html)
Bei den Werten handelt es sich um Zeichenkettenliterale mit breiten Zeichen, wie durch L vor dem Literal angegeben.
`dwFlags`[in]
Flags, die das Verhalten der Funktion ändern. Für diese Funktion sind keine Flags definiert.
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
# NCryptOpenKey mit Key Storage Provider (KSP)
Die `NCryptOpenKey` Funktion öffnet einen Schlüssel, der im Key Storage Provider (KSP) vorhanden ist.
## Parameters
`hProvider`[in]
Das KSP-Handle, das den Schlüssel enthält. Verwenden Sie [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md), um das Handle zu erhalten.
`phKey`[raus]
Ein Zeiger auf eine `NCRYPT_KEY_HANDLE` Variable, die das Tastenkürzel speichert.
`pszKeyName`[in]
Ein Zeiger auf eine mit Null terminierte Unicode-Zeichenfolge, die den Schlüsselnamen enthält.
`dwLegacyKeySpec`[in, unbenutzt]
AWS CloudHSM Key Storage Provider (KSP) verwendet diesen Parameter nicht.
`dwFlags`[in]
Flags, die das Verhalten der Funktion ändern. Für diese Funktion sind keine Flags definiert.
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hProvider` |
| NET\$1BAD\$1KEYSET | Der angegebene Schlüsselname lieferte kein eindeutiges Ergebnis. |
# NCryptCreatePersistedKey mit Key Storage Provider (KSP)
Die `NCryptCreatePersistedKey` Funktion erstellt einen neuen Schlüssel und speichert ihn im Key Storage Provider (KSP). Sie können die [`NCryptSetProperty`](ksp-library-apis-set-property.md)Funktion verwenden, um ihre Eigenschaften nach der Erstellung festzulegen. Sie müssen anrufen, [`NCryptFinalizeKey`](ksp-library-apis-finalize-key.md)bevor Sie den Schlüssel verwenden können.
## Parameters
`hProvider`[rein]
Das Handle des Schlüsselspeicheranbieters, unter dem Sie den Schlüssel erstellen werden. Verwenden Sie [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md), um dieses Handle zu erhalten.
`phKey`[raus]
Die Adresse einer `NCRYPT_KEY_HANDLE` Variablen, die das Schlüssel-Handle speichert.
`pszAlgId`[in]
Ein Zeiger auf eine mit Null terminierte Unicode-Zeichenfolge, die den Bezeichner des kryptografischen Algorithmus für die Erstellung des Schlüssels angibt.
AWS CloudHSM Der Key Storage Provider (KSP) unterstützt die folgenden Algorithmen:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-create-persisted-key.html)
`pszKeyName`[rein, optional]
Ein Zeiger auf eine Unicode-Zeichenfolge mit Nullterminierung, die den Namen des Schlüssels enthält. Wenn dieser Parameter NULL ist, erstellt diese Funktion einen kurzlebigen Schlüssel, der nicht persistent ist.
`dwLegacyKeySpec`[in, unbenutzt]
AWS CloudHSM Key Storage Provider (KSP) verwendet diesen Parameter nicht.
`dwFlags`[in]
Flags, um das Verhalten der Funktion zu ändern. Verwenden Sie null oder mehr der folgenden Werte:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-create-persisted-key.html)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Die Funktion wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
| NTE\$1NOT\$1SUPPORTED | Der `pszAlgId` Parameter enthält einen Wert, der nicht unterstützt wird. |
| NTE\$1EXISTS | Ein Schlüssel mit dem angegebenen Namen ist bereits vorhanden und der Vorgang wurde nicht verwendet. ` NCRYPT_OVERWRITE_KEY_FLAG` |
# NCryptGetProperty mit Key Storage Provider (KSP)
Die `NCryptGetProperty` Funktion ruft Eigenschaftswerte für ein Schlüsselspeicherobjekt ab.
## Parameters
`hObject`[in]
Das Handle des Objekts, dessen Eigenschaft Sie abrufen möchten. Sie können Folgendes verwenden:
+ Ein Anbieter-Handle (`NCRYPT_PROV_HANDLE`)
+ Ein Schlüsselgriff (`NCRYPT_KEY_HANDLE`)
`pszProperty `[im]
Ein Zeiger auf eine Unicode-Zeichenfolge mit Nullterminierung, die den abzurufenden Eigenschaftsnamen enthält.
Bei der Verwendung `NCRYPT_PROV_HANDLE` unterstützt AWS CloudHSM Key Storage Provider (KSP) die folgenden KSP-Bezeichner:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
Bei der Verwendung `NCRYPT_KEY_HANDLE` unterstützt der AWS CloudHSM Key Storage Provider (KSP) die folgenden KSP-Identifikatoren:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
Bei Werten handelt es sich um Zeichenkettenliteral mit breiten Zeichen, wie durch L vor dem Literal angegeben.
`pbOutput`[aus]
Die Adresse eines Puffers zum Speichern des Eigenschaftswerts. Geben Sie die Puffergröße mit`cbOutput`.
Um die erforderliche Puffergröße zu ermitteln, setzen Sie diesen Parameter auf NULL. Die Funktion speichert die erforderliche Größe (in Byte) an dem Ort, auf den von zeigt`pcbResult`.
`cbOutput`[in]
Die Größe des `pbOutput` Puffers in Byte.
`pcbResult`[aus]
Ein Zeiger auf eine DWORD-Variable, die die Anzahl der in den `pbOutput` Puffer kopierten Byte speichert.
Wenn der Wert NULL `pbOutput` ist, wird die erforderliche Größe (in Byte) gespeichert.
`dwFlags`[in]
Flags, um das Verhalten der Funktion zu ändern. Sie können Null verwenden oder:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
Wenn pszProperty den Wert hat`NCRYPT_SECURITY_DESCR_PROPERTY`, verwenden Sie eine oder eine Kombination aus:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
| NTE\$1NOT\$1SUPPORTED | Der `pszAlgId` Parameter enthält einen Wert, der nicht unterstützt wird. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hObject` |
| NET\$1BUFFER\$1TOO\$1SMALL | Der `cbOutput` Parameter ist zu klein für Rückgabewerte. |
# NCryptSetProperty mit Key Storage Provider (KSP)
Die `NCryptSetProperty` Funktion legt Eigenschaftswerte für ein Schlüsselspeicherobjekt fest.
## Parameters
`hObject`[in]
Das Handle des Objekts, dessen Eigenschaft Sie festlegen möchten. Sie können Folgendes verwenden:
+ Ein Anbieter-Handle (`NCRYPT_PROV_HANDLE`)
+ Ein Schlüsselgriff (`NCRYPT_KEY_HANDLE`)
`pszProperty `[im]
Ein Zeiger auf eine Unicode-Zeichenfolge mit Nullterminierung, die den abzurufenden Eigenschaftsnamen enthält.
Bei der Verwendung `NCRYPT_PROV_HANDLE` unterstützt AWS CloudHSM Key Storage Provider (KSP) die folgenden KSP-Bezeichner:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-set-property.html)
Bei der Verwendung `NCRYPT_KEY_HANDLE` unterstützt AWS CloudHSM Key Storage Provider (KSP) die folgenden KSP-Bezeichner:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-set-property.html)
Bei den Werten handelt es sich um Zeichenkettenliteral mit breiten Zeichen, wie durch L vor dem Literal angegeben.
`pbInput`[in]
Die Adresse eines Puffers, der den neuen Eigenschaftswert enthält. `cbInput`enthält die Größe des Puffers.
`cbInput`[in]
Die Größe des `pbInput` Puffers in Byte.
`dwFlags`[in]
Flags, die das Verhalten der Funktion ändern. Für diese Funktion sind keine Flags definiert.
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
| NTE\$1NOT\$1SUPPORTED | Der `pszProperty` Parameter enthält einen Wert, der nicht unterstützt wird. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hObject` |
| NET\$1BAD\$1DATA | Die Daten, auf die verwiesen wird `pbInput` und die nicht gültig sind. `cbInput` |
# NCryptFinalizeKey mit Key Storage Provider (KSP)
Die `NCryptFinalizeKey` Funktion vervollständigt einen KSP-Schlüssel. Sie müssen diese Funktion aufrufen, bevor Sie die Taste verwenden können.
## Parameters
`hKey`[in]
Der Griff des Schlüssels, der abgeschlossen werden soll. Rufen Sie dieses Handle ab, indem Sie die [NCryptCreatePersistedKey](ksp-library-apis-create-persisted-key.md)Funktion aufrufen.
`dwFlags`[rein]
Flags, um das Verhalten der Funktion zu ändern. Sie können Null oder diese Werte verwenden:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-finalize-key.html)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hKey` |
| NET\$1NOT\$1SUPPORTED | Der `dwFlags` Parameter enthält einen Wert, der nicht unterstützt wird. |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
# NCryptDeleteKey mit Key Storage Provider (KSP)
Die `NCryptDeleteKey` Funktion löscht einen KSP-Schlüssel vom Key Storage Provider (KSP).
## Parameters
`hKey`[in]
Der Griff des Schlüssels, der gelöscht werden soll.
`dwFlags`[in]
Flags, um das Verhalten der Funktion zu ändern. Sie können null oder mehr der folgenden Werte verwenden:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-delete-key.html)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Die Funktion war erfolgreich. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hKey` |
| NET\$1INTERNAL\$1ERROR | Beim Löschen des Schlüssels ist ein interner Fehler aufgetreten. |
# NCryptFreeObject mit Key Storage Provider (KSP)
Die `NCryptFreeObject` Funktion gibt den Provider oder das Key-Handle vom Key Storage Provider (KSP) frei.
## Parameters
`hObject`[in]
Der Handle des Objekts, das freigegeben werden soll. Sie können Folgendes verwenden:
+ Ein Provider-Handle (`NCRYPT_PROV_HANDLE`)
+ Ein Schlüsselgriff (`NCRYPT_KEY_HANDLE`)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hObject` |
# NCryptFreeBuffer mit Key Storage Provider (KSP)
Die `NCryptFreeBuffer` Funktion gibt einen Speicherblock frei, der vom Key Storage Provider (KSP) zugewiesen wurde.
## Parameters
`pvInput`[in]
Die Adresse des Speichers, der freigegeben werden soll.
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
# NCryptIsAlgSupported mit Key Storage Provider (KSP)
NCryptIsAlgSupported Die Funktion bestimmt, ob der Key Storage Provider (KSP) einen bestimmten kryptografischen Algorithmus unterstützt.
## Parameters
`hProvider`[in]
Das Handle des Schlüsselspeicheranbieters. Verwenden Sie [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md), um das Handle zu bekommen.
`pszAlgId`[im]
Ein Zeiger auf eine mit Null terminierte Unicode-Zeichenfolge, die den Bezeichner des kryptografischen Algorithmus zur Erstellung des Schlüssels enthält. AWS CloudHSM Key Storage Provider (KSP) unterstützt die folgenden Algorithmen:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-is-alg-supported.html)
`dwFlags`[in]
Flags, die das Verhalten von Funktionen ändern. Dies kann Null oder der folgende Wert sein:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-is-alg-supported.html)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
| NTE\$1NOT\$1SUPPORTED | Der `pszAlgId` Parameter enthält einen Wert, der nicht unterstützt wird. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hProvider` |
# NCryptEnumAlgorithms mit Key Storage Provider (KSP)
Die `NCryptEnumAlgorithms` Funktion ruft die Namen der Algorithmen ab, die der Key Storage Provider (KSP) unterstützt.
## Parameters
`hProvider`[in]
Das Handle des Schlüsselspeicheranbieters, für den die Algorithmen aufgezählt werden sollen. Verwenden Sie die [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)Funktion, um dieses Handle abzurufen.
`dwAlgOperations`[in]
Eine Reihe von Werten, die angeben, welche Algorithmusklassen aufgezählt werden sollen. Sie können Null verwenden, um alle Algorithmen aufzuzählen, oder Sie können einen oder mehrere dieser Werte kombinieren:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-enum-algorithms.html)
`pdwAlgCount`[aus]
Die Adresse eines DWORD-Objekts, das die Anzahl der Elemente im `ppAlgList` Array speichert.
`ppAlgList`[aus]
Die Adresse eines `NCryptAlgorithmName` Strukturzeigers, der eine Reihe registrierter Algorithmusnamen speichert. Der `pdwAlgCount` Parameter gibt die Anzahl der Elemente in diesem Array an.
`dwFlags`[in]
Flags, um das Verhalten der Funktion zu ändern. Verwenden Sie Null oder den folgenden Wert:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-enum-algorithms.html)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
| NTE\$1NOT\$1SUPPORTED | Der `dwAlgOperations` Parameter enthält einen Wert, der nicht unterstützt wird. |
# NCryptEnumKeys mit Key Storage Provider (KSP)
NCryptEnumKeys Die Funktion listet die im Key Storage Provider (KSP) gespeicherten Schlüssel auf.
## Parameters
`hProvider`[in]
Das Handle des wichtigsten Speicheranbieters. Verwenden Sie [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md), um dieses Handle zu erhalten.
`pszScope`[rein, unbenutzt]
Setzen Sie diesen Parameter auf NULL.
`ppKeyName`[aus]
Eine Zeigeradresse auf eine `NCryptKeyName` Struktur, die den Schlüsselnamen speichert. Rufen Sie auf, um diesen Speicher nach dem Gebrauch wieder freizugeben`NCryptFreeBuffer`.
`ppEnumState`[rein, raus]
Eine VOID-Zeigeradresse, die den Fortschritt der Aufzählung verfolgt. Der Schlüsselspeicheranbieter verwendet diese Informationen intern, um die Aufzählungssequenz zu verwalten. Um eine neue Aufzählung von Anfang an zu beginnen, setzen Sie diesen Zeiger auf NULL.
Um diesen Speicher nach Abschluss der Aufzählung freizugeben, übergeben Sie diesen Zeiger an den. `NCryptFreeBuffer`
`dwFlags`[in]
Flags, um das Verhalten der Funktion zu ändern. Diese Funktion hat keine Flags.
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hProvider` |
| NET\$1NO\$1MORE\$1ITEMS | Die Aufzählung hat alle verfügbaren Schlüssel aufgelistet. |
# NCryptExportKey mit Key Storage Provider (KSP)
Die `NCryptExportKey` Funktion exportiert einen KSP-Schlüssel in einen Speicher. BLOB Diese Funktion unterstützt nur den Export von öffentlichen Schlüsseln.
## Parameters
`hKey`[in]
Das Handle des zu exportierenden Schlüssels.
`hExportKey`[drin, unbenutzt]
AWS CloudHSM Key Storage Provider (KSP) verwendet diesen Parameter nicht.
`pszBlobType`[in]
Eine Unicode-Zeichenfolge mit Nullabschluss, die den zu exportierenden BLOB Typ angibt. AWS CloudHSM Key Storage Provider (KSP) unterstützt die folgenden Werte:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-export-key.html)
`pParameterList`[drin, unbenutzt]
AWS CloudHSM Key Storage Provider (KSP) verwendet diesen Parameter nicht.
`pbOutput`[aus, optional]
Eine Pufferadresse zum Speichern des Schlüssels BLOB. Geben Sie die Puffergröße mit`cbOutput`. Wenn der Wert auf NULL gesetzt ist, speichert die Funktion die erforderliche Größe (in Byte) in dem DWORD, auf das verwiesen wird`pcbResult`.
`cbOutput`[in]
Die Größe des `pbOutput` Puffers in Byte.
`pcbResult`[aus]
Eine DWORD-Variablenadresse, die die Anzahl der in den `pbOutput` Puffer kopierten Byte speichert. Wenn NULL `pbOutput` ist, speichert die Funktion die erforderliche Puffergröße in Byte.
`dwFlags`[in]
Flags, die die Funktionsweise der Funktion ändern. Sie können Null oder Folgendes verwenden:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-export-key.html)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hProvider` |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
| NTE\$1BAD\$1KEY\$1STATE | Der Schlüsselstatus ist nicht gültig. |
| NET\$1NOT\$1SUPPORTED | Der `dwFlags` Parameter `pszBlobType` oder enthält einen nicht unterstützten Wert. |
| STATUS\$1INTERNAL\$1ERROR | Während des Vorgangs ist ein interner Fehler aufgetreten. |
# NCryptSignHash mit Key Storage Provider (KSP)
Die `NCryptSignHash` Funktion erstellt eine Signatur eines Hashwerts.
## Parameters
`hKey`[in]
Das Handle des Schlüssels, mit dem der Hash signiert werden soll.
`pPaddingInfo`[ein, optional]
Ein Zeiger auf eine Struktur, die Füllinformationen enthält. Der Strukturtyp hängt vom `dwFlags` Wert ab. Verwenden Sie diesen Parameter nur mit asymmetrischen Schlüsseln. Setzen Sie ihn für andere Schlüsseltypen auf NULL.
`pbHashValue`[in]
Ein Zeiger auf einen Puffer, der den zu signierenden Hashwert enthält. Geben Sie die Puffergröße mit`cbHashValue`.
`cbHashValue`[in]
Die Größe des zu signierenden `pbHashValue` Puffers in Byte.
`pbSignature`[aus]
Die Adresse eines Puffers zum Speichern der Signatur. Geben Sie die Puffergröße mit`cbSignature`.
Um die erforderliche Puffergröße zu ermitteln, setzen Sie diesen Parameter auf NULL. Die Funktion speichert die erforderliche Größe (in Byte) an dem Ort, auf den von zeigt`pcbResult`.
`cbSignature`[in]
Die Größe des `pbSignature` Puffers in Byte. Die Funktion ignoriert diesen Parameter, wenn er NULL `pbSignature` ist.
`pcbResult`[aus]
Ein Zeiger auf eine DWORD-Variable, die die Anzahl der in den `pbSignature` Puffer kopierten Byte speichert.
Wenn `pbSignature` der Wert NULL ist, wird die erforderliche Puffergröße in Byte gespeichert.
`dwFlags`[in]
Flags, um das Verhalten der Funktion zu ändern. Die erlaubten Flags hängen von Ihrem Schlüsseltyp ab. Verwenden Sie einen der folgenden Werte:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-sign-hash.html)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hKey` |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
| NTE\$1BUFFER\$1TOO\$1SMALL | Der `pcbOutput` Parameter ist zu klein für Rückgabewerte. |
| NET\$1BAD\$1KEY\$1STATE | Der Schlüsselstatus ist nicht gültig. |
| NTE\$1INTERNAL\$1ERROR | Beim Signieren des Hashs ist ein interner Fehler aufgetreten. |
# NCryptVerifySignature mit Key Storage Provider (KSP)
Die `NCryptVerifySignature` Funktion bestätigt, ob eine Signatur mit einem angegebenen Hash übereinstimmt.
## Parameters
`hKey`[in]
Das Handle des Schlüssels, der zum Entschlüsseln der Signatur verwendet werden soll. Sie müssen den öffentlichen Schlüsselteil des key pair verwenden, mit dem die Daten signiert wurden [`NCryptSignHash`](ksp-library-apis-sign-hash.md).
`pPaddingInfo`[in, optional]
Ein Zeiger auf eine Struktur, die Füllinformationen enthält. Der Strukturtyp hängt vom `dwFlags` Wert ab. Verwenden Sie diesen Parameter nur mit asymmetrischen Schlüsseln. Setzen Sie ihn für andere Schlüsseltypen auf NULL.
`pbHashValue`[in]
Ein Zeiger auf einen Puffer, der den zu signierenden Hashwert enthält. Geben Sie die Puffergröße mit`cbHashValue`.
`cbHashValue`[in]
Die Größe des `pbHashValue` Puffers in Byte.
`pbSignature`[aus]
Die Adresse eines Puffers, der den signierten Hash der Daten enthält. Wird verwendet [`NCryptSignHash`](ksp-library-apis-sign-hash.md), um diese Signatur zu erstellen. Geben Sie die Puffergröße mit an`cbSignature`.
`cbSignature`[in]
Die Größe des `pbSignature` Puffers in Byte. Wird verwendet [`NCryptSignHash`](ksp-library-apis-sign-hash.md), um die Signatur zu erstellen.
`dwFlags`[in]
Flags, um das Verhalten der Funktion zu ändern. Die erlaubten Flags hängen von Ihrem Schlüsseltyp ab. Verwenden Sie einen der folgenden Werte:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/ksp-library-apis-verify-signature.html)
## Rückgabewert
Die Funktion gibt einen Statuscode zurück, der auf Erfolg oder Misserfolg hinweist.
Zu den gängigen Rückgabecodes gehören:
****
| Rückgabecode | Description |
| --- | --- |
| ERROR\$1SUCCESS | Der Vorgang wurde erfolgreich abgeschlossen. |
| NTE\$1INVALID\$1PARAMETER | Ein oder mehrere Parameter sind nicht gültig. |
| NET\$1FAIL | Der Vorgang konnte nicht abgeschlossen werden. |
| NTE\$1INVALID\$1HANDLE | Das Handle in ist nicht gültig. `hKey` |
| NET\$1BAD\$1FLAGS | Der `dwFlags` Parameter enthält einen ungültigen Wert. |
| NTE\$1BAD\$1SIGNATURE | Die Signatur wurde nicht verifiziert. |
| NTE\$1BAD\$1KEY\$1STATE | Der Schlüsselstatus ist nicht gültig. |
| NTE\$1INTERNAL\$1ERROR | Bei der Überprüfung der Signatur ist ein interner Fehler aufgetreten. |
# Erweiterte Konfigurationen für KSP für AWS CloudHSM
Der AWS CloudHSM Key Storage Provider (KSP) umfasst die folgende erweiterte Konfiguration, die nicht Teil der allgemeinen Konfigurationen ist, die die meisten Kunden verwenden. Diese Konfigurationen bieten zusätzliche Funktionen.
+ [SDK3 Kompatibilitätsmodus für KSP](ksp-library-configs-sdk3-compatibility-mode.md)
# SDK3 Kompatibilitätsmodus für Key Storage Provider (KSP) für AWS CloudHSM
Key Storage Provider (KSP) implementiert verschiedene Ansätze für die HSM-Schlüsselinteraktion:
+ Client SDK 5: Ermöglicht die direkte Kommunikation mit Schlüsseln, die im HSM gespeichert sind, sodass keine lokalen Referenzdateien erforderlich sind
+ Client-SDK 3: Verwaltet lokale Dateien auf dem Windows-Server, die als Verweise auf im HSM gespeicherte Schlüssel dienen, und verwendet diese Dateien, um wichtige Operationen zu erleichtern
Für Kunden, die von Client SDK 3 auf Client SDK 5 migrieren, unterstützt die Aktivierung der Option für den SDK3 Kompatibilitätsmodus Operationen, die vorhandene Schlüsselreferenzdateien verwenden, während die zugrunde liegende HSM-Schlüsselspeicherarchitektur beibehalten wird.
## Aktivieren Sie SDK3 den Kompatibilitätsmodus
------
#### [ Windows ]
**Um den SDK3 Kompatibilitätsmodus für Key Storage Provider (KSP) für Client SDK 5 in Windows zu aktivieren**
+ Sie können den folgenden Befehl verwenden, um den SDK3 Kompatibilitätsmodus zu aktivieren:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-ksp.exe" --enable-sdk3-compatibility-mode
```
------
## Deaktivieren Sie den SDK3 Kompatibilitätsmodus
------
#### [ Windows ]
**So deaktivieren Sie den SDK3 Kompatibilitätsmodus für Key Storage Provider (KSP) für Client SDK 5 in Windows**
+ Sie können den folgenden Befehl verwenden, um den SDK3 Kompatibilitätsmodus zu deaktivieren:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-ksp.exe" --disable-sdk3-compatibility-mode
```
------
# 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
```
------