Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# fournisseur JCE pour le SDK AWS CloudHSM client 5
Le fournisseur AWS CloudHSM JCE est une implémentation de fournisseur créée à partir du framework de fournisseur Java Cryptographic Extension (JCE). Le JCE vous permet d'effectuer des opérations cryptographiques à l'aide du kit de développement Java (JDK). Dans ce guide, le fournisseur AWS CloudHSM JCE est parfois appelé fournisseur JCE. Utilisez le fournisseur JCE et le JDK pour décharger les opérations cryptographiques vers le HSM. Pour le dépannage, voir[Problèmes connus relatifs au SDK JCE pour AWS CloudHSM](ki-jce-sdk.md).
Pour plus d'informations sur l'utilisation du SDK client 3, consultez [Utilisation de la version précédente du SDK pour travailler avec AWS CloudHSM](choose-client-sdk.md).
**Topics**
+ [Installation du fournisseur JCE pour le SDK AWS CloudHSM client 5](java-library-install_5.md)
+ [Types de clés pris en charge par le fournisseur JCE pour le SDK AWS CloudHSM client 5](java-lib-keys_5.md)
+ [Notions de base de la gestion des clés dans le fournisseur JCE pour AWS CloudHSM le SDK client 5](java-library-key-basics_5.md)
+ [Mécanismes pris en charge par le fournisseur JCE pour le SDK AWS CloudHSM client 5](java-lib-supported_5.md)
+ [Attributs clés Java pris en charge pour AWS CloudHSM le SDK client 5](java-lib-attributes_5.md)
+ [Exemples de code pour la bibliothèque de AWS CloudHSM logiciels pour Java for Client SDK 5](java-samples.md)
+ [AWS CloudHSM Javadocs, fournisseur JCE](java-javadocs_5.md)
+ [AWS CloudHSM KeyStore Classe Java pour le SDK client 5](alternative-keystore_5.md)
+ [Configurations avancées pour AWS CloudHSM JCE for Client SDK 5](java-lib-configs.md)
# Installation du fournisseur JCE pour le SDK AWS CloudHSM client 5
Le fournisseur JCE pour le SDK AWS CloudHSM client 5 est compatible avec OpenJDK 8, OpenJDK 11, OpenJDK 17, OpenJDK 21 et OpenJDK 25. Vous pouvez télécharger les deux depuis le [site Web d'OpenJDK](https://openjdk.java.net/).
Utilisez les sections suivantes pour installer et fournir des informations d'identification au fournisseur.
**Note**
Pour exécuter un seul cluster HSM avec le SDK client 5, vous devez d'abord gérer les paramètres de durabilité des clés client en définissant `disable_key_availability_check` sur `True`. Pour plus d'informations, veuillez consulter les sections [Synchronisation des clés](manage-key-sync.md) et [outil de configuration du SDK client 5](configure-sdk-5.md).
**Topics**
+ [Étape 1 : Installation du fournisseur JCE](#install-java-library_5)
+ [Étape 2 : Fournissez les informations d'identification au fournisseur JCE](#java-library-credentials_5)
## Étape 1 : Installation du fournisseur JCE
1. Utilisez les commandes suivantes pour télécharger et installer le fournisseur JCE.
------
#### [ Amazon Linux 2023 ]
Installez le fournisseur JCE pour Amazon Linux 2023 sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur JCE pour Amazon Linux 2023 sur ARM64 l'architecture :
```
$ 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 ]
Installez le fournisseur JCE pour Amazon Linux 2 sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur JCE pour Amazon Linux 2 sur ARM64 l'architecture :
```
$ 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) ]
Installez le fournisseur JCE pour RHEL 10 sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur JCE pour RHEL 10 sur ARM64 l'architecture :
```
$ 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) ]
Installez le fournisseur JCE pour RHEL 9 (9.2\$1) sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur JCE pour RHEL 9 (9.2\$1) sur l'architecture : 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) ]
Installez le fournisseur JCE pour RHEL 8 sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur JCE pour RHEL 8 sur ARM64 l'architecture :
```
$ 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 ]
Installez le fournisseur JCE pour Ubuntu 24.04 LTS sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur JCE pour Ubuntu 24.04 LTS sur ARM64 l'architecture :
```
$ 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 ]
Installez le fournisseur JCE pour Ubuntu 22.04 LTS sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur JCE pour Ubuntu 22.04 LTS sur ARM64 l'architecture :
```
$ 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 ]
Installez le fournisseur JCE pour Windows Server sur une architecture x86\$164, ouvrez-le en PowerShell tant qu'administrateur et exécutez la commande suivante :
```
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. Démarrez le SDK client 5. Pour plus d'informations sur le démarrage, consultez [Amorcez le SDK client](cluster-connect.md#connect-how-to).
1. Recherchez les fichiers du fournisseur JCE suivants :
------
#### [ 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`
------
## Étape 2 : Fournissez les informations d'identification au fournisseur JCE
Avant que votre application Java puisse utiliser un HSM, celui-ci doit d'abord authentifier l'application. HSMs authentifiez-vous à l'aide d'une méthode de connexion explicite ou implicite.
**Connexion explicite** : Cette méthode vous permet de fournir les informations d’identification AWS CloudHSM directement dans l’application. Elle utilise la méthode [https://docs.oracle.com/javase/8/docs/api/java/security/AuthProvider.html](https://docs.oracle.com/javase/8/docs/api/java/security/AuthProvider.html), dans laquelle vous transmettez le nom d'utilisateur et le mot de passe du CU dans le modèle d’accès. Pour plus d'informations, consultez la section [Connexion à un exemple de code HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java).
**Connexion implicite** : Cette méthode vous permet de définir les informations de connexion AWS CloudHSM dans un nouveau fichier de propriétés, dans les propriétés système ou en tant que variables d’environnement.
+ **Propriétés système** : Définissez les informations d’identification par le biais des propriétés système lors de l’exécution de votre application. Les exemples suivants montrent deux manières de le faire :
------
#### [ 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","");
```
------
+ **Variables d’environnement** : Définissez les informations d’identification en tant que variables d’environnement.
**Note**
Lorsque vous définissez des variables d'environnement, vous devez éviter tout caractère spécial susceptible d'être interprété par votre shell.
------
#### [ Linux ]
```
$ export HSM_USER=
$ export HSM_PASSWORD=
```
------
#### [ Windows ]
```
PS C:\> $Env:HSM_USER=""
PS C:\> $Env:HSM_PASSWORD=""
```
------
Les informations d'identification peuvent ne pas être disponibles si l'application ne les fournit pas ou si vous essayez une opération avant que le HSM n’authentifie la session. Dans ces cas, la bibliothèque de logiciels CloudHSM pour Java recherche les informations d'identification dans l'ordre suivant :
1. Propriétés système
1. Variables d’environnement
# Types de clés pris en charge par le fournisseur JCE pour le SDK AWS CloudHSM client 5
La bibliothèque AWS CloudHSM logicielle pour Java vous permet de générer les types de clés suivants.
****
| Type de clé | Description |
| --- | --- |
| AES | Générez des clés AES de 128, 192 et 256 bits. |
| Triple DES (3DES), DESede | Générez une clé triple DES 192 bits. [*](#java-lib-keys_5-note-1) |
| EC | Générez des paires de clés EC : courbes NIST secp224r1 (P-224), secp256r1 (P-256), secp256k1 (Blockchain), secp384r1 (P-384) et secp521r1 (P-521). |
| GENERIC\$1SECRET | Générez des secrets génériques de 1 à 800 octets. |
| HMAC | Support de hachage pour SHA1, SHA224,, SHA256 SHA384, SHA512. |
| RSA | Générez des clés RSA de 2 048 bits à 4 096 bits, par incréments de 256 bits. |
\$1 Conformément aux directives du NIST, cela n'est pas autorisé pour les clusters en mode FIPS après 2023. Pour les clusters en mode non FIPS, cela est toujours autorisé après 2023. Consultez [Conformité à la norme FIPS 140 : mécanisme 2024 rendu obsolète](compliance-dep-notif.md#compliance-dep-notif-1) pour plus de détails.
# Notions de base de la gestion des clés dans le fournisseur JCE pour AWS CloudHSM le SDK client 5
Les notions de base sur la gestion des clés dans le fournisseur JCE incluent l'importation des clés, l'exportation des clés, le chargement des clés par le handle ou la suppression des clés. Pour plus d'informations sur la gestion des clés, consultez l’exemple de code [Gérer les clés](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java).
Vous pouvez également trouver d'autres exemples de code de fournisseur JCE sur[Exemples de code](java-samples.md).
# Mécanismes pris en charge par le fournisseur JCE pour le SDK AWS CloudHSM client 5
Cette rubrique fournit des informations sur les mécanismes pris en charge par le fournisseur JCE avec AWS CloudHSM le SDK client 5. Pour plus d'informations sur les interfaces JCA (Java Cryptography Architecture) et les classes de moteur prises en charge par AWS CloudHSM, consultez les rubriques suivantes.
**Topics**
+ [Génération de fonctions de clé et de paire de clés](#java-gen-key-pairs-5)
+ [Fonctions de chiffrement](#java-ciphers_5)
+ [Fonctions de signature et de vérification](#java-sign-verify_5)
+ [Fonctions de résumé](#java-digests_5)
+ [Fonctions du code d’authentification de message utilisant hash (HMAC).](#java-mac_5)
+ [Fonctions du code d'authentification des messages basé sur le chiffrement (CMAC)](#java-cmac_5)
+ [Principales fonctions de l'accord](#java-key-derivation_5)
+ [Convertissez les clés en spécifications de clés à l'aide de fabriques de clés](#java-key-factories)
+ [Annotations du mécanisme](#w2aac25c21c25c15c23)
## Génération de fonctions de clé et de paire de clés
La bibliothèque AWS CloudHSM logicielle pour Java vous permet d'utiliser les opérations suivantes pour générer des fonctions de clé et de paire de clés.
+ `RSA`
+ `EC`
+ `AES`
+ `DESede (Triple DES)`voir note[1](#java-gen-key-pairs-5-note-1)
+ `GenericSecret`
## Fonctions de chiffrement
La bibliothèque AWS CloudHSM logicielle pour Java prend en charge les combinaisons d'algorithmes, de modes et de remplissage suivantes.
| Algorithm | Mode | Remplissage | Remarques |
| --- | --- | --- | --- |
| AES | CBC | `AES/CBC/NoPadding` `AES/CBC/PKCS5Padding` | Implémente `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`. Implémente `Cipher.UNWRAP_MODE for AES/CBC NoPadding` |
| AES | ECB | `AES/ECB/PKCS5Padding` `AES/ECB/NoPadding` | Implémente `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`. |
| AES | CTR | `AES/CTR/NoPadding` | Implémente `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`. |
| AES | GCM | `AES/GCM/NoPadding` | Implémente `Cipher.WRAP_MODE`, `Cipher.UNWRAP_MODE`, `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`.Lorsque vous effectuez un chiffrement AES-GCM, le HSM ignore le vecteur d'initialisation (IV) dans la demande et utilise un vecteur d'initialisation généré. Lorsque l'opération est terminée, vous devez appeler `Cipher.getIV()` pour obtenir le vecteur d'initialisation. |
| AESWrap | ECB | `AESWrap/ECB/NoPadding` `AESWrap/ECB/PKCS5Padding` `AESWrap/ECB/ZeroPadding` | Implémente `Cipher.WRAP_MODE` et `Cipher.UNWRAP_MODE`. |
| DESede (Triple DES) | CBC | `DESede/CBC/PKCS5Padding` `DESede/CBC/NoPadding` | Implémente `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`. Voir la note [1](#java-gen-key-pairs-5-note-1) ci-dessous pour un changement à venir. |
| DESede (Triple DES) | ECB | `DESede/ECB/NoPadding` `DESede/ECB/PKCS5Padding` | Implémente `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`. Voir la note [1](#java-gen-key-pairs-5-note-1) ci-dessous pour un changement à venir. |
| RSA | ECB | `RSA/ECB/PKCS1Padding`**Voir note[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` | Implémente `Cipher.WRAP_MODE`, `Cipher.UNWRAP_MODE`, `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`. |
| RSA | ECB | `RSA/ECB/NoPadding` | Implémente `Cipher.ENCRYPT_MODE` et `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` | Implémente `Cipher.WRAP_MODE` et `Cipher.UNWRAP_MODE`. |
## Fonctions de signature et de vérification
La bibliothèque AWS CloudHSM logicielle pour Java prend en charge les types de signature et de vérification suivants. Avec le SDK client 5 et les algorithmes de signature avec hachage, les données sont hachées localement dans le logiciel avant d'être envoyées au HSM pour signature/vérification. Cela signifie qu'il n'y a aucune limite quant à la taille des données pouvant être hachées par le SDK.
**Types de signature RSA**
+ `NONEwithRSA`
+ `RSASSA-PSS`
+ `SHA1withRSA`
+ `SHA1withRSA/PSS`
+ `SHA1withRSAandMGF1`
+ `SHA224withRSA`
+ `SHA224withRSAandMGF1`
+ `SHA224withRSA/PSS`
+ `SHA256withRSA`
+ `SHA256withRSAandMGF1`
+ `SHA256withRSA/PSS`
+ `SHA384withRSA`
+ `SHA384withRSAandMGF1`
+ `SHA384withRSA/PSS`
+ `SHA512withRSA`
+ `SHA512withRSAandMGF1`
+ `SHA512withRSA/PSS`
**Types de signature ECDSA**
+ `NONEwithECDSA`
+ `SHA1withECDSA`
+ `SHA224withECDSA`
+ `SHA256withECDSA`
+ `SHA384withECDSA`
+ `SHA512withECDSA`
## Fonctions de résumé
La bibliothèque AWS CloudHSM logicielle pour Java prend en charge les résumés de messages suivants. Avec le SDK client 5, les données sont hachées localement dans le logiciel. Cela signifie qu'il n'y a aucune limite quant à la taille des données pouvant être hachées par le SDK.
+ `SHA-1`
+ `SHA-224`
+ `SHA-256`
+ `SHA-384`
+ `SHA-512`
## Fonctions du code d’authentification de message utilisant hash (HMAC).
La bibliothèque AWS CloudHSM logicielle pour Java prend en charge les algorithmes HMAC suivants.
+ `HmacSHA1`(Taille maximale des données en octets : 16288)
+ `HmacSHA224`(Taille maximale des données en octets : 16256)
+ `HmacSHA256`(Taille maximale des données en octets : 16288)
+ `HmacSHA384`(Taille maximale des données en octets : 16224)
+ `HmacSHA512`(Taille maximale des données en octets : 16224)
## Fonctions du code d'authentification des messages basé sur le chiffrement (CMAC)
CMACs (Codes d'authentification de message basés sur le chiffrement) Créez des codes d'authentification de message (MACs) à l'aide d'un chiffrement par blocs et d'une clé secrète. Ils diffèrent par HMACs le fait qu'ils utilisent une méthode de clé symétrique par blocs MACs plutôt qu'une méthode de hachage.
La bibliothèque AWS CloudHSM logicielle pour Java prend en charge les algorithmes CMAC suivants.
+ `AESCMAC`
## Principales fonctions de l'accord
La bibliothèque AWS CloudHSM logicielle pour Java prend en charge l'ECDH avec des fonctions de dérivation clés (KDF). Les types KDF suivants sont pris en charge :
+ `ECDHwithX963SHA1KDF`Supporte l'algorithme KDF X9.63 SHA1 [2](#kdf2)
+ `ECDHwithX963SHA224KDF`Supporte l'algorithme KDF X9.63 SHA224 [2](#kdf2)
+ `ECDHwithX963SHA256KDF`Supporte l'algorithme KDF X9.63 SHA256 [2](#kdf2)
+ `ECDHwithX963SHA384KDF`Supporte l'algorithme KDF X9.63 SHA384 [2](#kdf2)
+ `ECDHwithX963SHA512KDF`Supporte l'algorithme KDF X9.63 SHA512 [2](#kdf2)
## Convertissez les clés en spécifications de clés à l'aide de fabriques de clés
Vous pouvez utiliser des usines de clés pour convertir les clés en spécifications clés. AWS CloudHSM possède deux types d'usines clés pour JCE :
**SecretKeyFactory:** Utilisé pour importer ou dériver des clés symétriques. En utilisant SecretKeyFactory, vous pouvez transmettre une clé prise en charge ou une clé prise en charge KeySpec pour importer ou dériver des clés symétriques. AWS CloudHSM Voici les spécifications prises en charge pour KeyFactory :
+ Les [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)classes suivantes SecretKeyFactory de la `generateSecret` méthode de For sont prises en charge :
+ **KeyAttributesMap**peut être utilisé pour importer des octets de clé avec des attributs supplémentaires en tant que clé CloudHSM. Un exemple peut être trouvé [ici](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)**peut être utilisé pour importer une spécification de clé symétrique en tant que clé CloudHSM.
+ **AesCmacKdfParameterSpec**peut être utilisé pour dériver des clés symétriques à l'aide d'une autre clé CloudHSM AES.
**Note**
SecretKeyFactoryLa `translateKey` méthode prend n'importe quelle clé qui implémente l'interface [clé](https://docs.oracle.com/javase/8/docs/api/java/security/Key.html).
**KeyFactory:** Utilisé pour importer des clés asymétriques. En utilisant KeyFactory, vous pouvez transmettre une clé prise en charge KeySpec ou une clé asymétrique dans AWS CloudHSM laquelle vous pouvez importer une clé asymétrique. Pour plus d'informations, consultez les ressources suivantes :
+ Selon KeyFactory la `generatePublic` méthode de For, les [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)classes suivantes sont prises en charge :
+ KeyAttributesMap CloudHSM pour RSA et EC, notamment : KeyTypes
+ KeyAttributesMap CloudHSM pour le public RSA et EC. KeyTypes Un exemple peut être trouvé [ici](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) pour les clés publiques RSA et EC
+ [RSAPublicKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/RSAPublicKeySpec.html)pour RSA Public Key
+ [ECPublicKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/ECPublicKeySpec.html)pour EC Public Key
+ Selon KeyFactory la `generatePrivate` méthode de For, les [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)classes suivantes sont prises en charge :
+ KeyAttributesMap CloudHSM pour RSA et EC, notamment : KeyTypes
+ KeyAttributesMap CloudHSM pour le public RSA et EC. KeyTypes Un exemple peut être trouvé [ici](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)pour les clés privées EC et RSA
+ [RSAPrivateCrtKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/RSAPrivateCrtKeySpec.html)pour RSA Private Key
+ [ECPrivateKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/ECPrivateKeySpec.html)pour EC Private Key
KeyFactoryLa `translateKey` méthode de For prend en compte n'importe quelle clé qui implémente l'[interface clé](https://docs.oracle.com/javase/8/docs/api/java/security/Key.html).
## Annotations du mécanisme
[1] Conformément aux directives du NIST, cela n'est pas autorisé pour les clusters en mode FIPS après 2023. Pour les clusters en mode non FIPS, cela est toujours autorisé après 2023. Consultez [Conformité à la norme FIPS 140 : mécanisme 2024 rendu obsolète](compliance-dep-notif.md#compliance-dep-notif-1) pour plus de détails.
[2] Les fonctions de dérivation clés (KDFs) sont spécifiées dans la [publication spéciale 800-56A du NIST](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar3.pdf), révision 3.
# Attributs clés Java pris en charge pour AWS CloudHSM le SDK client 5
Cette rubrique fournit des informations sur les attributs clés Java pris en charge pour AWS CloudHSM le SDK client 5. Cette rubrique décrit comment utiliser une extension propriétaire pour le fournisseur JCE afin de définir les attributs de clé. Utilisez cette extension pour définir les attributs de clés pris en charge et leurs valeurs au cours des opérations suivantes :
+ Génération de clés
+ Importation de clés
Pour des exemples d'utilisation des attributs de clé, consultez [Exemples de code pour la bibliothèque de AWS CloudHSM logiciels pour Java for Client SDK 5](java-samples.md).
**Topics**
+ [Présentation des attributs](#java-understanding-attributes_5)
+ [Attributs pris en charge](#java-attributes_5)
+ [Définition des attributs pour une clé](#java-setting-attributes_5)
## Présentation des attributs
Les attributs de clé permettent de spécifier les actions autorisées sur les objets de type clé, y compris les clés publiques, privées ou secrètes. Vous définissez les attributs de clés et leurs valeurs lors des opérations de création d'objets de type clé.
Toutefois, l'extension JCE (Java Cryptography Extension) ne spécifie pas comment définir les valeurs des attributs de clé. Dès lors, la plupart des actions étaient autorisées par défaut. En revanche, la norme PKCS \$111 définit un ensemble complet d'attributs avec des valeurs par défaut plus restrictives. À partir du fournisseur JCE 3.1, AWS CloudHSM fournit une extension propriétaire qui vous permet de définir des valeurs plus restrictives pour les attributs couramment utilisés.
## Attributs pris en charge
Vous pouvez définir des valeurs pour les attributs répertoriés dans le tableau ci-dessous. Il est conseillé de spécifier uniquement des valeurs pour les attributs que vous souhaitez restreindre. Si vous ne spécifiez aucune valeur, AWS CloudHSM utilise la valeur par défaut spécifiée dans le tableau ci-dessous. Une cellule vide dans la colonne Default Value (Valeur par défaut) signale qu'aucune valeur par défaut n'est assignée à l'attribut.
****
| Attribut | Valeur par défaut | Remarques | | Clé symétrique | Clé publique dans la paire de clés | Clé privée dans la paire de clés | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| DECRYPT | TRUE | | TRUE | True indique que vous pouvez utiliser la clé pour déchiffrer n'importe quelle mémoire tampon. Vous définissez généralement cette valeur sur FALSE pour une clé dont l'attribut WRAP est défini sur true. |
| DERIVE | | | | Permet d'utiliser une clé pour dériver d'autres clés. |
| ENCRYPT | TRUE | TRUE | | True indique que vous pouvez utiliser la clé pour chiffrer n'importe quelle mémoire tampon. |
| EXTRACTABLE | TRUE | | TRUE | True indique que vous pouvez exporter cette clé hors du HSM. |
| ID | | | | Valeur définie par l'utilisateur utilisée pour identifier la clé. |
| KEY\$1TYPE | | | | Utilisé pour identifier le type de clé (AES DESede, secret générique, EC ou RSA). |
| LABEL | | | | Chaîne définie par l'utilisateur qui vous permet d'identifier facilement les clés de votre HSM. Conformément aux meilleures pratiques, utilisez une étiquette unique pour chaque clé afin de pouvoir la retrouver plus facilement par la suite. |
| LOCAL | | | | Indique une clé générée par le HSM. |
| OBJECT\$1CLASS | | | | Utilisé pour identifier la classe d'objet d'une clé (SecretKey PublicKey ou PrivateKey). |
| PRIVATE | TRUE | TRUE | TRUE | True indique qu'un utilisateur ne peut pas accéder à la clé tant qu'il n'est pas authentifié. Pour plus de clarté, les utilisateurs ne peuvent accéder à aucune clé AWS CloudHSM tant qu'ils ne sont pas authentifiés, même si cet attribut est défini sur FALSE. |
| SIGN | TRUE | | TRUE | True indique que vous pouvez utiliser la clé pour signer le résumé d'un message. Cette valeur est généralement définie sur FALSE pour les clés publiques et les clés privées que vous avez archivées. |
| SIZE | | | | Attribut qui définit la taille d'une clé. Pour plus de détails sur les tailles de clé prises en charge, reportez-vous à la section [Mécanismes pris en charge pour le SDK client 5](https://docs.aws.amazon.com/cloudhsm/latest/userguide/java-lib-supported_5.html#java-keys_5). |
| TOKEN | FALSE | FALSE | FALSE | Une clé permanente qui est répliquée sur l'ensemble HSMs du cluster et incluse dans les sauvegardes. TOKEN = FALSE implique une clé éphémère qui est automatiquement effacée lorsque la connexion au HSM est interrompue. |
| UNWRAP | TRUE | | TRUE | True indique que vous pouvez utiliser la clé pour décencapsuler (importer) une autre clé. |
| VERIFY | TRUE | TRUE | | True indique que vous pouvez utiliser la clé pour valider une signature. Cette valeur est généralement définie sur FALSE pour les clés privées. |
| WRAP | TRUE | TRUE | | True indique que vous pouvez utiliser la clé pour encapsuler une autre clé. Vous définissez généralement ce paramètre sur FALSE pour les clés privées. |
| WRAP\$1WITH\$1TRUSTED | FALSE | | FALSE | True indique qu'une clé ne peut être encapsulée et désencapsulée qu'avec des clés pour lesquelles l'attribut TRUSTED est défini sur true. Une fois que l’attribut WRAP\$1WITH\$1TRUSTED est défini sur true, cet attribut est en lecture seule et ne peut pas être défini sur false. Pour en savoir plus sur l’encapsulage de confiance, consultez la section [Utilisation de clés de confiance pour contrôler le désencapsulage des clés](https://docs.aws.amazon.com/cloudhsm/latest/userguide/cloudhsm_using_trusted_keys_control_key_wrap.html). |
**Note**
Vous bénéficiez d'une prise en charge plus large des attributs dans la bibliothèque PKCS \$111. Pour plus d'informations, consultez [Attributs PKCS \$111 pris en charge](pkcs11-attributes.md).
## Définition des attributs pour une clé
`KeyAttributesMap` est un objet de type Java Map que vous pouvez utiliser pour définir des valeurs d'attribut pour les objets de type clé. Les méthodes de `KeyAttributesMap` fonctionne d'une manière similaire à celles utilisées pour la manipulation de Java Map.
Pour définir des valeurs personnalisées pour les attributs, deux options s'offrent à vous :
+ Utiliser les méthodes répertoriées dans le tableau suivant
+ Utiliser les modèles de générateur illustrés plus loin dans ce document
Les objets de mappage d'attribut prennent en charge les méthodes suivantes pour définir les attributs :
****
| Opération | Valeur renvoyée | Méthode `KeyAttributesMap` |
| --- | --- | --- |
| Obtenir la valeur d'un attribut pour une clé existante | Objet (contenant la valeur) ou null | **get**(keyAttribute) |
| Renseigner la valeur d'un attribut de clé | Valeur précédente associée à l'attribut de clé, ou null en l'absence de mappage pour un attribut de clé | **put**(keyAttribute, value) |
| Renseigner des valeurs pour plusieurs attributs de clés | N/A | **Tout mettre ()** keyAttributesMap |
| Supprimer une paire clé-valeur du mappage d'attributs | Valeur précédente associée à l'attribut de clé, ou *null* en l'absence de mappage pour un attribut de clé | **remove**(keyAttribute) |
**Note**
Tous les attributs que vous ne spécifiez pas explicitement utilisent les valeurs par défaut répertoriées dans le tableau précédent, dans [Attributs pris en charge](#java-attributes_5).
### Définition des attributs pour une paire de clés
Utilisez la classe Java `KeyPairAttributesMap` pour gérer les attributs d'une paire de clés. `KeyPairAttributesMap` encapsule deux objets `KeyAttributesMap` : un pour une clé publique et un pour une clé privée.
Pour définir des attributs individuels de la clé publique et la clé privée séparément, vous pouvez utiliser la méthode `put()` sur l'objet mappé `KeyAttributes` correspondant à cette clé. Choisissez la méthode `getPublic()` pour récupérer le mappage d'attributs de la clé publique, et utilisez `getPrivate()` pour récupérer le mappage d'attributs de la clé privée. Renseignez la valeur de plusieurs attributs de clés pour les paires de clés publiques et privées en utilisant `putAll()` avec le mappage d'attributs d'une paire de clés comme argument.
# Exemples de code pour la bibliothèque de AWS CloudHSM logiciels pour Java for Client SDK 5
Cette rubrique fournit des ressources et des informations sur des exemples de code Java pour AWS CloudHSM le SDK client 5.
## Conditions préalables
Avant d'exécuter les exemples, vous devez configurer votre environnement :
+ Installez et configurez le [fournisseur d’extension cryptographique Java (JCE).](java-library-install_5.md#install-java-library_5)
+ Définissez un [nom d'utilisateur et un mot de passe HSM](manage-hsm-users.md) valides. Les autorisations de l'utilisateur de chiffrement (CU) sont suffisantes pour ces tâches. Votre application utilise ces informations d'identification pour se connecter au HSM dans chaque exemple.
+ Décidez comment fournir les informations d'identification au [fournisseur JCE](java-library-install_5.md#java-library-credentials_5).
## Exemples de code
Les exemples de code suivants vous montrent comment utiliser le [fournisseur AWS CloudHSM JCE](java-library.md) pour effectuer des tâches de base. D'autres exemples de code sont disponibles sur [GitHub](https://github.com/aws-samples/aws-cloudhsm-jce-examples/tree/sdk5).
+ [Se connecter à un HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java)
+ [Gérer les clés](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java)
+ [Générer des clés symétriques](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/SymmetricKeys.java)
+ [Générer des clés asymétriques](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AsymmetricKeys.java)
+ [Chiffrer et déchiffrer avec AES-GCM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AESGCMEncryptDecryptRunner.java)
+ [Chiffrer et déchiffrer avec AES-CTR](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AESCTREncryptDecryptRunner.java)
+ [Chiffrer et déchiffrer avec DESede -ECB](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/DESedeECBEncryptDecryptRunner.java) (voir note) [1](#java-samples-code-5-note-1)
+ [Signer et vérifier avec des clés RSA](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/RSAOperationsRunner.java)
+ [Signer et vérifier avec des clés EC](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/ECOperationsRunner.java)
+ [Utiliser les attributs de clé pris en charge](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyAttributesRunner.java)
+ [Utiliser le magasin de clés CloudHSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyStoreExampleRunner.java)
[1] Conformément aux directives du NIST, cela n'est pas autorisé pour les clusters en mode FIPS après 2023. Pour les clusters en mode non FIPS, cela est toujours autorisé après 2023. Consultez [Conformité à la norme FIPS 140 : mécanisme 2024 rendu obsolète](compliance-dep-notif.md#compliance-dep-notif-1) pour plus de détails.
# AWS CloudHSM Javadocs, fournisseur JCE
Utilisez le fournisseur JCE Javadocs pour obtenir des informations d'utilisation sur les types et méthodes Java définis dans le SDK AWS CloudHSM JCE. Pour télécharger la dernière version de Javadocs pour AWS CloudHSM, consultez la [AWS CloudHSM dernière version du SDK client](latest-releases.md) section sur la page Téléchargements.
Vous pouvez importer des Javadocs dans un environnement de développement intégré (IDE) ou les afficher dans un navigateur Web.
# AWS CloudHSM KeyStore Classe Java pour le SDK client 5
La AWS CloudHSM `KeyStore` classe fournit un magasin de PKCS12 clés à usage spécial. Ce magasin de clés peut stocker des certificats avec vos données clés et les mettre en corrélation avec les données clés stockées sur AWS CloudHSM. La AWS CloudHSM `KeyStore` classe implémente l'interface du fournisseur de `KeyStore` services (SPI) de l'extension de cryptographie Java (JCE). Pour plus d'informations sur l'utilisation`KeyStore`, consultez la section [Classe KeyStore](https://devdocs.io/openjdk~8/java/security/keystore).
**Note**
Étant donné que les certificats sont des informations publiques, il n'est pas possible de les stocker sur. Dans le but d'optimiser la capacité de stockage des clés cryptographiques, AWS CloudHSM il n'est pas possible de les stocker sur HSMs.
## Choisissez le magasin de clés approprié pour AWS CloudHSM le SDK client 5
Le fournisseur d'extension cryptographique AWS CloudHSM Java (JCE) propose un AWS CloudHSM à usage spécifique. KeyStore La AWS CloudHSM `KeyStore` classe prend en charge le transfert des opérations clés vers le HSM, le stockage local des certificats et les opérations basées sur les certificats.
Chargez le CloudHSM spécialisé comme suit : KeyStore
```
KeyStore ks = KeyStore.getInstance("CloudHSM")
```
## Initialisation du SDK AWS CloudHSM KeyStore client 5
Connectez-vous de AWS CloudHSM KeyStore la même manière que vous vous connectez au fournisseur JCE. Vous pouvez utiliser des variables d'environnement ou le fichier de propriétés du système, et vous devez vous connecter avant de commencer à utiliser CloudHSM KeyStore. Pour obtenir un exemple de connexion à un HSM à l'aide du fournisseur JCE, veuillez consulter [Connexion à un HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java).
Si vous le souhaitez, vous pouvez spécifier un mot de passe pour chiffrer le PKCS12 fichier local contenant les données du magasin de clés. Lorsque vous créez le AWS CloudHSM Keystore, vous définissez le mot de passe et vous le fournissez lorsque vous utilisez les méthodes load, set et get.
Instanciez un nouvel objet KeyStore CloudHSM comme suit :
```
ks.load(null, null);
```
Écrivez les données du keystore dans un fichier à l'aide de la méthode `store`. À partir de ce moment, vous pouvez charger le keystore existant en utilisant la méthode `load` avec le fichier source et le mot de passe comme suit :
```
ks.load(inputStream, password);
```
## Utiliser AWS CloudHSM KeyStore notre SDK AWS CloudHSM client 5
AWS CloudHSM KeyStore est conforme aux KeyStore spécifications de la [classe](https://devdocs.io/openjdk~8/java/security/keystore) JCE et fournit les fonctions suivantes.
+ `load`
Charge le magasin de clés à partir du flux d'entrée donné. Si un mot de passe a été défini lors de l'enregistrement du magasin de clés, ce même mot de passe doit être fourni pour que le chargement réussisse. Définissez les deux paramètres sur null pour initialiser un nouveau magasin de clés vide.
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
ks.load(inputStream, password);
```
+ `aliases`
Renvoie une énumération des noms d'alias de toutes les entrées de l'instance de magasin de clés donnée. Les résultats incluent les objets stockés localement dans le PKCS12 fichier et les objets résidant sur le HSM.
**Exemple de code :**
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
for(Enumeration entry = ks.aliases(); entry.hasMoreElements();) {
String label = entry.nextElement();
System.out.println(label);
}
```
+ `containsalias`
Renvoie true si le magasin de clés a accès à au moins un objet avec l'alias spécifié. Le magasin de clés vérifie les objets stockés localement dans le PKCS12 fichier et les objets résidant sur le HSM.
+ `deleteEntry`
Supprime une entrée de certificat du PKCS12 fichier local. La suppression de données clés stockées dans un HSM n'est pas prise en charge à l'aide du AWS CloudHSM KeyStore. Vous pouvez supprimer des clés en utilisant la méthode `destroy` de l'interface [Destroyable](https://devdocs.io/openjdk~8/javax/security/auth/destroyable#destroy--).
```
((Destroyable) key).destroy();
```
+ `getCertificate`
Renvoie le certificat associé à un alias le cas échéant. Si l'alias n'existe pas ou fait référence à un objet qui n'est pas un certificat, la fonction renvoie NULL.
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
Certificate cert = ks.getCertificate(alias);
```
+ `getCertificateAlias`
Renvoie le nom (alias) de la première entrée de magasin de clés dont les données correspondent au certificat donné.
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
String alias = ks.getCertificateAlias(cert);
```
+ `getCertificateChain`
Renvoie la chaîne de certificats associée à l'alias donné. Si l'alias n'existe pas ou fait référence à un objet qui n'est pas un certificat, la fonction renvoie NULL.
+ `getCreationDate`
Renvoie la date de création de l'entrée identifiée par l'alias donné. Si aucune date de création n'est disponible, la fonction renvoie la date à laquelle le certificat est devenu valide.
+ `getKey`
GetKey est transmis au HSM et renvoie un objet clé correspondant à l'étiquette donnée. Comme il interroge `getKey` directement le HSM, il peut être utilisé pour n'importe quelle clé du HSM, qu'elle ait été générée ou non par le. KeyStore
```
Key key = ks.getKey(keyLabel, null);
```
+ `isCertificateEntry`
Vérifie si l'entrée avec l'alias donné représente une entrée de certificat.
+ `isKeyEntry`
Vérifie si l'entrée avec l'alias donné représente une entrée de clé. L'action recherche l'alias à la fois dans le PKCS12 fichier et dans le HSM.
+ `setCertificateEntry`
Affecte le certificat donné à l'alias donné. Si l'alias donné est déjà utilisé pour identifier une clé ou un certificat, une `KeyStoreException` est levée. Vous pouvez utiliser le code JCE pour obtenir l'objet clé, puis utiliser la KeyStore `SetKeyEntry` méthode pour associer le certificat à la clé.
+ `setKeyEntry` avec la clé `byte[]`
**Cette API n'est actuellement pas prise en charge par le SDK client 5.**
+ `setKeyEntry` avec l'objet `Key`
Affecte la clé donnée à l'alias donné et la stocke dans le HSM. Si la clé n'existe pas déjà dans le HSM, elle sera importée dans le HSM en tant que clé de session extractible.
Si l'objet `Key` est de type `PrivateKey`, il doit être accompagné d'une chaîne de certificats correspondante.
Si l'alias existe déjà, l'appel `SetKeyEntry` lance un `KeyStoreException` et empêche la clé d'être écrasée. Si la clé doit être écrasée, utilisez KMU ou JCE à cet effet.
+ `engineSize`
Renvoie le nombre d'entrées dans le keystore.
+ `store`
Stocke le magasin de clés du flux de sortie donné sous forme de PKCS12 fichier et le sécurise avec le mot de passe donné. En outre, il persiste toutes les clés chargées (qui sont définies en utilisant des appels `setKey`).
# Configurations avancées pour AWS CloudHSM JCE for Client SDK 5
Le fournisseur AWS CloudHSM JCE inclut les configurations avancées suivantes, qui ne font pas partie des configurations générales utilisées par la plupart des clients.
+ [Connexion à plusieurs clusters](java-lib-configs-multi.md)
+ [Extraction de clés à l'aide de JCE](java-lib-configs-getencoded.md)
+ [Réessayer la configuration pour JCE](java-lib-configs-retry.md)
# Connexion à plusieurs AWS CloudHSM clusters avec le fournisseur JCE
Cette configuration permet à une seule instance client de communiquer avec plusieurs AWS CloudHSM clusters. Par rapport au fait qu'une seule instance communique uniquement avec un seul cluster, cette fonctionnalité peut permettre de réaliser des économies dans certains cas d'utilisation. La `CloudHsmProvider` classe est AWS CloudHSM l'implémentation de la [classe Provider de Java Security](https://docs.oracle.com/javase/8/docs/api/java/security/Provider.html). Chaque instance de cette classe représente une connexion à l'ensemble de votre AWS CloudHSM cluster. Vous instanciez cette classe et vous l'ajoutez à la liste des fournisseurs de Java Security afin de pouvoir interagir avec elle à l'aide des classes JCE standard.
L'exemple suivant instancie cette classe et l'ajoute à la liste des fournisseurs Java Security :
```
if (Security.getProvider(CloudHsmProvider.PROVIDER_NAME) == null) {
Security.addProvider(new CloudHsmProvider());
}
```
`CloudHsmProvider` peut être configuré de deux façons :
1. Configuration avec un fichier (configuration par défaut)
1. Configuration à l'aide du code
Les rubriques suivantes décrivent ces configurations et expliquent comment se connecter à plusieurs clusters.
**Topics**
+ [Configurer la AWS CloudHSM `CloudHsmProvider` classe avec un fichier (configuration par défaut)](java-lib-configs-default.md)
+ [Configurer la AWS CloudHSM `CloudHsmProvider` classe à l'aide du code](java-lib-configs-using-code.md)
+ [Connectez-vous à plusieurs AWS CloudHSM clusters](java-lib-connecting-to-multiclusters.md)
# Configurer la AWS CloudHSM `CloudHsmProvider` classe avec un fichier (configuration par défaut)
La méthode par défaut pour configurer la AWS CloudHSM `CloudHsmProvider` classe consiste à utiliser un fichier.
Lorsque vous instanciez `CloudHsmProvider` en utilisant le constructeur par défaut, il recherche par défaut le fichier de configuration dans le chemin `/opt/cloudhsm/etc/cloudhsm-jce.cfg` sous Linux. Ce fichier de configuration peut être configuré à l'aide du paramètre `configure-jce`.
Un objet créé à l'aide du constructeur par défaut utilisera le nom du fournisseur CloudHSM par défaut `CloudHSM`. Le nom du fournisseur est utile pour interagir avec JCE afin de lui indiquer quel fournisseur utiliser pour diverses opérations. Voici un exemple d'utilisation du nom du fournisseur CloudHSM pour l'opération Cipher :
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "CloudHSM");
```
# Configurer la AWS CloudHSM `CloudHsmProvider` classe à l'aide du code
À partir de la version 5.8.0 du SDK client, vous pouvez également configurer la AWS CloudHSM `CloudHsmProvider` classe à l'aide du code Java. Pour cela, utilisez un objet de classe `CloudHsmProviderConfig`. Vous pouvez générer cet objet à l'aide de `CloudHsmProviderConfigBuilder`.
`CloudHsmProvider` possède un autre constructeur qui prend l'objet `CloudHsmProviderConfig`, comme le montre l'exemple suivant.
**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);
```
Dans cet exemple, le nom du fournisseur JCE est`CloudHsmCluster1`. Voici le nom que l'application peut ensuite utiliser pour interagir avec JCE :
**Example**
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "CloudHsmCluster1");
```
Les applications peuvent également utiliser l'objet fournisseur créé ci-dessus pour indiquer à JCE d'utiliser ce fournisseur pour l'opération :
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider);
```
Si aucun identifiant unique n'est spécifié avec la méthode `withClusterUniqueIdentifier`, un nom de fournisseur généré de manière aléatoire est créé pour vous. Pour obtenir cet identifiant généré de manière aléatoire, les applications peuvent appeler `provider.getName()`.
# Connectez-vous à plusieurs AWS CloudHSM clusters
Chacun `CloudHsmProvider` représente une connexion à votre AWS CloudHSM cluster. Si vous souhaitez communiquer avec un autre cluster à partir de la même application, vous pouvez créer un autre objet `CloudHsmProvider` avec des configurations pour votre autre cluster et vous pouvez interagir avec cet autre cluster en utilisant l'objet fournisseur ou en utilisant le nom du fournisseur, comme indiqué dans l'exemple suivant.
**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);
}
```
Une fois que vous avez configuré les deux fournisseurs (les deux clusters) ci-dessus, vous pouvez interagir avec eux en utilisant l'objet fournisseur ou en utilisant le nom du fournisseur.
Sur la base de cet exemple qui montre comment parler à`cluster1`, vous pouvez utiliser l'exemple suivant pour une AES/GCM/NoPadding opération :
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider1);
```
Et dans la même application pour générer une clé « AES » sur le deuxième cluster en utilisant le nom du fournisseur, vous pouvez également utiliser l'exemple suivant :
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider2.getName());
```
# Extraction de clés à l'aide de JCE pour AWS CloudHSM
L'extension de cryptographie Java (JCE) utilise une architecture qui permet de connecter différentes implémentations de cryptographie. AWS CloudHSM fournit un tel fournisseur JCE qui télécharge les opérations cryptographiques vers le HSM. Pour que la plupart des autres fournisseurs JCE puissent utiliser des clés stockées dans AWS CloudHSM, ils doivent extraire les octets clés de votre compte en texte clair et les placer dans la mémoire HSMs de votre machine pour les utiliser. HSMs autorise généralement uniquement l'extraction des clés sous forme d'objets encapsulés, et non sous forme de texte clair. Toutefois, pour prendre en charge les cas d'utilisation liés à l'intégration entre fournisseurs, AWS CloudHSM autorise une option de configuration optionnelle pour permettre l'extraction des octets clés en clair.
**Important**
JCE décharge les opérations AWS CloudHSM chaque fois que le fournisseur AWS CloudHSM est spécifié ou AWS CloudHSM qu'un objet clé est utilisé. Il n'est pas nécessaire d'extraire les clés en clair si vous vous attendez à ce que votre opération se déroule dans le HSM. L'extraction de clés en texte clair n'est nécessaire que lorsque votre application ne peut pas utiliser de mécanismes sécurisés tels que l'encapsulage et le désencapsulage d'une clé en raison de restrictions imposées par une bibliothèque tierce ou un fournisseur JCE.
Le fournisseur AWS CloudHSM JCE permet l'extraction de **clés publiques** pour fonctionner avec des fournisseurs JCE externes par défaut. Les méthodes suivantes sont toujours autorisées :
| Classe | Method | Format (getEncoded) |
| --- | --- | --- |
| EcPublicKey | getEncoded() | X.509 |
| | getW() | N/A |
| RSAPublicClé | getEncoded() | X.509 |
| | getPublicExponent() | N/A |
| CloudHsmRsaPrivateCrtKey | getPublicExponent() | N/A |
Le fournisseur AWS CloudHSM JCE n'autorise pas l'extraction d'octets clés en clair pour les clés **privées** ou **secrètes** par défaut. Si votre cas d'utilisation l'exige, vous pouvez activer l'extraction d'octets de clé en clair pour les clés **privées** ou **secrètes** dans les conditions suivantes :
1. L'attribut `EXTRACTABLE` des clés privées et secrètes est défini sur **true**.
+ Par défaut, l'attribut `EXTRACTABLE` des clés privées et secrètes est défini sur **true**. Les clés `EXTRACTABLE` sont des clés dont l'exportation hors du HSM est autorisée. Pour plus d'informations, consultez Attributs Java pris en charge pour le [Client SDK 5](java-lib-attributes_5.md).
1. L’attribut `WRAP_WITH_TRUSTED` pour les clés privées et secrètes est défini sur **false**.
+ `getEncoded`, `getPrivateExponent`, et `getS` ne peuvent pas être utilisés avec des clés privées qui ne peuvent pas être exportées en clair. `WRAP_WITH_TRUSTED` n'autorise pas l'exportation de vos clés privées hors du HSM en clair. Pour plus d'informations, consultez [Utilisation de clés fiables pour contrôler le désencapsulage des clés.](manage-keys-using-trusted-keys.md)
# Autoriser le fournisseur JCE à extraire les clés privées secrètes de AWS CloudHSM
Suivez les étapes ci-dessous pour autoriser le fournisseur AWS CloudHSM JCE à extraire les secrets de votre clé privée.
**Important**
Cette modification de configuration permet d'extraire à partir de tous les octets de clé `EXTRACTABLE` en clair de votre cluster HSM. Pour une meilleure sécurité, envisagez d'utiliser des [méthodes d'encapsulage des clés](java-lib-supported_5.md) pour extraire la clé du HSM en toute sécurité. Cela empêche l'extraction involontaire de vos octets de clé du HSM.
1. Utilisez les commandes suivantes pour activer l'extraction de vos clés **privées** ou **secrètes** dans JCE :
------
#### [ 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. Une fois que vous avez activé l'extraction de votre clé en clair, les méthodes suivantes sont activées pour extraire les clés privées en mémoire.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/get-encoded-take-out-private-keys.html)
Si vous souhaitez rétablir le comportement par défaut et empêcher JCE d'exporter les clés en clair, exécutez la commande suivante :
------
#### [ 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
```
------
# Commandes de nouvelle tentative pour JCE pour AWS CloudHSM
AWS CloudHSM Le SDK client 5.8.0 et versions ultérieures disposent d'une stratégie de relance automatique intégrée qui permet de réessayer les opérations limitées par HSM du côté client. Lorsqu'un HSM limite les opérations parce qu'il est trop occupé à effectuer les opérations précédentes et qu'il ne peut pas prendre plus de demandes, le client SDKs tente de réessayer les opérations limitées jusqu'à 3 fois tout en reculant de façon exponentielle. Cette stratégie de nouvelle tentative automatique peut être réglée sur l'un des deux modes suivants : **désactivé** et **standard**.
+ **désactivé** : le SDK client n'exécutera aucune stratégie de nouvelle tentative pour les opérations limitées effectuées par le HSM.
+ **standard** : il s'agit du mode par défaut pour le SDK client 5.8.0 et versions ultérieures. Dans ce mode, le client SDKs réessaiera automatiquement les opérations limitées en reculant de manière exponentielle.
Pour de plus amples informations, veuillez consulter [Limitation du HSM](troubleshoot-hsm-throttling.md).
## Définir des commandes de nouvelle tentative sur le mode désactivé
------
#### [ Linux ]
**Pour définir les commandes de nouvelle tentative sur **off** pour le SDK client 5 sous Linux**
+ Vous pouvez utiliser la commande suivante pour définir une nouvelle tentative de configuration sur le mode **off** :
```
$ sudo /opt/cloudhsm/bin/configure-jce --default-retry-mode off
```
------
#### [ Windows ]
**Pour définir les commandes de nouvelle tentative sur **off** pour le SDK client 5 sous Windows**
+ Vous pouvez utiliser la commande suivante pour définir une nouvelle tentative de configuration sur le mode**off** :
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe" --default-retry-mode off
```
------