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.
# Opérations de déchargement avec le client AWS CloudHSM SDKs
Utilisez un SDK client pour décharger les opérations cryptographiques des applications basées sur une plate-forme ou un langage vers des modules de sécurité matériels (). HSMs
AWS CloudHSM propose deux versions principales, et le SDK client 5 est la plus récente. Il offre de nombreux avantages par rapport au SDK client 3 (la série précédente). Pour plus d'informations, consultez [ Avantages du SDK client 5](client-sdk-5-benefits.md). Pour plus d’informations sur les plateformes prises en charge, veuillez consulter [AWS CloudHSM Plateformes prises en charge par le SDK client 5](client-supported-platforms.md).
Les rubriques suivantes décrivent comment travailler avec AWS CloudHSM le client SDKs.
AWS CloudHSM prend en charge les composants suivants :
**[bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5](pkcs11-library.md)**
PKCS \$111 est une norme permettant d'effectuer des opérations cryptographiques sur des modules de sécurité matériels ()HSMs. AWS CloudHSM propose des implémentations de la bibliothèque PKCS \$111 conformes à la version 2.40 de PKCS \$111.
**[Moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 5](openssl-library.md)**
Le moteur dynamique AWS CloudHSM OpenSSL vous permet de décharger des opérations cryptographiques vers votre cluster CloudHSM via l'API OpenSSL.
**[Fournisseur AWS CloudHSM OpenSSL pour le SDK client 5](openssl-provider-library.md)**
Le fournisseur AWS CloudHSM OpenSSL Dynamic Engine vous permet de décharger les opérations cryptographiques vers votre cluster CloudHSM via l'API du fournisseur OpenSSL.
**[fournisseur JCE pour le SDK AWS CloudHSM client 5](java-library.md)**
Le fournisseur AWS CloudHSM JCE est conforme à l'architecture cryptographique Java (JCA). Le fournisseur vous permet d'effectuer des opérations cryptographiques sur le HSM.
**[Fournisseur de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5](ksp-library.md)**
Le AWS CloudHSM client pour Windows inclut les fournisseurs CNG et KSP.
**Topics**
+ [Vérifiez la version de votre SDK AWS CloudHSM client](check-client_version.md)
+ [Comparaison de la prise en charge des composants du SDK AWS CloudHSM client](sdk3-compare.md)
+ [Migration du SDK AWS CloudHSM client 3 vers le SDK client 5](client-sdk-migration.md)
+ [Utilisation du SDK client 5 pour travailler avec AWS CloudHSM](client-sdk5.md)
+ [Utilisation de la version précédente du SDK pour travailler avec AWS CloudHSM](choose-client-sdk.md)
# Vérifiez la version de votre SDK AWS CloudHSM client
Utilisez les commandes suivantes pour vérifier la version du SDK client que vous utilisez. AWS CloudHSM
------
#### [ Amazon Linux ]
Utilisez la commande suivante :
```
rpm -qa | grep ^cloudhsm
```
------
#### [ Amazon Linux 2 ]
Utilisez la commande suivante :
```
rpm -qa | grep ^cloudhsm
```
------
#### [ CentOS 6 ]
Utilisez la commande suivante :
```
rpm -qa | grep ^cloudhsm
```
------
#### [ CentOS 7 ]
Utilisez la commande suivante :
```
rpm -qa | grep ^cloudhsm
```
------
#### [ CentOS 8 ]
Utilisez la commande suivante :
```
rpm -qa | grep ^cloudhsm
```
------
#### [ RHEL 6 ]
Utilisez la commande suivante :
```
rpm -qa | grep ^cloudhsm
```
------
#### [ RHEL 7 ]
Utilisez la commande suivante :
```
rpm -qa | grep ^cloudhsm
```
------
#### [ RHEL 8 ]
Utilisez la commande suivante :
```
rpm -qa | grep ^cloudhsm
```
------
#### [ Ubuntu 16.04 LTS ]
Utilisez la commande suivante :
```
apt list --installed | grep ^cloudhsm
```
------
#### [ Ubuntu 18.04 LTS ]
Utilisez la commande suivante :
```
apt list --installed | grep ^cloudhsm
```
------
#### [ Ubuntu 20.04 LTS ]
Utilisez la commande suivante :
```
apt list --installed | grep ^cloudhsm
```
------
#### [ Windows Server ]
Utilisez la commande suivante :
```
wmic product get name,version
```
------
# Comparaison de la prise en charge des composants du SDK AWS CloudHSM client
Outre les outils de ligne de commande, le SDK client 3 contient des composants qui permettent de décharger les opérations cryptographiques vers le HSM à partir de diverses applications basées sur des plateformes ou des langages. Le SDK client 5 est identique au SDK client 3, sauf qu'il ne prend pas encore en charge les fournisseurs CNG et KSP. Le tableau suivant compare la disponibilité des composants dans le SDK client 3 et le SDK client 5.
| Composant | SDK client 5 | SDK client 3 |
| --- | --- | --- |
| Bibliothèque PKCS \$111 | Oui | Oui |
| Fournisseur JCE | Oui | Oui |
| OpenSSL Dynamic Engine | Oui | Oui |
| Fournisseur de stockage de clés (KSP) | Oui | Oui |
| Utilitaire de gestion CloudHSM (CMU) [1](#sdk-compare-note-1) | Oui | Oui |
| Utilitaire de gestion des clés (KMU) [1](#sdk-compare-note-1) | Oui | Oui |
| Outil de configuration | Oui | Oui |
[1] Les composants CMU et KMU sont inclus dans l’interface de ligne de commande CloudHSM avec le SDK client 5.
Les sections suivantes décrivent les composants.
## Bibliothèque PKCS \$111
PKCS \$111 est une norme permettant d'effectuer des opérations cryptographiques sur des modules de sécurité matériels ()HSMs. AWS CloudHSM propose des implémentations de la bibliothèque PKCS \$111 conformes à la version 2.40 de PKCS \$111.
+ Pour le SDK client 3, la bibliothèque PKCS \$111 est un composant Linux uniquement compatible avec le support de base de Linux. Pour de plus amples informations, veuillez consulter [Support Linux pour AWS CloudHSM le SDK client 3](sdk3-linux.md).
+ Pour le SDK client 5, la bibliothèque PKCS \$111 est un composant multiplateforme compatible avec le support de base du SDK client 5 pour Linux et Windows. Pour plus d’informations, consultez [Support Linux pour AWS CloudHSM le SDK client 5](sdk8-linux.md) et [Support Windows pour AWS CloudHSM le SDK client 5](sdk8-windows.md).
## Utilitaire de gestion CloudHSM (CMU)
L'outil de ligne de commande CloudHSM Management Utility (CMU) aide les responsables du chiffrement à gérer les utilisateurs dans le. HSMs Il inclut des outils permettant de créer, supprimer et répertorier des utilisateurs, et de modifier des mots de passe utilisateur. Pour de plus amples informations, veuillez consulter [AWS CloudHSM Utilitaire de gestion (CMU)](cloudhsm_mgmt_util.md).
## Utilitaire de gestion des clés (KMU)
L'utilitaire de gestion des clés (KMU) est un outil en ligne de commande qui aide les utilisateurs de chiffrement (CU) à gérer les clés des modules de sécurité matériels (HSM). Pour de plus amples informations, veuillez consulter [AWS CloudHSM Utilitaire de gestion des clés (KMU)](key_mgmt_util.md).
## Fournisseur JCE
Le fournisseur AWS CloudHSM JCE est conforme à l'architecture cryptographique Java (JCA). Le fournisseur vous permet d'effectuer des opérations cryptographiques sur le HSM.
Le fournisseur JCE est un composant uniquement pour Linux qui correspond au support de base de Linux. Pour de plus amples informations, veuillez consulter [Support Linux pour AWS CloudHSM le SDK client 3](sdk3-linux.md).
+ Pour le SDK client 3, OpenJDK 1.8 est requis
## OpenSSL Dynamic Engine
Le moteur dynamique AWS CloudHSM OpenSSL vous permet de décharger des opérations cryptographiques vers votre cluster CloudHSM via l'API OpenSSL.
+ Pour le SDK client 3, le moteur dynamique OpenSSL est un composant uniquement Linux qui *ne* correspond pas au support de base de Linux. Consultez les exclusions ci-dessous.
+ Nécessite OpenSSL 1.0.2[f\$1]
**Plateformes non prises en charge :**
+ CentOS 8
+ Red Hat Enterprise Linux (RHEL) 8
+ Ubuntu 18.04 LTS
Ces plateformes sont fournies avec une version d'OpenSSL incompatible avec OpenSSL Dynamic Engine for Client SDK 3. AWS CloudHSM prend en charge ces plateformes avec OpenSSL Dynamic Engine for Client SDK 5.
+ Pour le SDK client 5, le moteur dynamique OpenSSL est un composant uniquement pour Linux qui nécessite OpenSSL 1.0.2, 1.1.1 ou 3.x.
## Fournisseur de stockage de clés (KSP)
Le Key Storage Provider (KSP) est une API cryptographique spécifique au système d'exploitation Microsoft Windows.
Pour le SDK client 3, les fournisseurs CNG et KSP sont des composants Windows uniquement compatibles avec le support de base de Windows. Pour de plus amples informations, veuillez consulter [Support Windows pour AWS CloudHSM le SDK client 3](sdk3-windows.md).
Pour le SDK client 5, le fournisseur de stockage de clés (KSP) est un composant Windows uniquement compatible avec le support de base de Windows. Pour de plus amples informations, veuillez consulter [Support Windows pour AWS CloudHSM le SDK client 5](sdk8-windows.md).
# Migration du SDK AWS CloudHSM client 3 vers le SDK client 5
Dans AWS CloudHSM, les applications client exécutent des opérations cryptographiques à l'aide du kit de développement logiciel (SDK) AWS CloudHSM client. Le SDK client 5 est le SDK principal auquel de nouvelles fonctionnalités et un support de plateforme continuent d'être ajoutés.
Le SDK client 3 inclut deux outils de ligne de commande distincts : le CMU pour la gestion des utilisateurs et le KMU pour la gestion des clés et l'exécution des opérations avec les clés. Le SDK client 5 consolide les fonctions de la CMU et de la KMU (outils proposés avec le SDK client 3) en un seul outil, le. [AWS CloudHSM Interface de ligne de commande (CLI)](cloudhsm_cli.md) Les opérations de gestion des utilisateurs se trouvent sous les sous-commandes [Catégorie d'utilisateur dans la CLI CloudHSM](cloudhsm_cli-user.md) et[La catégorie de quorum dans la CLI CloudHSM](cloudhsm_cli-qm.md). Les opérations de gestion des clés se trouvent sous la [sous-commande clé](cloudhsm_cli-key.md), et les opérations cryptographiques se trouvent sous la sous-commande [cryptographique](cloudhsm_cli-crypto.md). Voir [Référence pour les commandes de la CLI CloudHSM](cloudhsm_cli-reference.md) pour une liste complète des commandes.
Pour connaître les avantages de la migration, voir[Avantages du SDK AWS CloudHSM client 5](client-sdk-5-benefits.md).
Consultez les rubriques suivantes pour obtenir des instructions détaillées sur la migration du SDK client 3 vers le SDK client 5. La dernière version du SDK AWS CloudHSM client est la 5.16.
+ [Migrez votre bibliothèque AWS CloudHSM PKCS \$111 du SDK client 3 vers le SDK client 5](pkcs11-migrate-to-sdk-5.md)
+ [Migrez votre moteur dynamique OpenSSL du SDK client 3 AWS CloudHSM vers le SDK client 5](openssl-migrate-to-sdk-5.md)
+ [Migrez votre fournisseur de stockage de clés (KSP) du SDK AWS CloudHSM client 3 vers le SDK client 5](ksp-migrate-to-sdk-5.md)
+ [Migrez votre fournisseur JCE du SDK AWS CloudHSM client 3 vers le SDK client 5](java-lib-migrate_to_sdk5.md)
Pour les fonctionnalités ou les cas d'utilisation non pris en charge par la CLI CloudHSM, contactez. [AWS Support](https://support.console.aws.amazon.com/support/home#/)
# Migrez votre bibliothèque AWS CloudHSM PKCS \$111 du SDK client 3 vers le SDK client 5
Utilisez cette rubrique pour migrer votre [bibliothèque AWS CloudHSM PKCS \$111](pkcs11-library.md) du SDK client 3 vers le SDK client 5. Pour connaître les avantages de la migration, voir[Avantages du SDK AWS CloudHSM client 5](client-sdk-5-benefits.md).
Dans AWS CloudHSM, les applications client exécutent des opérations cryptographiques à l'aide du kit de développement logiciel (SDK) AWS CloudHSM client. Le SDK client 5 est le SDK principal auquel de nouvelles fonctionnalités et un support de plateforme continuent d'être ajoutés.
Pour consulter les instructions de migration pour tous les fournisseurs, voir[Migration du SDK AWS CloudHSM client 3 vers le SDK client 5](client-sdk-migration.md).
## Préparez-vous en faisant face aux changements les plus importants
Passez en revue ces modifications majeures et mettez à jour votre application dans votre environnement de développement en conséquence.
### Les mécanismes d'enroulement ont changé
****
| Mécanisme du SDK client 3 | Mécanisme équivalent du SDK client 5 |
| --- | --- |
| `CKM_AES_KEY_WRAP` | `CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD` |
| `CKM_AES_KEY_WRAP_PAD` | `CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD` |
| `CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD` | `CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD` |
| `CKM_CLOUDHSM_AES_KEY_WRAP_NO_PAD` | `CKM_CLOUDHSM_AES_KEY_WRAP_NO_PAD` |
| `CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD` | `CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD` |
### ECDH
Dans le SDK client 3, vous pouvez utiliser ECDH et spécifier un KDF. Cette fonctionnalité n'est actuellement pas disponible dans le SDK client 5. Si votre application a besoin de cette fonctionnalité, veuillez contacter l'[assistance](https://support.console.aws.amazon.com/support/home#/).
### Les poignées de touches sont désormais spécifiques à la session
Pour utiliser correctement les descripteurs de clé dans le SDK client 5, vous devez obtenir des descripteurs de clé chaque fois que vous exécutez une application. Si vous avez des applications existantes qui utiliseront les mêmes descripteurs de clé au cours de différentes sessions, vous devez modifier votre code pour obtenir le descripteur de clé à chaque exécution de l'application. Pour plus d'informations sur la récupération des descripteurs de touches, consultez [cet exemple AWS CloudHSM PKCS \$111](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/find_objects/find_objects.c). Cette modification est conforme à la [spécification PKCS \$111 2.40](http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/os/pkcs11-base-v2.40-os.html#_Toc416959689).
## Migrer vers le SDK client 5
Suivez les instructions de cette section pour migrer du SDK client 3 vers le SDK client 5.
**Note**
Amazon Linux, Ubuntu 16.04, Ubuntu 18.04, CentOS 6, CentOS 8 et RHEL 6 ne sont actuellement pas pris en charge avec le SDK client 5. Si vous utilisez actuellement l'une de ces plateformes avec le SDK client 3, vous devrez en choisir une autre lors de la migration vers le SDK client 5.
1. Désinstallez la bibliothèque PKCS \$111 pour le SDK client 3.
------
#### [ Amazon Linux 2 ]
```
$ sudo yum remove cloudhsm-client-pkcs11
```
------
#### [ CentOS 7 ]
```
$ sudo yum remove cloudhsm-client-pkcs11
```
------
#### [ RHEL 7 ]
```
$ sudo yum remove cloudhsm-client-pkcs11
```
------
#### [ RHEL 8 ]
```
$ sudo yum remove cloudhsm-client-pkcs11
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo apt remove cloudhsm-client-pkcs11
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo apt remove cloudhsm-client-pkcs11
```
------
1. Arrêtez le démon client pour le SDK client 3.
------
#### [ Amazon Linux 2 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ CentOS 7 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ RHEL 7 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ RHEL 8 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo systemctl stop cloudhsm-client
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo systemctl stop cloudhsm-client
```
------
1. Désinstallez le démon client pour le SDK client 3.
------
#### [ Amazon Linux 2 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ CentOS 7 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ RHEL 7 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ RHEL 8 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo apt remove cloudhsm-client
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo apt remove cloudhsm-client
```
------
**Note**
Les configurations personnalisées doivent être réactivées.
1. Installez la bibliothèque PKCS \$111 du SDK client en suivant les étapes décrites dans. [Installation de la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5](pkcs11-library-install.md)
1. Le SDK client 5 introduit un nouveau format de fichier de configuration et un outil d'amorçage en ligne de commande. Pour démarrer votre bibliothèque PKCS \$111 du SDK client 5, suivez les instructions répertoriées dans le guide de l'utilisateur ci-dessous. [Amorcez le SDK client](cluster-connect.md#connect-how-to)
1. Dans votre environnement de développement, testez votre application. Mettez à jour votre code existant pour corriger les modifications importantes avant votre migration finale.
## Rubriques en relation
+ [Les meilleures pratiques pour AWS CloudHSM](best-practices.md)
# Migrez votre moteur dynamique OpenSSL du SDK client 3 AWS CloudHSM vers le SDK client 5
Utilisez cette rubrique pour migrer votre moteur [dynamique OpenSSL](openssl-library.md) du SDK client 3 AWS CloudHSM vers le SDK client 5. Pour connaître les avantages de la migration, voir[Avantages du SDK AWS CloudHSM client 5](client-sdk-5-benefits.md).
Dans AWS CloudHSM, les applications client exécutent des opérations cryptographiques à l'aide du kit de développement logiciel (SDK) AWS CloudHSM client. Le SDK client 5 est le SDK principal auquel de nouvelles fonctionnalités et un support de plateforme continuent d'être ajoutés.
**Note**
La génération de nombres aléatoires n'est actuellement pas prise en charge dans le SDK client 5 avec OpenSSL Dynamic Engine.
Pour consulter les instructions de migration pour tous les fournisseurs, voir[Migration du SDK AWS CloudHSM client 3 vers le SDK client 5](client-sdk-migration.md).
## Migrer vers le SDK client 5
Suivez les instructions de cette section pour migrer du SDK client 3 vers le SDK client 5.
**Note**
Amazon Linux, Ubuntu 16.04, Ubuntu 18.04, CentOS 6, CentOS 8 et RHEL 6 ne sont actuellement pas pris en charge avec le SDK client 5. Si vous utilisez actuellement l'une de ces plateformes avec le SDK client 3, vous devrez en choisir une autre lors de la migration vers le SDK client 5.
1. Désinstallez le moteur dynamique OpenSSL pour le SDK client 3.
------
#### [ Amazon Linux 2 ]
```
$ sudo yum remove cloudhsm-client-dyn
```
------
#### [ CentOS 7 ]
```
$ sudo yum remove cloudhsm-client-dyn
```
------
#### [ RHEL 7 ]
```
$ sudo yum remove cloudhsm-client-dyn
```
------
#### [ RHEL 8 ]
```
$ sudo yum remove cloudhsm-client-dyn
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo apt remove cloudhsm-client-dyn
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo apt remove cloudhsm-client-dyn
```
------
1. Arrêtez le démon client pour le SDK client 3.
------
#### [ Amazon Linux 2 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ CentOS 7 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ RHEL 7 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ RHEL 8 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo systemctl stop cloudhsm-client
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo systemctl stop cloudhsm-client
```
------
1. Désinstallez le démon client pour le SDK client 3.
------
#### [ Amazon Linux 2 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ CentOS 7 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ RHEL 7 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ RHEL 8 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo apt remove cloudhsm-client
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo apt remove cloudhsm-client
```
------
**Note**
Les configurations personnalisées doivent être réactivées.
1. Installez le SDK client OpenSSL Dynamic Engine en suivant les étapes décrites dans. [Installation du moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 5](openssl5-install.md)
1. Le SDK client 5 introduit un nouveau format de fichier de configuration et un outil d'amorçage en ligne de commande. Pour démarrer votre moteur dynamique OpenSSL Client SDK 5, suivez les instructions répertoriées dans le guide de l'utilisateur ci-dessous. [Amorcez le SDK client](cluster-connect.md#connect-how-to)
1. Dans votre environnement de développement, testez votre application. Mettez à jour votre code existant pour corriger les modifications importantes avant votre migration finale.
## Rubriques en relation
+ [Les meilleures pratiques pour AWS CloudHSM](best-practices.md)
# Migrez votre fournisseur de stockage de clés (KSP) du SDK AWS CloudHSM client 3 vers le SDK client 5
Cette rubrique explique comment migrer votre [fournisseur de stockage de clés (KSP)](ksp-library.md) du SDK AWS CloudHSM client 3 vers le SDK client 5. La dernière version du SDK AWS CloudHSM client est la 5.16. Pour plus d'informations sur les avantages de la migration, consultez[Avantages du SDK AWS CloudHSM client 5](client-sdk-5-benefits.md).
Dans AWS CloudHSM, vous utilisez le kit de développement logiciel (SDK) AWS CloudHSM client pour effectuer des opérations cryptographiques. Le SDK client 5 est le SDK principal qui reçoit les nouvelles fonctionnalités et les mises à jour de support de la plateforme.
Pour les instructions de migration pour tous les fournisseurs, voir[Migration du SDK AWS CloudHSM client 3 vers le SDK client 5](client-sdk-migration.md).
## Migrer vers le SDK client 5
1. Arrêtez le démon client pour le SDK client 3.
```
PS C:\> Stop-Service "AWS CloudHSM Client"
```
1. Installez le fournisseur de stockage de clés (KSP) du SDK client (KSP) sur votre instance Windows Server. Pour obtenir des instructions, veuillez consulter [Installation du fournisseur de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5](ksp-library-install.md).
1. Configurez votre fournisseur de stockage de clés (KSP) du SDK client (KSP) à l'aide du nouveau format de fichier de configuration et de l'outil de démarrage en ligne de commande. Pour obtenir des instructions, veuillez consulter [Amorcez le SDK client](cluster-connect.md#connect-how-to).
1. Le fournisseur de stockage de clés (KSP) pour AWS CloudHSM le SDK client 5 inclut le mode de SDK3 compatibilité pour prendre en charge les fichiers de référence clés générés dans. SDK3 Pour de plus amples informations, veuillez consulter [SDK3 mode de compatibilité pour le fournisseur de stockage de clés (KSP) pour AWS CloudHSM](ksp-library-configs-sdk3-compatibility-mode.md).
**Note**
Vous devez activer le mode de SDK3 compatibilité lorsque vous utilisez les fichiers de référence clés générés par le SDK client 3 avec le SDK client 5.
## Migrer vers de nouvelles instances Windows Server
1. Effectuez toutes les étapes de [la section Migrer vers le SDK client 5](#ksp-migrate-steps) sur vos nouvelles instances Windows Server.
1.
**Vérifiez les fichiers de référence clés existants**
Sur votre instance Windows Server d'origine, recherchez la présence de fichiers de référence clés dans`C:\Users\Default\AppData\Roaming\Microsoft\Crypto\CaviumKSP\GlobalPartition`.
+ Si des fichiers de référence clés existent, copiez tout le contenu sous « `C:\Users\Default\AppData\Roaming\Microsoft\Crypto\CaviumKSP` y `GlobalPartition` » dans le même chemin de répertoire sur votre nouvelle instance Windows Server. Créez le répertoire s'il n'existe pas.
+ Si les fichiers de référence clés n'existent pas, utilisez-les `cloudhsm-cli key generate-file --encoding ksp-key-reference` sur votre nouvelle instance Windows Server pour les créer. Pour obtenir des instructions, veuillez consulter [Génération de références clés KSP (Windows)](cloudhsm_cli-key-generate-file.md#key-generate-ksp-key-reference).
1.
**Vérifier le certificat racine**
Vérifiez votre certificat racine auprès des autorités de certification racine fiables :
```
PS C:\Users\Administrator\Desktop> certutil -store Root
Root "Trusted Root Certification Authorities"
================ Certificate 0 ================
Serial Number: certificate-serial-number
Issuer: CN=MYRootCA
NotBefore: 2/5/2020 1:38 PM
NotAfter: 2/5/2021 1:48 PM
Issuer: CN=MYRootCA
Signature matches Public Key
Root Certificate: Subject matches Issuer
Cert Hash(sha1): cert-hash
No key provider information
Cannot find the certificate and private key for decryption.
CertUtil: -store command completed successfully.
```
**Note**
Notez le numéro de série du certificat à utiliser à l'étape suivante.
1.
**Exporter le certificat racine**
Exportez le certificat racine vers un fichier :
```
certutil -store Root certificate-serial-number root-certificate-name.cer
```
1.
**Vérifier le certificat HSM-Backend**
Vérifiez votre certificat HSM-backend dans le magasin de certificats personnels :
```
PS C:\Users\Administrator\Desktop> certutil -store My
my "Personal"
================ Certificate 0 ================
Serial Number: certificate-serial-number
Issuer: CN=MYRootCA
NotBefore: 2/5/2020 1:38 PM
NotAfter: 2/5/2021 1:48 PM
Subject: CN=www.mydomain.com, OU=Certificate Management, O=Information Technology, L=Houston, S=Texas, C=US
Non-root Certificate
Cert Hash(sha1): cert-hash
Key Container = key-container-name
Provider = Cavium Key Storage Provider
Private key is NOT exportable
Encryption test passed
CertUtil: -store command completed successfully.
```
**Note**
Notez le numéro de série du certificat à utiliser à l'étape suivante.
1.
**Exporter le certificat HSM-backend**
Exportez le certificat HSM-Backend vers un fichier :
```
certutil -store My certificate-serial-number signed-certificate-name.cer
```
1.
**Importer le certificat racine**
Sur votre nouvelle instance Windows :
1. Copiez le fichier CA racine sur votre nouvelle instance Windows
1. Importez le certificat :
```
certutil -addstore Root root-certificate-name.cer
```
1.
**Vérifier l'installation du certificat racine**
Vérifiez que le certificat racine est correctement installé :
```
PS C:\Users\Administrator\Desktop> certutil -store Root
Root "Trusted Root Certification Authorities"
================ Certificate 0 ================
Serial Number: certificate-serial-number
Issuer: CN=MYRootCA
NotBefore: 2/5/2020 1:38 PM
NotAfter: 2/5/2021 1:48 PM
Issuer: CN=MYRootCA
Signature matches Public Key
Root Certificate: Subject matches Issuer
Cert Hash(sha1): cert-hash
No key provider information
Cannot find the certificate and private key for decryption.
CertUtil: -store command completed successfully.
```
1.
**Importer un certificat HSM-Backend**
Sur votre nouvelle instance Windows :
1. Copiez le certificat HSM-Backend sur votre nouvelle instance Windows
1. Importez le certificat :
```
certutil -addstore My signed-certificate-name.cer
```
1.
**Vérifier l'installation du certificat HSM-backend**
Vérifiez que le certificat HSM-Backend est correctement installé :
```
PS C:\Users\Administrator\Desktop> certutil -store My
my "Personal"
================ Certificate 0 ================
Serial Number: certificate-serial-number
Issuer: CN=MYRootCA
NotBefore: 2/5/2020 1:38 PM
NotAfter: 2/5/2021 1:48 PM
Subject: CN=www.mydomain.com, OU=Certificate Management, O=Information Technology, L=Houston, S=Texas, C=US
Non-root Certificate
Cert Hash(sha1): cert-hash
No key provider information
Cannot find the certificate and private key for decryption.
CertUtil: -store command completed successfully.
```
**Note**
Notez le numéro de série du certificat à utiliser dans les étapes suivantes.
1.
**Création d'un fichier de référence clé (facultatif)**
Effectuez cette étape uniquement si vous devez créer un nouveau fichier de référence clé. Sinon, passez à l'étape suivante.
**Note**
Cette fonctionnalité n'est disponible que dans les versions 5.16.0 et ultérieures du SDK.
1. Installez [OpenSSL](https://slproweb.com/products/Win32OpenSSL.html) et extrayez le module :
```
openssl x509 -in signed-certificate-name.cer -modulus -noout
```
**Note**
La commande OpenSSL affiche le module au format :. `Modulus=modulus-value` Notez le *modulus-value* à utiliser dans la commande suivante.
1. Créez un fichier de référence clé avec la CLI CloudHSM, voir : [Génération de références clés KSP (Windows)](cloudhsm_cli-key-generate-file.md#key-generate-ksp-key-reference)
```
& "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" key generate-file --encoding ksp-key-reference --filter attr.class=private-key attr.modulus=0xmodulus-value
```
**Note**
Les arguments de la commande *modulus-value* in CloudHSM CLI doivent être `0x` préfixés par un préfixe pour indiquer le format hexadécimal.
Les fichiers de référence clés sont créés dans`C:\Users\Default\AppData\Roaming\Microsoft\Crypto\CaviumKSP\GlobalPartition`.
1.
**Création d'une configuration de réparation**
Créez un fichier nommé `repair.txt` avec le contenu suivant:
```
[Properties]
11 = "" ; Add friendly name property
2 = "{text}" ; Add Key Provider Information property
_continue_="Container=key-container-name&"
_continue_="Provider=Cavium Key Storage Provider&"
_continue_="Flags=0&"
_continue_="KeySpec=2"
```
**Note**
Remplacez *key-container-name* par le nom de fichier de référence clé de`C:\Users\Default\AppData\Roaming\Microsoft\Crypto\CaviumKSP\GlobalPartition`.
1.
**Boutique de certificats de réparation**
Exécutez la commande de réparation :
```
certutil -repairstore My certificate-serial-number repair.txt
```
**Note**
Le numéro de série du certificat est obtenu lors des étapes précédentes lors de la vérification de l'installation du certificat HSM-backend.
1.
**Vérifier l'association des certificats**
Vérifiez que le certificat est correctement associé :
```
PS C:\Users\Administrator\Desktop> certutil -store My
my "Personal"
================ Certificate 0 ================
Serial Number: certificate-serial-number
Issuer: CN=MYRootCA
NotBefore: 2/5/2020 1:38 PM
NotAfter: 2/5/2021 1:48 PM
Subject: CN=www.mydomain.com, OU=Certificate Management, O=Information Technology, L=Houston, S=Texas, C=US
Non-root Certificate
Cert Hash(sha1): cert-hash
Key Container = key-container-name
Provider = Cavium Key Storage Provider
Private key is NOT exportable
ERROR: Could not verify certificate public key against private key
CertUtil: -store command completed successfully.
```
Vérifiez que le résultat indique :
+ Le nom correct du conteneur clé
+ Le fournisseur de stockage de clés Cavium
+ `ERROR: Could not verify certificate public key against private key`Il s'agit d'un problème connu, voir [Problème : échec de la vérification d'un magasin de certificats](ki-ksp-sdk.md#ki-ksp-1)
1.
**Testez votre application**
Avant de terminer la migration :
1. Testez votre application dans votre environnement de développement
1. Mettez à jour votre code pour corriger les modifications importantes
1. Pour obtenir des conseils spécifiques à l'application, voir [Intégration d'applications tierces avec AWS CloudHSM](third-party-applications.md)
## Vérifiez la migration
Une fois les étapes de migration terminées, vérifiez que :
+ Vos certificats sont correctement installés dans les magasins de certificats appropriés
+ Les fichiers de référence clés sont présents au bon endroit
+ Votre application peut effectuer des opérations cryptographiques à l'aide des certificats migrés
## Résolution des problèmes
Si vous rencontrez des problèmes lors de la migration, vérifiez :
+ Tous les certificats sont correctement exportés depuis le système source
+ Les numéros de série des certificats correspondent entre les systèmes
+ Les noms des conteneurs clés dans le fichier repair.txt correspondent à vos fichiers de référence clés
+ SDK3 le mode de compatibilité est activé si vous utilisez des SDK3 fichiers de référence clés générés par
## Rubriques en relation
+ [Les meilleures pratiques pour AWS CloudHSM](best-practices.md)
# Migrez votre fournisseur JCE du SDK AWS CloudHSM client 3 vers le SDK client 5
Utilisez cette rubrique pour migrer votre [fournisseur JCE](java-library.md) du SDK AWS CloudHSM client 3 vers le SDK client 5. Pour connaître les avantages de la migration, voir[Avantages du SDK AWS CloudHSM client 5](client-sdk-5-benefits.md).
Dans AWS CloudHSM, les applications client exécutent des opérations cryptographiques à l'aide du kit de développement logiciel (SDK) AWS CloudHSM client. Le SDK client 5 est le SDK principal auquel de nouvelles fonctionnalités et un support de plateforme continuent d'être ajoutés.
Le fournisseur JCE du SDK client 3 utilise des classes personnalisées APIs qui ne font pas partie de la spécification JCE standard. Le SDK client 5 pour le fournisseur JCE est conforme à la spécification JCE et est rétroincompatible avec le SDK client 3 dans certains domaines. Les applications du client peuvent nécessiter des modifications dans le cadre de la migration vers le SDK client 5. Cette section décrit les modifications requises pour une migration réussie.
Pour consulter les instructions de migration pour tous les fournisseurs, voir[Migration du SDK AWS CloudHSM client 3 vers le SDK client 5](client-sdk-migration.md).
**Topics**
+ [Préparez-vous en faisant face aux changements les plus importants](#jce-migration-preparation-sdk5)
+ [Migrer vers le SDK client 5](#w2aac25c19c21c15)
+ [Rubriques en relation](#java-lib-migrate_to_sdk5-seealso)
## Préparez-vous en faisant face aux changements les plus importants
Passez en revue ces modifications majeures et mettez à jour votre application dans votre environnement de développement en conséquence.
### La classe et le nom du fournisseur ont changé
****
| Qu'est-ce qui a changé | Ce que c'était dans le SDK client 3 | Qu'est-ce que c'est dans le SDK client 5 | Exemple |
| --- | --- | --- | --- |
| Classe et nom du fournisseur | La classe de fournisseur JCE du SDK client 3 est appelée `CaviumProvider` et porte le nom du fournisseur. `Cavium` | Dans le SDK client 5, la classe Provider est appelée `CloudHsmProvider` et porte le nom `CloudHSM` du fournisseur. | Un exemple d'initialisation de l'`CloudHsmProvider`objet est disponible dans le [référentiel AWS CloudHSM GitHub d'exemples](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AESGCMEncryptDecryptRunner.java#L43-L50). |
### La connexion explicite a changé, la connexion implicite n'a pas changé
****
| Qu'est-ce qui a changé | Ce que c'était dans le SDK client 3 | Qu'est-ce que c'est dans le SDK client 5 | Exemple |
| --- | --- | --- | --- |
| Login explicite | Le SDK client 3 utilise la `LoginManager` classe pour une connexion [1](#explicit_login_sdk3_note)explicite. | Dans le SDK client 5, le `CloudHSM` fournisseur implémente `AuthProvider` une connexion explicite. `AuthProvider`est une classe Java standard qui suit la méthode idiomatique de Java pour se connecter à un fournisseur. Grâce à la gestion améliorée de l'état de connexion dans le SDK client 5, les applications n'ont plus besoin de surveiller et d'effectuer des connexions lors des [2](#explicit_login_sdk5_note)reconnexions. | Pour un exemple d'utilisation de la connexion explicite avec le SDK client 5, consultez l' LoginRunner exemple dans le référentiel d'exemples [ GitHub AWS CloudHSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java#L109C5-L141). |
| Login implicite | Aucune modification n'est requise pour la connexion implicite. Le même fichier de propriétés et toutes les variables d'environnement continueront de fonctionner pour la connexion implicite lors de la migration du SDK client 3 vers le SDK client 5. | Pour un exemple d'utilisation de la connexion implicite avec le SDK client 5, consultez l'[LoginRunner exemple](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java#L143-L202) dans le référentiel AWS CloudHSM GitHub d'exemples. |
+ [1] Extrait de code du SDK client 3 :
```
LoginManager lm = LoginManager.getInstance();
lm.login(partition, user, pass);
```
+ [2] Extrait de code du SDK client 5 :
```
// Construct or get the existing provider object
AuthProvider provider = new CloudHsmProvider();
// Call login method on the CloudHsmProvider object
// Here loginHandler is a CallbackHandler
provider.login(null, loginHandler);
```
Pour un exemple d'utilisation de la connexion explicite avec le SDK client 5, consultez l'[LoginRunner exemple](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java#L109C5-L141) dans le référentiel AWS CloudHSM GitHub d'exemples.
### La génération de clés a changé
****
| Qu'est-ce qui a changé | Ce que c'était dans le SDK client 3 | Qu'est-ce que c'est dans le SDK client 5 | Exemple |
| --- | --- | --- | --- |
| Génération de clés | Dans le SDK client 3, `Cavium[Key-type]AlgorithmParameterSpec` est utilisé pour spécifier les paramètres de génération de clés. Pour un extrait de code, voir note de bas de page. [1](#key_generation_sdk3_note) | Dans le SDK client 5, `KeyAttributesMap` est utilisé pour spécifier les attributs de génération de clés. Pour un extrait de code, voir note de bas de page. [2](#key_generation_sdk5_note) | Pour un exemple expliquant comment l'utiliser `KeyAttributesMap` pour générer une clé symétrique, consultez l'[SymmetricKeys exemple dans le référentiel d'exemples](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/SymmetricKeys.java) GitHub AWS CloudHSM. |
| Génération de paires de clés | Dans le SDK client 3, `Cavium[Key-type]AlgorithmparameterSpec` est utilisé pour spécifier les paramètres de génération de paires de clés. Pour un extrait de code, voir note de bas de page. [3](#key_pair_generation_sdk3_note) | Dans le SDK client 5, `KeyPairAttributesMap` est utilisé pour spécifier ces paramètres. Pour un extrait de code, voir note de bas de page. [4](#key_pair_generation_sdk5_note) | Pour un exemple sur la façon de `KeyAttributesMap` générer une clé asymétrique, consultez l'[AsymmetricKeys exemple](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AsymmetricKeys.java) dans le référentiel AWS CloudHSM GitHub d'échantillons. |
+ [1] Extrait de code de génération de clé du SDK client 3 :
```
KeyGenerator keyGen = KeyGenerator.getInstance("AES", "Cavium");
CaviumAESKeyGenParameterSpec aesSpec = new CaviumAESKeyGenParameterSpec(
keySizeInBits,
keyLabel,
isExtractable,
isPersistent);
keyGen.init(aesSpec);
SecretKey aesKey = keyGen.generateKey();
```
+ [2] Extrait de code de génération de clé du SDK client 5 :
```
KeyGenerator keyGen = KeyGenerator.getInstance("AES",
CloudHsmProvider.PROVIDER_NAME);
final KeyAttributesMap aesSpec = new KeyAttributesMap();
aesSpec.put(KeyAttribute.LABEL, keyLabel);
aesSpec.put(KeyAttribute.SIZE, keySizeInBits);
aesSpec.put(KeyAttribute.EXTRACTABLE, isExtractable);
aesSpec.put(KeyAttribute.TOKEN, isPersistent);
keyGen.init(aesSpec);
SecretKey aesKey = keyGen.generateKey();
```
+ [3] Extrait de code de génération de paires de clés du SDK client 3 :
```
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("rsa", "Cavium");
CaviumRSAKeyGenParameterSpec spec = new CaviumRSAKeyGenParameterSpec(
keySizeInBits,
new BigInteger("65537"),
label + ":public",
label + ":private",
isExtractable,
isPersistent);
keyPairGen.initialize(spec);
keyPairGen.generateKeyPair();
```
+ [4] Extrait de code de génération de 5 paires de clés du SDK client :
```
KeyPairGenerator keyPairGen =
KeyPairGenerator.getInstance("RSA", providerName);
// Set attributes for RSA public key
final KeyAttributesMap publicKeyAttrsMap = new KeyAttributesMap();
publicKeyAttrsMap.putAll(additionalPublicKeyAttributes);
publicKeyAttrsMap.put(KeyAttribute.LABEL, label + ":Public");
publicKeyAttrsMap.put(KeyAttribute.MODULUS_BITS, keySizeInBits);
publicKeyAttrsMap.put(KeyAttribute.PUBLIC_EXPONENT,
new BigInteger("65537").toByteArray());
// Set attributes for RSA private key
final KeyAttributesMap privateKeyAttrsMap = new KeyAttributesMap();
privateKeyAttrsMap.putAll(additionalPrivateKeyAttributes);
privateKeyAttrsMap.put(KeyAttribute.LABEL, label + ":Private");
// Create KeyPairAttributesMap and use that to initialize the
// keyPair generator
KeyPairAttributesMap keyPairSpec =
new KeyPairAttributesMapBuilder()
.withPublic(publicKeyAttrsMap)
.withPrivate(privateKeyAttrsMap)
.build();
keyPairGen.initialize(keyPairSpec);
keyPairGen.generateKeyPair();
```
### La recherche, la suppression et le référencement des clés ont changé
Pour trouver une clé déjà générée, AWS CloudHSM il faut utiliser le KeyStore. Le SDK client 3 est de deux KeyStore types : `Cavium` et`CloudHSM`. Le SDK client 5 n'a qu'un seul KeyStore type :`CloudHSM`.
Le passage du `Cavium` KeyStore à `CloudHSM` KeyStore nécessite un changement de KeyStore type. En outre, le SDK client 3 utilise des poignées de touches pour référencer les clés, tandis que le SDK client 5 utilise des libellés de touches. Les modifications de comportement qui en résultent sont répertoriées ci-dessous.
| Qu'est-ce qui a changé | Ce que c'était dans le SDK client 3 | Qu'est-ce que c'est dans le SDK client 5 | Exemple |
| --- | --- | --- | --- |
| Principales références | Avec le SDK client 3, les applications utilisent des libellés ou des descripteurs de touches pour référencer les clés dans le HSM. Ils utilisent des étiquettes KeyStore pour trouver une clé, ou ils utilisent des poignées pour créer des `CaviumKey` objets. | Dans le SDK client 5, les applications peuvent utiliser le [AWS CloudHSM KeyStore Classe Java pour le SDK client 5](alternative-keystore_5.md) pour rechercher des clés par étiquette. Pour rechercher les clés par poignée, utilisez la touche AWS CloudHSM `KeyStoreWithAttributes` avec AWS CloudHSM `KeyReferenceSpec`. | |
| Recherche de plusieurs entrées | Lorsque vous recherchez une clé à l'aide de `getEntry``getKey`, ou `getCertificate` dans des scénarios où plusieurs éléments répondant aux mêmes critères existent dans le `Cavium` KeyStore, seule la première entrée trouvée sera renvoyée. | Avec le AWS CloudHSM `KeyStore` et`KeyStoreWithAttributes`, ce même scénario entraînera le lancement d'une exception. Pour résoudre ce problème, il est recommandé de définir des étiquettes uniques pour les clés à l'aide de la [Définissez les attributs des clés à l'aide de la CLI CloudHSM](cloudhsm_cli-key-set-attribute.md) commande de la CLI CloudHSM. Ou `KeyStoreWithAttributes#getKeys` utilisez-le pour renvoyer toutes les clés correspondant aux critères. | |
| Trouvez toutes les clés | Dans le SDK client 3, il est possible de trouver toutes les clés du HSM à l'aide de. `Util.findAllKeys()` | Le SDK client 5 simplifie et rend la recherche de clés plus efficace en utilisant la `KeyStoreWithAttributes` classe. Dans la mesure du possible, mettez vos clés en cache pour minimiser le temps de latence. Pour de plus amples informations, veuillez consulter [Gérez efficacement les clés de votre application](bp-application-integration.md#bp-manage-application). Lorsque vous devez récupérer toutes les clés du HSM, utilisez-les `KeyStoreWithAttributes#getKeys` avec une clé vide. `KeyAttributesMap` | Un exemple utilisant la `KeyStoreWithAttributes` classe pour trouver une clé est disponible dans le [référentiel AWS CloudHSM GitHub d'exemples](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java#L205-L223) et un extrait de code est affiché dans. [1](#using_keystore_att_note) |
| Suppression de la clé | Le SDK client 3 est utilisé `Util.deleteKey()` pour supprimer une clé. | L'`Key`objet du SDK client 5 implémente l'`Destroyable`interface qui permet de supprimer des clés à l'aide de la `destroy()` méthode de cette interface. | Un exemple de code illustrant la fonctionnalité de suppression de la clé se trouve dans le référentiel d'exemples [ GitHub CloudHSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java#L229-L234). Un exemple d'extrait de code pour chaque SDK est présenté dans. [2](#delete_key_note) |
+ [1] un extrait est affiché ci-dessous :
```
KeyAttributesMap findSpec = new KeyAttributesMap();
findSpec.put(KeyAttribute.LABEL, label);
findSpec.put(KeyAttribute.KEY_TYPE, keyType);
KeyStoreWithAttributes keyStore = KeyStoreWithAttributes.getInstance("CloudHSM");
keyStore.load(null, null);
keyStore.getKey(findSpec);
```
+ [2] Suppression d'une clé dans le SDK client 3 :
```
Util.deleteKey(key);
```
Suppression d'une clé dans le SDK client 5 :
```
((Destroyable) key).destroy();
```
### Les opérations de décompression du chiffrement ont changé, les autres opérations de chiffrement n'ont pas changé
**Note**
Aucune modification n'est requise pour les encrypt/decrypt/wrap opérations de chiffrement.
Les opérations de désencapsulage nécessitent que la `CaviumUnwrapParameterSpec` classe du SDK client 3 soit remplacée par l'une des classes suivantes, spécifique aux opérations cryptographiques répertoriées.
+ `GCMUnwrapKeySpec`pour `AES/GCM/NoPadding` déballer
+ `IvUnwrapKeySpec`pour `AESWrap unwrap` et `AES/CBC/NoPadding unwrap`
+ `OAEPUnwrapKeySpec` pour `RSA OAEP unwrap`
Exemple d'extrait pour : `OAEPUnwrapkeySpec`
```
OAEPParameterSpec oaepParameterSpec =
new OAEPParameterSpec(
"SHA-256",
"MGF1",
MGF1ParameterSpec.SHA256,
PSpecified.DEFAULT);
KeyAttributesMap keyAttributesMap =
new KeyAttributesMap(KeyAttributePermissiveProfile.KEY_CREATION);
keyAttributesMap.put(KeyAttribute.TOKEN, true);
keyAttributesMap.put(KeyAttribute.EXTRACTABLE, false);
OAEPUnwrapKeySpec spec = new OAEPUnwrapKeySpec(oaepParameterSpec,
keyAttributesMap);
Cipher hsmCipher =
Cipher.getInstance(
"RSA/ECB/OAEPPadding",
CloudHsmProvider.PROVIDER_NAME);
hsmCipher.init(Cipher.UNWRAP_MODE, key, spec);
```
### Les opérations de signature n'ont pas changé
Aucune modification n'est requise pour les opérations de signature.
## Migrer vers le SDK client 5
Suivez les instructions de cette section pour migrer du SDK client 3 vers le SDK client 5.
**Note**
Amazon Linux, Ubuntu 16.04, Ubuntu 18.04, CentOS 6, CentOS 8 et RHEL 6 ne sont actuellement pas pris en charge avec le SDK client 5. Si vous utilisez actuellement l'une de ces plateformes avec le SDK client 3, vous devrez en choisir une autre lors de la migration vers le SDK client 5.
1. Désinstallez le fournisseur JCE pour le SDK client 3.
------
#### [ Amazon Linux 2 ]
```
$ sudo yum remove cloudhsm-client-jce
```
------
#### [ CentOS 7 ]
```
$ sudo yum remove cloudhsm-client-jce
```
------
#### [ RHEL 7 ]
```
$ sudo yum remove cloudhsm-client-jce
```
------
#### [ RHEL 8 ]
```
$ sudo yum remove cloudhsm-client-jce
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo apt remove cloudhsm-client-jce
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo apt remove cloudhsm-client-jce
```
------
1. Arrêtez le démon client pour le SDK client 3.
------
#### [ Amazon Linux 2 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ CentOS 7 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ RHEL 7 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ RHEL 8 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo systemctl stop cloudhsm-client
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo systemctl stop cloudhsm-client
```
------
1. Désinstallez le démon client pour le SDK client 3.
------
#### [ Amazon Linux 2 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ CentOS 7 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ RHEL 7 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ RHEL 8 ]
```
$ sudo yum remove cloudhsm-client
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo apt remove cloudhsm-client
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo apt remove cloudhsm-client
```
------
**Note**
Les configurations personnalisées doivent être réactivées.
1. Installez le fournisseur JCE du SDK client en suivant les étapes décrites dans. [Installation du fournisseur JCE pour le SDK AWS CloudHSM client 5](java-library-install_5.md)
1. Le SDK client 5 introduit un nouveau format de fichier de configuration et un outil d'amorçage en ligne de commande. Pour démarrer votre fournisseur Client SDK 5 JCE, suivez les instructions répertoriées dans le guide de l'utilisateur ci-dessous. [Amorcez le SDK client](cluster-connect.md#connect-how-to)
1. Dans votre environnement de développement, testez votre application. Mettez à jour votre code existant pour corriger les modifications importantes avant votre migration finale.
## Rubriques en relation
+ [Les meilleures pratiques pour AWS CloudHSM](best-practices.md)
# Utilisation du SDK client 5 pour travailler avec AWS CloudHSM
AWS CloudHSM inclut deux versions principales du SDK client :
+ SDK client 5 : il s'agit de notre dernier SDK client par défaut. Pour plus d'informations sur ses avantages, consultez [Avantages du SDK AWS CloudHSM client 5](client-sdk-5-benefits.md).
+ SDK client 3 : il s'agit de notre ancien SDK client. Il inclut un ensemble complet de composants pour la compatibilité des applications basées sur les plateformes et les langages ainsi que des outils de gestion.
Pour obtenir des instructions sur la migration du SDK client 3 vers le SDK client 5, consultez. [Migration du SDK AWS CloudHSM client 3 vers le SDK client 5](client-sdk-migration.md)
Cette rubrique décrit le SDK client 5. Pour vérifier la version du SDK client que vous utilisez, voir
**Topics**
+ [Avantages du SDK AWS CloudHSM client 5](client-sdk-5-benefits.md)
+ [AWS CloudHSM Plateformes prises en charge par le SDK client 5](client-supported-platforms.md)
+ [bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5](pkcs11-library.md)
+ [Moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 5](openssl-library.md)
+ [Fournisseur AWS CloudHSM OpenSSL pour le SDK client 5](openssl-provider-library.md)
+ [Fournisseur de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5](ksp-library.md)
+ [fournisseur JCE pour le SDK AWS CloudHSM client 5](java-library.md)
# Avantages du SDK AWS CloudHSM client 5
Comparé au SDK AWS CloudHSM client 3, le SDK client 5 est plus facile à gérer, offre une configurabilité supérieure et une fiabilité accrue. Le SDK client 5 apporte également des avantages clés supplémentaires au SDK client 3.
**Conçu pour une architecture sans serveur**
Le SDK client 5 ne nécessite pas de démon client, vous n'avez donc plus besoin de gérer un service d'arrière-plan. Cela aide les utilisateurs de plusieurs manières significatives :
+ Cela simplifie le processus de démarrage des applications. Pour vous lancer avec CloudHSM, il vous suffit de configurer le SDK avant de démarrer votre application.
+ Vous n'avez pas besoin d'un processus permanent, ce qui facilite l'intégration avec des composants sans serveur tels que Lambda et Elastic Container Service (ECS).
**Meilleures intégrations tierces et portabilité facilitée**
Le SDK client 5 suit de près les spécifications JCE et facilite la portabilité entre les différents fournisseurs JCE et améliore les intégrations tierces
**Expérience utilisateur et configurabilité améliorées**
Le SDK client 5 améliore la lisibilité des messages de journal et fournit des exceptions et des mécanismes de gestion des erreurs plus clairs, ce qui facilite considérablement le triage en libre-service pour les utilisateurs. Le SDK 5 propose également diverses configurations, répertoriées sur la [page de l'outil de configuration](https://docs.aws.amazon.com/cloudhsm/latest/userguide/configure-sdk-5.html).
**Support de plateforme plus large**
Le SDK client 5 offre une meilleure prise en charge des plateformes d'exploitation modernes. Cela inclut la prise en charge des technologies ARM et une meilleure prise en charge de [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) et [OpenSSL](https://docs.aws.amazon.com/cloudhsm/latest/userguide/openssl-library.html). Pour plus d'informations, reportez-vous à la section [Plateformes prises en charge](client-supported-platforms.md).
**IPv6 support de connexion**
Le SDK client 5.14\$1 prend en charge les connexions à l'aide de la technologie Dual-Stack. HSMs IPv6
**Fonctionnalités et mécanismes supplémentaires**
Le SDK client 5 inclut des fonctionnalités et des mécanismes supplémentaires qui ne sont pas disponibles dans le SDK client 3, et le SDK client 5 continuera d'ajouter d'autres mécanismes à l'avenir.
# AWS CloudHSM Plateformes prises en charge par le SDK client 5
Le support de base est différent pour chaque version du SDK AWS CloudHSM client. Le support de plateforme pour les composants d'un SDK correspond généralement au support de base, mais pas toujours. Pour déterminer le support de plate-forme pour un composant donné, assurez-vous d'abord que la plate-forme que vous souhaitez apparaît dans la section de base du SDK, puis vérifiez les exclusions ou toute autre information pertinente dans la section du composant.
AWS CloudHSM ne prend en charge que les systèmes d'exploitation 64 bits.
Le support de la plateforme évolue au fil du temps. Les versions antérieures du SDK du client CloudHSM peuvent ne pas prendre en charge tous les systèmes d'exploitation répertoriés ici. Utilisez les notes de mise à jour pour déterminer le système d'exploitation compatible avec les versions précédentes du SDK du client CloudHSM. Pour de plus amples informations, veuillez consulter [Téléchargements pour AWS CloudHSM le SDK client](client-history.md).
Pour connaître les plateformes prises en charge par le précédent SDK client, voir [AWS CloudHSM Plateformes prises en charge par le SDK client 3](sdk3-support.md)
Le SDK client 5 ne nécessite pas de démon client.
**Topics**
+ [Support Linux pour le SDK client 5](sdk8-linux.md)
+ [Support Windows pour le SDK client 5](sdk8-windows.md)
+ [Support pour architecture sans serveur pour le SDK client 5](sdk8-serverless.md)
+ [Compatibilité HSM pour le SDK client 5](sdk5-hsm-types.md)
# Support Linux pour AWS CloudHSM le SDK client 5
AWS CloudHSM Le SDK client 5 prend en charge les systèmes d'exploitation et plateformes Linux suivants.
| Plateformes prises en charge | Architecture x86\$164 | Architecture ARM |
| --- | --- | --- |
| Amazon Linux 2 | Oui | Oui |
| Amazon Linux 2023 | Oui | Oui |
| Red Hat Enterprise Linux 8 (8.3 ou version ultérieure) | Oui | Oui |
| Red Hat Enterprise Linux 9 (version 9.2\$1) | Oui | Oui |
| Red Hat Enterprise Linux 10 (10.0\$1) | Oui | Oui |
| Ubuntu 22.04 LTS | Oui | Oui |
| Ubuntu 24.04 LTS | Oui | Oui |
+ Le SDK 5.16 était la dernière version à prendre en charge la plate-forme Ubuntu 20.04 LTS. Pour plus d'informations, consultez le [site Web d'Ubuntu](https://ubuntu.com/blog/ubuntu-20-04-lts-end-of-life-standard-support-is-coming-to-an-end-heres-how-to-prepare).
+ Le SDK 5.12 était la dernière version à prendre en charge la plate-forme CentOS 7 (7.8\$1). Pour plus d'informations, veuillez consulter le [site Web CentOS](https://blog.centos.org/2023/04/end-dates-are-coming-for-centos-stream-8-and-centos-linux-7/).
+ Le SDK 5.12 est la dernière version à prendre en charge la plate-forme Red Hat Enterprise Linux 7 (7.8\$1). Pour plus d'informations, consultez le [site Web de Red Hat](https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux/rhel-7-end-of-maintenance).
+ Le SDK 5.4.2 est la dernière version à prendre en charge la plate-forme CentOS 8. Pour plus d'informations, veuillez consulter le [site Web CentOS](https://www.centos.org/centos-linux-eol/).
# Support Windows pour AWS CloudHSM le SDK client 5
AWS CloudHSM Le SDK client 5 prend en charge les versions suivantes de Windows Server.
+ Microsoft Windows Server 2016
+ Microsoft Windows Server 2019
+ Microsoft Windows Server 2022
+ Microsoft Windows Server 2025
# Support sans serveur pour le SDK AWS CloudHSM client 5
AWS CloudHSM Le SDK client 5 prend en charge les services AWS sans serveur suivants.
+ AWS Lambda
+ Docker/ECS
# Compatibilité HSM pour le SDK AWS CloudHSM client 5
Le tableau suivant décrit la compatibilité AWS CloudHSM du SDK client 5 pour HSMs.
| hsm1.medium | hsm2m.medium |
| --- | --- |
| Compatible avec les versions 5.0.0 et ultérieures du SDK client. | Compatible avec le SDK client version 5.9.0 et versions ultérieures. |
# bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
PKCS \$111 est une norme permettant d'effectuer des opérations cryptographiques sur des modules de sécurité matériels ()HSMs. AWS CloudHSM propose des implémentations de la bibliothèque PKCS \$111 conformes à la version 2.40 de PKCS \$111.
Pour plus d'informations sur l’amorçage, veuillez consulter [Connexion au cluster](cluster-connect.md). Pour le dépannage, voir[Problèmes connus relatifs à la bibliothèque PKCS \$111 pour AWS CloudHSMProblèmes connus pour la bibliothèque PKCS\$111](ki-pkcs11-sdk.md).
Pour plus d'informations sur l'utilisation du SDK client 3, veuillez consulter [Utilisation de la version précédente du SDK pour travailler avec AWS CloudHSM](choose-client-sdk.md).
**Topics**
+ [Installation de la bibliothèque PKCS \$111](pkcs11-library-install.md)
+ [Authentifiez-vous auprès de la bibliothèque PKCS \$111](pkcs11-pin.md)
+ [Types de clé](pkcs11-key-types.md)
+ [Mécanismes](pkcs11-mechanisms.md)
+ [opérations d’API](pkcs11-apis.md)
+ [Attributs de clé](pkcs11-attributes.md)
+ [Exemples de code](pkcs11-samples.md)
+ [Configurations avancées.](pkcs11-library-configs.md)
+ [Stockage des certificats](pkcs11-certificate-storage.md)
# Installation de la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
Cette rubrique fournit des instructions pour installer la dernière version de la bibliothèque PKCS \$111 pour la série de versions 5 du SDK AWS CloudHSM client. Pour plus d'informations sur le SDK client ou la bibliothèque PKCS \$111, consultez la section [Utilisation du SDK client](use-hsm.md) et la [bibliothèque PKCS \$111](pkcs11-library.md).
Avec le SDK client 5, il n'est pas nécessaire d'installer ou d'exécuter un démon client.
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).
Pour plus d'informations sur la bibliothèque PKCS \$111 dans le SDK client 5, consultez la section [bibliothèque PKCS \$111](pkcs11-library.md).
**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).
**Pour installer e configurer la bibliothèque PKCS \$111**
1. Utilisez les commandes suivantes pour télécharger et installer la bibliothèque PKCS \$111.
------
#### [ Amazon Linux 2023 ]
Installez la bibliothèque PKCS \$111 pour Amazon Linux 2023 sur une architecture X86\$164 :
```
$ 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
```
Installez la bibliothèque PKCS \$111 pour Amazon Linux 2023 sur ARM64 l'architecture :
```
$ 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 ]
Installez la bibliothèque PKCS \$111 pour Amazon Linux 2 sur une architecture X86\$164 :
```
$ 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
```
Installez la bibliothèque PKCS \$111 pour Amazon Linux 2 sur ARM64 l'architecture :
```
$ 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) ]
Installez la bibliothèque PKCS \$111 pour RHEL 10 sur l'architecture X86\$164 :
```
$ 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
```
Installez la bibliothèque PKCS \$111 pour RHEL 10 sur ARM64 l'architecture :
```
$ 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) ]
Installez la bibliothèque PKCS \$111 pour RHEL 9 sur l'architecture X86\$164 :
```
$ 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
```
Installez la bibliothèque PKCS \$111 pour RHEL 9 sur ARM64 l'architecture :
```
$ 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) ]
Installez la bibliothèque PKCS \$111 pour RHEL 8 sur l'architecture X86\$164 :
```
$ 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
```
Installez la bibliothèque PKCS \$111 pour RHEL 8 sur ARM64 l'architecture :
```
$ 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 ]
Installez la bibliothèque PKCS \$111 pour Ubuntu 24.04 LTS sur l'architecture X86\$164 :
```
$ 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
```
Installez la bibliothèque PKCS \$111 pour Ubuntu 24.04 LTS sur ARM64 l'architecture :
```
$ 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 ]
Installez la bibliothèque PKCS \$111 pour Ubuntu 22.04 LTS sur l'architecture X86\$164 :
```
$ 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
```
Installez la bibliothèque PKCS \$111 pour Ubuntu 22.04 LTS sur ARM64 l'architecture :
```
$ 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 ]
Installez la bibliothèque PKCS \$111 pour Windows Server sur une architecture X86\$164 :
1. Téléchargez la [bibliothèque PKCS \$111 pour le SDK client 5](https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Windows/AWSCloudHSMPKCS11-latest.msi).
1. Exécutez le programme d'installation de la bibliothèque PKCS \$111 (**AWSCloudHSMPKCS11-latest.msi**) avec les privilèges d'administrateur Windows.
------
1. Utilisez l'outil de configuration pour spécifier l'emplacement du certificat émetteur. Pour obtenir des instructions, veuillez consulter [Spécifier l'emplacement du certificat émetteur](cluster-connect.md#specify-cert-location).
1. Pour vous connecter à votre cluster, consultez [Amorcez le SDK client](cluster-connect.md#connect-how-to).
1. Vous trouverez les fichiers de bibliothèque PKCS \$111 dans les emplacements suivants :
+ Binaires, scripts de configuration et fichiers journaux Linux :
```
/opt/cloudhsm
```
Binaires Windows :
```
C:\Program Files\Amazon\CloudHSM
```
Scripts de configuration et fichiers journaux Windows :
```
C:\ProgramData\Amazon\CloudHSM
```
# Authentifiez-vous auprès de la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
Lorsque vous utilisez la bibliothèque PKCS \$111, votre application s'exécute en tant qu'[utilisateur cryptographique (CU)](manage-hsm-users.md) spécifique HSMs dans AWS CloudHSM votre fichier d'entrée. Votre application peut afficher et gérer uniquement les clés que le CU possède et partage. Vous pouvez utiliser une CU existante dans votre application HSMs ou en créer une nouvelle pour votre application. Pour plus d'informations sur la gestion CUs, voir [Gestion des utilisateurs HSM avec CloudHSM CLI et Gestion des utilisateurs HSM](manage-hsm-users-chsm-cli.md) [avec CloudHSM Management Utility](manage-hsm-users-cmu.md) (CMU)
Pour spécifier le CU pour PKCS \$111, utilisez le paramètre de code PIN PKCS \$111 [fonction C\$1Login](http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/os/pkcs11-base-v2.40-os.html#_Toc385057915). En AWS CloudHSM effet, le paramètre pin a le format suivant :
```
:
```
Par exemple, la commande suivante définit le code PIN de bibliothèque PKCS \$111 sur le CU avec le nom d'utilisateur `CryptoUser` et le mot de passe `CUPassword123!`.
```
CryptoUser:CUPassword123!
```
# Types de clés pris en charge pour la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
La bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5 prend en charge 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 des clés Triple DES 192 bits. Voir la note [1](#key-types-1) ci-dessous pour un changement à venir. |
| EC | Générez des clés avec les courbes 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. |
| 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.
# Mécanismes pris en charge pour la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
La bibliothèque PKCS \$111 est conforme à la version 2.40 de la spécification PKCS \$111. Pour appeler une fonction de chiffrement utilisant PKCS \$111, appelez une fonction à l'aide d'un mécanisme donné. Les sections suivantes résument les combinaisons de fonctions et de mécanismes pris en charge par AWS CloudHSM le SDK client 5.
La bibliothèque PKCS \$111 prend en charge les algorithmes suivants :
+ **Chiffrement et déchiffrement** — AES-CBC, AES-CTR, AES-ECB, AES-GCM, -CBC, -ECB, RSA-OAEP et RSA-PKCS DES3 DES3
+ **Signature et vérification** : RSA, HMAC et ECDSA ; avec et sans hachage
+ **Hash/digest** — SHA1,, SHA224 SHA256, et SHA384 SHA512
+ **Encapsulage de clés** – AES Key Wrap,[1](#mech1) AES-GCM, RSA-AES et RSA-OAEP
+ **Dérivation de clés** — SP800 -108 Compter KDF et ECDH avec KDF (les algorithmes KDF pris en charge sont X9.63 avec,,,,) SHA1 SHA224 SHA256 SHA384 SHA512
**Topics**
+ [Génération de fonctions de clé et de paire de clés](#pkcs11-mech-function-genkey)
+ [Fonctions de signature et de vérification](#pkcs11-mech-function-signverify)
+ [Fonctions de récupération de signature et de récupération de vérification](#pkcs11-mech-function-sr-vr)
+ [Fonctions de résumé](#pkcs11-mech-function-digest)
+ [Fonctions de chiffrement et de déchiffrement](#pkcs11-mech-function-enc-dec)
+ [Fonctions de dérivation de clé](#pkcs11-mech-function-derive-key)
+ [Fonctions d'encapsulage et de désencapsulage](#pkcs11-mech-function-wrap-unwrap)
+ [Taille maximale des données pour chaque mécanisme](#pkcs11-mech-max)
+ [Annotations du mécanisme](#pkcs11-mech-annotations)
## Génération de fonctions de clé et de paire de clés
La bibliothèque AWS CloudHSM logicielle de la bibliothèque PKCS \$111 vous permet d'utiliser les mécanismes suivants pour les fonctions Generate Key et Key Pair.
+ `CKM_RSA_PKCS_KEY_PAIR_GEN`
+ `CKM_RSA_X9_31_KEY_PAIR_GEN` – Le fonctionnement de ce mécanisme est identique au mécanisme `CKM_RSA_PKCS_KEY_PAIR_GEN`, mais offre de meilleures garanties pour la génération de `p` et `q`.
+ `CKM_EC_KEY_PAIR_GEN`
+ `CKM_GENERIC_SECRET_KEY_GEN`
+ `CKM_AES_KEY_GEN`
+ `CKM_DES3_KEY_GEN`— le changement à venir est indiqué dans la note de bas de page [5](#mech5).
## Fonctions de signature et de vérification
La bibliothèque AWS CloudHSM logicielle de la bibliothèque PKCS \$111 vous permet d'utiliser les mécanismes suivants pour les fonctions de signature et de vérification. 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.
Avec le SDK client 5, le hachage RSA et ECDSA est effectué localement, il n'y a donc aucune limite de données. Avec HMAC, il existe une limite de données. Pour plus d'informations, consultez la note de bas de page [2](#mech2).
**RSA**
+ `CKM_RSA_X_509`
+ `CKM_RSA_PKCS` - Opérations à une seule partie uniquement.
+ `CKM_RSA_PKCS_PSS` - Opérations à une seule partie uniquement.
+ `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` - Opérations à une seule partie uniquement.
+ `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`
## Fonctions de récupération de signature et de récupération de vérification
Le SDK client 5 ne prend pas en charge les fonctions de récupération de signature et de récupération de vérification.
## Fonctions de résumé
La bibliothèque AWS CloudHSM logicielle de la bibliothèque PKCS \$111 vous permet d'utiliser les mécanismes suivants pour les fonctions Digest. 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.
+ `CKM_SHA_1`
+ `CKM_SHA224`
+ `CKM_SHA256`
+ `CKM_SHA384`
+ `CKM_SHA512`
## Fonctions de chiffrement et de déchiffrement
La bibliothèque AWS CloudHSM logicielle de la bibliothèque PKCS \$111 vous permet d'utiliser les mécanismes suivants pour les fonctions de chiffrement et de déchiffrement.
+ `CKM_RSA_X_509`
+ `CKM_RSA_PKCS` - Opérations à une seule partie uniquement. Modification à venir répertoriée dans la note de bas de page [5](#mech5).
+ `CKM_RSA_PKCS_OAEP` - Opérations à une seule partie uniquement.
+ `CKM_AES_ECB`
+ `CKM_AES_CTR`
+ `CKM_AES_CBC`
+ `CKM_AES_CBC_PAD`
+ `CKM_DES3_CBC`— le changement à venir est indiqué dans la note de bas de page [5](#mech5).
+ `CKM_DES3_ECB`— le changement à venir est indiqué dans la note de bas de page [5](#mech5).
+ `CKM_DES3_CBC_PAD`— le changement à venir est indiqué dans la note de bas de page [5](#mech5).
+ `CKM_AES_GCM` [1](#mech1), [2](#mech2)
+ `CKM_CLOUDHSM_AES_GCM`[3](#mech3)
## Fonctions de dérivation de clé
La bibliothèque AWS CloudHSM logicielle de la bibliothèque PKCS \$111 prend en charge les principaux mécanismes de dérivation suivants :
+ `CKM_SP800_108_COUNTER_KDF`
+ `CKM_ECDH1_DERIVE`- Supporte la dérivation de clés ECDH avec les types KDF suivants définis par le fournisseur : [6](#kdf6)
+ `CKD_CLOUDHSM_X963_SHA1_KDF`- X9.63 KDF avec SHA1 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA224_KDF`- X9.63 KDF avec SHA224 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA256_KDF`- X9.63 KDF avec SHA256 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA384_KDF`- X9.63 KDF avec SHA384 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA512_KDF`- X9.63 KDF avec SHA512 [7](#kdf7)
## Fonctions d'encapsulage et de désencapsulage
La bibliothèque AWS CloudHSM logicielle de la bibliothèque PKCS \$111 vous permet d'utiliser les mécanismes suivants pour les fonctions Wrap et Unwrap.
Pour plus d'informations sur l'encapsulage de clé AES, voir [Encapsulage de clé AES](manage-aes-key-wrapping.md).
+ `CKM_RSA_PKCS` - Opérations à une seule partie uniquement. Une modification à venir est répertoriée dans la note de bas de page [5](#mech5).
+ `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)
## Taille maximale des données pour chaque mécanisme
Le tableau suivant répertorie la taille maximale des données définie pour chaque mécanisme :
**Taille maximale des jeux de données**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-mechanisms.html)
## Annotations du mécanisme
+ [1] Lorsque vous procédez au chiffrement AES GCM, le HSM n'accepte pas de données du vecteur d'initialisation (VI) de l'application. Vous devez utiliser un vecteur d’initialisation qu’il génère. Le vecteur d'initialisation 12 octets fourni par le HSM est écrit dans la référence en mémoire vers lequel pointe l'élément pIV des paramètres `CK_GCM_PARAMS` de la structure que vous fournissez. Pour éviter toute confusion de l'utilisateur, le kit SDK PKCS\$111 version 1.1.1 et ultérieure s’assure que cet élément pIV pointe vers une mémoire tampon mise à zéro lorsque le chiffrement AES-GCM est initialisé.
+ [2] Lors de l’utilisation de données avec l’un des mécanismes suivants, si la mémoire tampon des données dépasse la taille maximale des données, l’opération génère une erreur. Pour ces mécanismes, tout le traitement des données doit avoir lieu à l'intérieur du HSM. Pour plus d'informations sur les ensembles de tailles de données maximales pour chaque mécanisme, reportez-vous à[Taille maximale des données pour chaque mécanisme](#pkcs11-mech-max).
+ [3] Mécanisme défini par le fournisseur. Afin d'utiliser les mécanismes définis par le fournisseur CloudHSM, les applications PKCS \$111 doivent inclure `/opt/cloudhsm/include/pkcs11/pkcs11t.h` lors de la compilation.
`CKM_CLOUDHSM_AES_GCM` : Ce mécanisme propriétaire est une alternative plus sûre par programme à la norme `CKM_AES_GCM`. Il ajoute le IV généré par le HSM au chiffrement au lieu de l'écrire dans la structure `CK_GCM_PARAMS` fournie lors de l'initialisation du chiffrement. Vous pouvez utiliser ce mécanisme avec les fonctions `C_Encrypt`, `C_WrapKey`, `C_Decrypt` et `C_UnwrapKey`. Lors de l'utilisation de ce mécanisme, la variable PiV dans la structure `CK_GCM_PARAMS` doit être définie sur `NULL`. Lors de l'utilisation de ce mécanisme avec `C_Decrypt` et `C_UnwrapKey`, le IV doit être ajouté au texte chiffré qui est en cours de désencapsulage.
`CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD` : Encapsulage des clés AES avec remplissage PKCS \$15
`CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD` : Encapsulage des clés AES avec remplissage à l'aide de zéros
+ [4] Les `CK_MECHANISM_TYPE` et `CK_RSA_PKCS_MGF_TYPE` suivants sont pris en charge en tant que `CK_RSA_PKCS_OAEP_PARAMS` pour `CKM_RSA_PKCS_OAEP`:
+ `CKM_SHA_1` utilisant `CKG_MGF1_SHA1`
+ `CKM_SHA224` utilisant `CKG_MGF1_SHA224`
+ `CKM_SHA256` utilisant `CKG_MGF1_SHA256`
+ `CKM_SHA384` utilisant `CKM_MGF1_SHA384`
+ `CKM_SHA512` utilisant `CKM_MGF1_SHA512`
+ [5] 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.
+ [6] Types définis par le fournisseur. Pour utiliser les types définis par le fournisseur CloudHSM, les applications PKCS \$111 doivent être incluses lors de la compilation. `cloudhsm_pkcs11_vendor_defs.h` Cela se trouve dans `/opt/cloudhsm/include/pkcs11/cloudhsm_pkcs11_vendor_defs.h` pour les plateformes basées sur Linux et `C:\Program Files\Amazon\CloudHSM\include\pkcs11\cloudhsm_pkcs11_vendor_defs.h` pour les plateformes basées sur Windows
+ [7] Les principales fonctions de dérivation (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.
# Opérations d'API prises en charge pour la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
La bibliothèque PKCS \$111 prend en charge les opérations d'API PKCS \$111 suivantes pour le SDK AWS CloudHSM client 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`
# Attributs clés de la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
Un objet AWS CloudHSM clé peut être une clé publique, privée ou secrète. Les actions autorisées sur un objet de clé sont spécifiées via des attributs. Les attributs sont définis lorsque l'objet de clé est créé. Lorsque vous utilisez la bibliothèque PKCS \$111 pour AWS CloudHSM, nous attribuons des valeurs par défaut conformément à la norme PKCS \$111.
AWS CloudHSM ne prend pas en charge tous les attributs répertoriés dans la spécification PKCS \$111. Nous nous conformons à la spécification pour tous les attributs que nous prenons en charge. Ces attributs sont indiqués dans les tableaux respectifs.
Les fonctions cryptographiques telles que `C_CreateObject`, `C_GenerateKey`, `C_GenerateKeyPair`, `C_UnwrapKey` et `C_DeriveKey` qui créent, modifient ou copient des objets utilisent un modèle d’attribut en tant que paramètre. Pour plus d'informations sur la transmission d'un modèle d’attributs lors de la création d’un objet, consultez les exemples dans [Génération de clés par la bibliothèque PKCS \$111](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate).
Les rubriques suivantes fournissent des informations supplémentaires sur les attributs AWS CloudHSM clés.
**Topics**
+ [Tableaux d'attributs](pkcs11-attributes-interpreting.md)
+ [Modification d’attributs](modify-attr.md)
+ [Interprétation des codes d'erreur](attr-errors.md)
# Tables d'attributs de bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
Les tables de bibliothèque PKCS \$111 pour AWS CloudHSM contiennent une liste d'attributs qui diffèrent selon le type de clé. Il indique si un attribut donné est pris en charge pour un type de clé particulier lors de l'utilisation d'une fonction cryptographique spécifique avec AWS CloudHSM.
**Légende :**
+ ✔ indique que CloudHSM prend en charge l'attribut pour le type de clé spécifique.
+ ✖ indique que CloudHSM ne prend pas en charge l'attribut pour le type de clé spécifique.
+ R indique que la valeur de l'attribut est définie en lecture seule pour le type de clé spécifique.
+ S indique que l'attribut ne peut pas être lu par `GetAttributeValue` car sensible.
+ Une cellule vide dans la colonne Default Value (Valeur par défaut) indique qu'il n'y a aucune valeur par défaut attribuée à l'attribut.
## GenerateKeyPair
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## GenerateKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## CreateObject
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## UnwrapKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## DeriveKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## GetAttributeValue
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
**Annotations d'attributs**
+ [1] Cet attribut est partiellement pris en charge par le micrologiciel et doit être explicitement défini sur la valeur par défaut.
+ [2] Attribut obligatoire.
# Modification des attributs de bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
Certains attributs de bibliothèque PKCS \$111 d'un AWS CloudHSM objet peuvent être modifiés une fois l'objet créé, alors que d'autres ne le peuvent pas. Pour modifier les attributs, utilisez la commande [key set-attribute](cloudhsm_cli-key-set-attribute.md) de la CLI CloudHSM. Vous pouvez également obtenir une liste d'attributs à l'aide de la commande [key list](cloudhsm_cli-key-list.md) de la CLI CloudHSM.
La liste suivante contient les attributs que vous pouvez modifier après la création de l'objet :
+ `CKA_LABEL`
+ `CKA_TOKEN`
**Note**
La modification est autorisée uniquement pour changer une clé de session en une clé de jeton. Utilisez la commande [key set-attribute](cloudhsm_cli-key-set-attribute.md) de la CLI CloudHSM pour modifier la valeur de l'attribut.
+ `CKA_ENCRYPT`
+ `CKA_DECRYPT`
+ `CKA_SIGN`
+ `CKA_VERIFY`
+ `CKA_WRAP`
+ `CKA_UNWRAP`
+ `CKA_LABEL`
+ `CKA_SENSITIVE`
+ `CKA_DERIVE`
**Note**
Cet attribut prend en charge la dérivation de clé. Il doit être `False` pour toutes les clés publiques et ne peut pas être défini sur `True`. Pour les clés privées EC et secrètes, il peut être défini sur `True` ou `False`.
+ `CKA_TRUSTED`
**Note**
Cet attribut peut être défini sur `True` ou `False` par le responsable du chiffrement uniquement.
+ `CKA_WRAP_WITH_TRUSTED`
**Note**
Appliquez cet attribut à une clé de données exportable pour indiquer que vous ne pouvez encapsuler cette clé qu'avec des clés marquées comme `CKA_TRUSTED`. Une fois `CKA_WRAP_WITH_TRUSTED` défini sur true, l'attribut passe en lecture seule et vous ne pouvez ni le modifier ni le supprimer.
# Interprétation des codes d'erreur de la bibliothèque PKCS \$111 pour AWS CloudHSM le SDK client 5
La spécification dans le modèle d'un attribut de bibliothèque PKCS \$111 qui n'est pas pris en charge par une clé spécifique entraîne une erreur. Le tableau suivant contient des codes d'erreur qui sont générés lorsque vous violez des spécifications :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/attr-errors.html)
# Exemples de code pour la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5
Les exemples de code ci-dessous vous GitHub montrent comment accomplir des tâches de base à l'aide de la bibliothèque PKCS \$111 pour AWS CloudHSM le SDK client 5.
## Conditions préalables
Avant d'exécuter les exemples, effectuez les étapes suivantes pour configurer votre environnement :
+ Installez et configurez la [bibliothèque PKCS \$111](pkcs11-library-install.md) pour le SDK client 5.
+ Configurez un [utilisateur de chiffrement(CU).](manage-hsm-users.md) Votre application utilise ce compte HSM pour exécuter les exemples de code sur le HSM.
## Exemples de code
Des exemples de code pour la bibliothèque AWS CloudHSM logicielle de PKCS \$111 sont disponibles sur [GitHub](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples). Ce référentiel contient des exemples sur la façon d'effectuer des opérations courantes à l'aide de PKCS \$111, y compris le chiffrement, le déchiffrement, la signature et la vérification.
+ [Générer des clés (AES, RSA, EC)](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate)
+ [Afficher les attributs des clés](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/attributes/)
+ [Chiffrer et déchiffrer les données avec AES GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/encrypt/aes_gcm.c)
+ [Chiffrer et déchiffrer les données avec AES\$1CTR](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/aes_ctr.c)
+ [Chiffrer et déchiffrer les données avec 3DES](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/des_ecb.c)
+ [Signer et vérifier les données avec RSA](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/sign/rsa_sign.c)
+ [Dériver des clés à l'aide de HMAC KDF](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/derivation/hmac_kdf.c)
+ [Encapsuler et désencapsuler les clés avec AES en utilisant le remplissage PKCS \$15](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_wrapping.c)
+ [Encapsuler et désencapsuler les clés avec AES sans remplissage](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_no_padding_wrapping.c)
+ [Encapsuler et désencapsuler les clés avec AES à l'aide du remplissage avec des zéros](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_zero_padding_wrapping.c)
+ [Encapsuler et désencapsuler les clés avec AES-GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/wrapping/aes_gcm_wrapping.c)
+ [Encapsuler et désencapsuler les clés avec RSA](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/rsa_wrapping.c)
# Configurations avancées pour la bibliothèque PKCS \$111 pour AWS CloudHSM
Le fournisseur AWS CloudHSM PKCS \$111 inclut la configuration avancée suivante, qui ne fait pas partie des configurations générales utilisées par la plupart des clients. Ces configurations fournissent des fonctionnalités supplémentaires.
+ [Connexion à plusieurs emplacements avec PKCS \$111](pkcs11-library-configs-multi-slot.md)
+ [Configuration de nouvelle tentative pour PKCS \$111](pkcs11-library-configs-retry.md)
# Configuration de plusieurs emplacements avec la bibliothèque PKCS \$111 pour AWS CloudHSM
Un emplacement unique dans la bibliothèque PKCS \$111 du SDK client 5 représente une connexion unique à un cluster dans AWS CloudHSM. Avec le SDK client 5, vous pouvez configurer votre PKCS11 bibliothèque pour autoriser plusieurs emplacements à connecter les utilisateurs à plusieurs clusters CloudHSM à partir d'une seule application PKCS \$111.
Suivez les instructions de cette rubrique pour que votre application utilise la fonctionnalité d’emplacements multiples pour se connecter à plusieurs clusters.
**Topics**
+ [Conditions préalables à plusieurs emplacements pour la bibliothèque PKCS \$111 pour AWS CloudHSM](#pkcs11-multi-slot-prereqs)
+ [Configurez la bibliothèque PKCS \$111 pour la fonctionnalité multi-slot pour AWS CloudHSM](pkcs11-multi-slot-config-run.md)
+ [Ajoutez un cluster doté d'une fonctionnalité multi-slot pour AWS CloudHSM](pkcs11-multi-slot-add-cluster.md)
+ [Supprimer un cluster doté d'une fonctionnalité multi-slot pour AWS CloudHSM](pkcs11-multi-slot-remove-cluster.md)
## Conditions préalables à plusieurs emplacements pour la bibliothèque PKCS \$111 pour AWS CloudHSM
Avant de configurer plusieurs emplacements pour la bibliothèque PKCS \$111 pour AWS CloudHSM, remplissez les conditions préalables suivantes.
+ Au moins deux AWS CloudHSM clusters auxquels vous souhaitez vous connecter, ainsi que leurs certificats de cluster.
+ Une instance EC2 avec des groupes de sécurité correctement configurés pour se connecter à tous les clusters ci-dessus. Pour plus d'informations sur la configuration d'un cluster et de l'instance client, reportez-vous à la section [Mise en route avec AWS CloudHSM](getting-started.md).
+ Pour configurer la fonctionnalité d’emplacements multiples, vous devez avoir déjà téléchargé et installé la bibliothèque PKCS \$111. Si vous ne l'avez pas déjà fait, consultez les instructions figurant dans [Installation de la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 5](pkcs11-library-install.md).
# Configurez la bibliothèque PKCS \$111 pour la fonctionnalité multi-slot pour AWS CloudHSM
Pour configurer votre bibliothèque PKCS \$111 pour la fonctionnalité multi-slot pour AWS CloudHSM, procédez comme suit :
1. Identifiez les clusters auxquels vous souhaitez vous connecter à l'aide de la fonctionnalité d’emplacements multiples.
1. Ajoutez ces clusters à votre configuration PKCS \$111 en suivant les instructions de [Ajoutez un cluster doté d'une fonctionnalité multi-slot pour AWS CloudHSM](pkcs11-multi-slot-add-cluster.md)
1. La prochaine fois que votre application PKCS \$111 s'exécutera, elle disposera d'une fonctionnalité d’emplacements multiples.
# Ajoutez un cluster doté d'une fonctionnalité multi-slot pour AWS CloudHSM
Lorsque vous vous [connectez à plusieurs emplacements avec PKCS \$111](pkcs11-library-configs-multi-slot.md) for AWS CloudHSM, utilisez la **configure-pkcs11 add-cluster** commande pour ajouter un cluster à votre configuration.
## Syntaxe
```
configure-pkcs11 add-cluster [OPTIONS]
--cluster-id
[--region ]
[--endpoint ]
[--hsm-ca-cert ]
[--client-cert-hsm-tls-file ]
[--client-key-hsm-tls-file ]
[-h, --help]
```
## Exemples
### Ajoutez un cluster à l'aide du paramètre `cluster-id`
**Example**
Utilisez le paramètre **configure-pkcs11 add-cluster** ainsi que le paramètre `cluster-id` pour ajouter un cluster (avec l'ID de `cluster-1234567`) à votre configuration.
```
$ 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
```
**Astuce**
Si l'utilisation de **configure-pkcs11 add-cluster** avec le paramètre `cluster-id` n'entraîne pas l'ajout du cluster, reportez-vous à l'exemple suivant pour une version plus longue de cette commande qui nécessite également des paramètres `--region` et `--endpoint` pour identifier le cluster ajouté. Si, par exemple, la région du cluster est différente de celle configurée par défaut dans votre interface de ligne de commande AWS, vous devez utiliser le paramètre `--region` pour utiliser la bonne région. En outre, il est possible de spécifier le point de terminaison d' AWS CloudHSM API à utiliser pour l'appel, ce qui peut être nécessaire pour diverses configurations réseau, telles que l'utilisation de points de terminaison d'interface VPC qui n'utilisent pas le nom d'hôte DNS par défaut pour. AWS CloudHSM
### Ajouter un cluster à l'aide des paramètres `cluster-id`, `endpoint` et `region`
**Example**
Utilisez les paramètres **configure-pkcs11 add-cluster** ainsi que `cluster-id`, `endpoint` et `region` pour ajouter un cluster (avec l'ID de `cluster-1234567`) à votre configuration.
```
$ 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
```
Pour plus d'informations sur les paramètres `--cluster-id`, `--region` et `--endpoint`, consultez [AWS CloudHSM Paramètres de configuration du SDK client 5](configure-tool-params5.md).
## Parameters
**--identifiant de cluster ****
Effectue un appel `DescribeClusters` pour rechercher toutes les adresses IP de l’interface réseau Elastic (ENI) du HSM du cluster associées à l'ID du cluster. Le système ajoute les adresses IP ENI aux fichiers AWS CloudHSM de configuration.
Si vous utilisez le `--cluster-id` paramètre à partir d'une instance EC2 au sein d'un VPC qui n'a pas accès à l'Internet public, vous devez créer un point de terminaison VPC d'interface auquel vous connecter. AWS CloudHSM Pour plus d'informations sur les points de terminaison d'un VPC, veuillez consulter [AWS CloudHSM et points de terminaison VPC](cloudhsm-vpc-endpoint.md).
Obligatoire : oui
**--point de terminaison ****
Spécifiez le point de terminaison de l' AWS CloudHSM API utilisé pour effectuer l'`DescribeClusters`appel. Vous devez définir cette option en combinaison avec `--cluster-id`.
Obligatoire : non
**--hsm-ca-cert ****
Spécifie le chemin du fichier vers le certificat HSM CA.
Obligatoire : non
**--région ****
Spécifiez la région de votre cluster. Vous devez définir cette option en combinaison avec `--cluster-id`.
Si vous ne fournissez pas le paramètre `--region`, le système choisit la région en essayant de lire les variables d'environnement `AWS_DEFAULT_REGION` ou `AWS_REGION`. Si ces variables ne sont pas définies, le système vérifie la région associée à votre profil dans votre fichier AWS Config (généralement `~/.aws/config`), sauf si vous avez spécifié un autre fichier dans la variable d'environnement `AWS_CONFIG_FILE`. Si aucune des options ci-dessus n'est définie, le système utilise par défaut la région `us-east-1`.
Obligatoire : non
**-- client-cert-hsm-tls -fichier ****
Chemin d'accès au certificat client utilisé pour l'authentification mutuelle TLS Client-HSM.
N'utilisez cette option que si vous avez enregistré au moins une ancre de confiance sur HSM avec la CLI CloudHSM. Vous devez définir cette option en combinaison avec `--client-key-hsm-tls-file`.
Obligatoire : non
**-- client-key-hsm-tls -fichier ****
Chemin d'accès à la clé client utilisée pour l'authentification mutuelle TLS Client-HSM.
N'utilisez cette option que si vous avez enregistré au moins une ancre de confiance sur HSM avec la CLI CloudHSM. Vous devez définir cette option en combinaison avec `--client-cert-hsm-tls-file`.
Obligatoire : non
# Supprimer un cluster doté d'une fonctionnalité multi-slot pour AWS CloudHSM
Lorsque vous vous [connectez à plusieurs emplacements avec PKCS \$111](pkcs11-library-configs-multi-slot.md), utilisez la commande **configure-pkcs11 remove-cluster** pour supprimer un cluster des emplacements PKCS \$111 disponibles.
## Syntaxe
```
configure-pkcs11 remove-cluster [OPTIONS]
--cluster-id
[-h, --help]
```
## Exemples
### Supprimer un cluster à l'aide du paramètre `cluster-id`
**Example**
Utilisez le paramètre **configure-pkcs11 remove-cluster** ainsi que le paramètre `cluster-id` pour supprimer un cluster (avec l'ID de `cluster-1234567`) de votre configuration.
```
$ 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
```
Pour plus d’informations sur le paramètre `--cluster-id`, consultez [AWS CloudHSM Paramètres de configuration du SDK client 5](configure-tool-params5.md).
## Paramètre
**--identifiant de cluster ****
L'ID du cluster à supprimer de la configuration
Obligatoire : oui
# Commandes de nouvelle tentative pour la bibliothèque PKCS \$111 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-pkcs11 --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-pkcs11.exe" --default-retry-mode off
```
------
# Stockage de certificats avec la bibliothèque PKCS \$111
La bibliothèque PKCS \$111 d'AWS CloudHSM prend en charge le stockage des certificats de clé publique en tant qu' « objets publics » (tels que définis dans PKCS \$111 2.40) sur des clusters hsm2m.medium. Cette fonctionnalité permet aux sessions PKCS \$111 publiques et privées de créer, récupérer, modifier et supprimer des certificats de clé publique.
Pour utiliser le stockage de certificats avec la bibliothèque PKCS \$111, vous devez l'activer dans la configuration de votre client. Une fois activé, vous pouvez gérer les objets de certificat depuis vos applications PKCS \$111. Les opérations qui s'appliquent à la fois au certificat et aux objets clés, tels que [C\$1 FindObjects](http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/os/pkcs11-base-v2.40-os.html#_Toc323205461), renverront les résultats du stockage des clés et des certificats.
**Topics**
+ [Activer le stockage des certificats](pkcs11-certificate-storage-configuration.md)
+ [API de stockage de certificats](pkcs11-certificate-storage-api.md)
+ [Attributs du certificat](pkcs11-certificate-storage-attributes.md)
+ [Journaux d'audit du stockage des certificats](pkcs11-certificate-storage-audit-logs.md)
# Activation du stockage des certificats
Vous pouvez activer le stockage de certificats sur les clusters hsm2m.medium à l'aide de l'outil de configuration de bibliothèque PKCS \$111. Cette fonctionnalité est disponible dans les versions 5.13 et ultérieures du SDK. Pour obtenir la liste des opérations qui prennent en charge le type d'objet de certificat, consultez[Opérations de l'API de stockage de certificats](pkcs11-certificate-storage-api.md).
Pour activer le stockage des certificats, procédez comme suit pour votre système d'exploitation :
------
#### [ Linux ]
+
****Activer le stockage des certificats****
Exécutez la commande suivante :
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 --enable-certificate-storage
```
------
#### [ Windows ]
+
****Activer le stockage des certificats****
Ouvrez une invite de commande et exécutez la commande suivante :
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" --enable-certificate-storage
```
------
# Opérations de l'API de stockage de certificats
Les opérations PKCS \$111 suivantes prennent en charge le type d'objet de certificat (`CKO_CERTIFICATE`) :
## Opérations générales de certification
**`C_CreateObject`**
Crée un nouvel objet de certificat.
**`C_DestroyObject`**
Supprime un objet de certificat existant.
**`C_GetAttributeValue`**
Obtient la valeur d'un ou de plusieurs attributs d'un objet de certificat.
**`C_SetAttributeValue`**
Met à jour la valeur d'un ou de plusieurs attributs d'un objet de certificat.
## Opérations de recherche d'objets de certificat
**`C_FindObjectsInit`**
Lance une recherche d'objets de certificat.
**`C_FindObjects`**
Poursuit la recherche d'objets de certificat.
**`C_FindObjectsFinal`**
Met fin à la recherche d'objets de certificat.
# Attributs de stockage des certificats
Le tableau suivant répertorie les attributs d'objet de certificat pris en charge et leurs valeurs :
| Attribut | Valeur par défaut | Description |
| --- | --- | --- |
| `CKA_CLASS` | Obligatoire | Doit indiquer `CKO_CERTIFICATE`. |
| `CKA_TOKEN` | True | Doit indiquer `True`. |
| `CKA_MODIFIABLE` | True | Doit indiquer `True`. |
| `CKA_PRIVATE` | False | Doit indiquer `False`. |
| `CKA_LABEL` | Vide | Limite de 127 caractères. |
| `CKA_COPYABLE` | False | Doit indiquer `False`. |
| `CKA_DESTROYABLE` | True | Doit indiquer `True`. |
| `CKA_CERTIFICATE_TYPE` | Obligatoire | Doit indiquer `CKC_X_509`. |
| `CKA_TRUSTED` | False | Doit indiquer `False`. |
| `CKA_CERTIFICATE_CATEGORY` | `CK_CERTIFICATE_CATEGORY_UNSPECIFIED` | Doit indiquer `CK_CERTIFICATE_CATEGORY_UNSPECIFIED`. |
| `CKA_CHECK_VALUE` | Dérivé de `CKA_VALUE` | Réglé automatiquement en fonction de`CKA_VALUE`. |
| `CKA_START_DATE` | Vide | Date « pas avant » du certificat. |
| `CKA_END_DATE` | Vide | Date « non postérieure » du certificat. |
| `CKA_PUBLIC_KEY_INFO` | Vide | La taille maximale est de 16 kilo-octets. |
| `CKA_SUBJECT` | Obligatoire | L'objet du certificat. |
| `CKA_ID` | Vide | La taille maximale est de 128 octets. L'unicité n'est pas imposée. |
| `CKA_ISSUER` | Vide | L'émetteur du certificat. |
| `CKA_SERIAL_NUMBER` | Vide | Numéro de série du certificat. |
| `CKA_VALUE` | Obligatoire | La taille maximale est de 32 kilo-octets. |
# Journaux d'audit du stockage des certificats
AWS CloudHSM écrit des journaux d'audit pour les opérations de stockage de certificats qui modifient les données dans un flux de journal CloudWatch Amazon Events distinct au sein du groupe de journaux de votre cluster CloudWatch . Ce flux de journal porte le nom du cluster, et non d'un HSM spécifique au sein du cluster.
Pour plus d'informations sur l'accès aux connexions d'audit CloudWatch, consultez[Utilisation d'Amazon CloudWatch Logs et AWS CloudHSM d'Audit Logs](get-hsm-audit-logs-using-cloudwatch.md).
## Champs de saisie du journal
`object_handle`
Identifiant unique de l'objet de certificat.
`op_code`
L'opération effectuée ou tentée. Valeurs possibles :
+ `CreateObject`
+ `DestroyObject`
+ `SetAttributeValues`
`response`
`OK`si l'opération a réussi, ou l'un des types d'erreur suivants :
+ `DuplicateAttribute`
+ `InvalidAttributeValue`
+ `ObjectNotFound`
+ `MaxObjectsReached`
+ `InternalFailure`
`attributes`
Les attributs modifiés, le cas échéant.
`timestamp`
Heure à laquelle l'opération s'est produite, en millisecondes depuis l'ère Unix.
## Exemples de journaux d’audit
### CreateObject exemple
```
{
"object_handle": 463180677312929947,
"op_code": "CreateObject",
"response": "OK",
"attributes": null,
"timestamp": 1725482483671
}
```
### DestroyObject exemple
```
{
"object_handle": 463180677312929947,
"op_code": "DestroyObject",
"response": "OK",
"attributes": null,
"timestamp": 1725482484559
}
```
### SetAttributeValues exemple
```
{
"object_handle": 463180678453346687,
"op_code": "SetAttributeValues",
"response": "OK",
"attributes": [
"Label"
],
"timestamp": 1725482488004
}
```
### CreateObject Exemple infructueux
```
{
"object_handle": null,
"op_code": "CreateObject",
"response": "MaxObjectsReached",
"attributes": null,
"timestamp": 1726084937125
}
```
# Moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 5
Le moteur dynamique AWS CloudHSM OpenSSL vous permet de décharger des opérations cryptographiques vers votre cluster CloudHSM via l'API OpenSSL.
AWS CloudHSM fournit un moteur dynamique OpenSSL, que vous pouvez consulter dans ou. [AWS CloudHSM Déchargement SSL/TLS sous Linux à l'aide de Tomcat avec JSSE](third-offload-linux-jsse.md) [AWS CloudHSM Déchargement SSL/TLS sous Linux en utilisant NGINX ou Apache avec OpenSSL](third-offload-linux-openssl.md) Pour un exemple d'utilisation AWS CloudHSM avec OpenSSL, consultez [ce blog sur la sécurité AWS](https://aws.amazon.com/blogs/security/automate-the-deployment-of-an-nginx-web-service-using-amazon-ecs-with-tls-offload-in-cloudhsm/). Pour plus d'informations sur la prise en charge de la plate-forme pour SDKs, consultez[AWS CloudHSM Plateformes prises en charge par le SDK client 5](client-supported-platforms.md). Pour le dépannage, voir[Problèmes connus liés au moteur dynamique OpenSSL pour AWS CloudHSM](ki-openssl-sdk.md).
Utilisez les sections suivantes pour installer et configurer le moteur AWS CloudHSM dynamique pour OpenSSL à l'aide du SDK client 5.
Pour plus d'informations sur l'utilisation du SDK client 3, veuillez consulter [Utilisation de la version précédente du SDK pour travailler avec AWS CloudHSM](choose-client-sdk.md).
**Topics**
+ [Installation du moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 5](openssl5-install.md)
+ [Types de clés pris en charge pour OpenSSL Dynamic Engine AWS CloudHSM for Client SDK 5](openssl-key-types.md)
+ [Mécanismes pris en charge pour OpenSSL Dynamic Engine AWS CloudHSM for Client SDK 5](openssl-mechanisms.md)
+ [Configurations avancées pour OpenSSL pour AWS CloudHSM](openssl-library-configs.md)
# Installation du moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 5
Utilisez les sections suivantes pour installer le moteur dynamique OpenSSL AWS CloudHSM pour le SDK client 5.
**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).
**Pour installer et configurer le moteur dynamique OpenSSL**
1. Utilisez les commandes suivantes pour télécharger et installer le moteur OpenSSL.
------
#### [ Amazon Linux 2023 ]
Installez le moteur dynamique OpenSSL pour Amazon Linux 2023 sur une architecture x86\$164 :
```
$ 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
```
Installez le moteur dynamique OpenSSL pour Amazon Linux 2023 sur l'architecture : ARM64
```
$ 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 ]
Installez le moteur dynamique OpenSSL pour Amazon Linux 2 sur une architecture x86\$164 :
```
$ 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
```
Installez le moteur dynamique OpenSSL pour Amazon Linux 2 sur l'architecture : ARM64
```
$ 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) ]
Installez le moteur dynamique OpenSSL pour RHEL 9 sur une architecture x86\$164 :
```
$ 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
```
Installez le moteur dynamique OpenSSL pour RHEL 9 sur l'architecture : ARM64
```
$ 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) ]
Installez le moteur dynamique OpenSSL pour RHEL 8 sur une architecture x86\$164 :
```
$ 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
```
Installez le moteur dynamique OpenSSL pour RHEL 8 sur l'architecture : ARM64
```
$ 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 ]
Installez le moteur dynamique OpenSSL pour Ubuntu 24.04 LTS sur une architecture x86\$164 :
```
$ 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
```
Installez le moteur dynamique OpenSSL pour Ubuntu 24.04 LTS sur l'architecture : 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 ]
Installez le moteur dynamique OpenSSL pour Ubuntu 22.04 LTS sur une architecture x86\$164 :
```
$ 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
```
Installez le moteur dynamique OpenSSL pour Ubuntu 22.04 LTS sur l'architecture : 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
```
------
Vous avez installé la bibliothèque partagée pour le moteur dynamique à l'adresse `/opt/cloudhsm/lib/libcloudhsm_openssl_engine.so`.
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. Définissez une variable d'environnement avec les informations d'identification d'un utilisateur de chiffrement (CU). Pour plus d'informations sur la création CUs, consultez[Création d'un AWS CloudHSM utilisateur à l'aide de la CLI CloudHSM](cloudhsm_cli-user-create.md).
```
$ export CLOUDHSM_PIN=:
```
**Note**
Le SDK client 5 introduit la variable d'environnement `CLOUDHSM_PIN` permettant de stocker les informations d'identification du CU. Dans le SDK client 3, vous stockez les informations d'identification CU dans la variable d'environnement `n3fips_password`. Le SDK client 5 prend en charge les deux variables d'environnement, mais nous vous recommandons d’utiliser `CLOUDHSM_PIN`.
Lorsque vous définissez des variables d'`CLOUDHSM_PIN`environnement, vous devez éviter tout caractère spécial susceptible d'être interprété par votre shell.
1. Connectez votre installation de moteur dynamique OpenSSL au cluster. Pour plus d’informations, consultez [Connexion à un Cluster](cluster-connect.md).
1. Démarrez le SDK client 5. Pour de plus amples informations, veuillez consulter [Amorcez le SDK client](cluster-connect.md#connect-how-to).
## Vérifiez le moteur dynamique OpenSSL pour le SDK client 5
Utilisez la commande suivante pour vérifier votre installation de moteur dynamique OpenSSL.
```
$ openssl engine -t cloudhsm
```
Le résultat suivant vérifie votre configuration :
```
(cloudhsm) CloudHSM OpenSSL Engine
[ available ]
```
# Types de clés pris en charge pour OpenSSL Dynamic Engine AWS CloudHSM for Client SDK 5
Le moteur dynamique AWS CloudHSM OpenSSL prend en charge les types de clés suivants avec le SDK client 5.
****
| Type de clé | Description |
| --- | --- |
| EC | ECDSA sign/verify pour les types de clés P-256, P-384 et secp256k1. Pour générer des clés EC interopérables avec le moteur OpenSSL, consultez [Exporter une clé asymétrique avec la CLI CloudHSM](cloudhsm_cli-key-generate-file.md). |
| RSA | Génération de clés RSA pour les clés 2048, 3072 et 4096 bits. Signation/vérification RSA. La vérification est déchargée vers le logiciel OpenSSL. |
# Mécanismes pris en charge pour OpenSSL Dynamic Engine AWS CloudHSM for Client SDK 5
Le moteur dynamique AWS CloudHSM OpenSSL prend en charge les mécanismes suivants pour les fonctions de signature et de vérification avec le SDK client 5.
## Fonctions de signature et de vérification
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.
Types de signature RSA
+ SHA1withRSA
+ SHA224withRSA
+ SHA256withRSA
+ SHA384withRSA
+ SHA512withRSA
Types de signature ECDSA
+ SHA1withECDSA
+ SHA224withECDSA
+ SHA256withECDSA
+ SHA384withECDSA
+ SHA512withECDSA
# Configurations avancées pour OpenSSL pour AWS CloudHSM
Le fournisseur AWS CloudHSM OpenSSL inclut la configuration avancée suivante, qui ne fait pas partie des configurations générales utilisées par la plupart des clients. Ces configurations fournissent des fonctionnalités supplémentaires.
+ [Commandes de nouvelle tentative pour OpenSSL](openssl-library-configs-retry.md)
# Commandes de nouvelle tentative pour OpenSSL 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é
Vous pouvez utiliser la commande suivante pour configurer des commandes de nouvelle tentative en mode **off** :
```
$ sudo /opt/cloudhsm/bin/configure-dyn --default-retry-mode off
```
# Fournisseur AWS CloudHSM OpenSSL pour le SDK client 5
Le fournisseur AWS CloudHSM OpenSSL vous permet de décharger les opérations cryptographiques TLS vers votre cluster CloudHSM via l'API du fournisseur OpenSSL. L'interface Provider est l'approche recommandée pour les nouveaux déploiements utilisant OpenSSL 3.2 et versions ultérieures.
Utilisez les sections suivantes pour installer et configurer le fournisseur AWS CloudHSM OpenSSL à l'aide du SDK client 5.
**Avertissement**
L'intégration avec la CLI OpenSSL n'est actuellement pas prise en charge AWS CloudHSM par le fournisseur OpenSSL. Consultez [AWS CloudHSM Déchargement SSL/TLS sous Linux à l'aide de NGINX ou du fournisseur OpenSSL HAProxy](third-offload-linux-openssl-provider.md) les intégrations prises en charge.
## Plateformes prises en charge
Le fournisseur OpenSSL nécessite OpenSSL 3.2 ou version ultérieure, disponible sur \$1, Ubuntu 24.04\$1 et Amazon EL9 Linux 2023\$1.
Vérifiez la compatibilité : `openssl version`
**Topics**
+ [Plateformes prises en charge](#openssl-provider-supported-platforms)
+ [Installation du fournisseur AWS CloudHSM OpenSSL pour le SDK client 5](openssl-provider-install.md)
+ [Types de clés pris en charge pour le fournisseur AWS CloudHSM OpenSSL pour le client SDK 5](openssl-provider-key-types.md)
+ [Mécanismes pris en charge par le fournisseur OpenSSL](openssl-provider-mechanisms.md)
+ [Configuration avancée du fournisseur OpenSSL](openssl-provider-advanced-config.md)
# Installation du fournisseur AWS CloudHSM OpenSSL pour le SDK client 5
Utilisez les sections suivantes pour installer le fournisseur OpenSSL pour le SDK client AWS CloudHSM 5.
**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](working-client-sync.md#client-sync-sdk8) et [outil de configuration du SDK client 5](configure-sdk-5.md).
## Exigences
Le fournisseur OpenSSL **nécessite** des types de clusters hsm2m.medium et une version minimale du SDK client CloudHSM version 5.17.0 ou ultérieure.
## Installation du fournisseur OpenSSL
**Pour installer le fournisseur OpenSSL**
1. Utilisez les commandes suivantes pour télécharger et installer le fournisseur OpenSSL.
------
#### [ Amazon Linux 2023 ]
Installez le fournisseur OpenSSL pour Amazon Linux 2023 sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur OpenSSL pour Amazon Linux 2023 sur l'architecture : ARM64
```
$ 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) ]
Installez le fournisseur OpenSSL pour RHEL 9 sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur OpenSSL pour RHEL 9 sur l'architecture : ARM64
```
$ 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) ]
Installez le fournisseur OpenSSL pour RHEL 10 sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur OpenSSL pour RHEL 10 sur l'architecture : ARM64
```
$ 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 ]
Installez le fournisseur OpenSSL pour Ubuntu 24.04 sur une architecture x86\$164 :
```
$ 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
```
Installez le fournisseur OpenSSL pour Ubuntu 24.04 sur l'architecture : 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
```
------
Vous avez installé la bibliothèque partagée pour le fournisseur OpenSSL à l'adresse. `/opt/cloudhsm/lib/licloudhsm_openssl_provider.so`
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. Définissez la variable d'`CLOUDHSM_PIN`environnement avec vos informations d'identification d'utilisateur cryptographique (CU) :
```
$ export CLOUDHSM_PIN=:
```
1. Connectez votre installation d'OpenSSL Provider au cluster. Pour plus d’informations, consultez [Connexion à un Cluster](cluster-connect.md).
## Vérifier l'installation
Vérifiez que le fournisseur OpenSSL est correctement installé :
```
$ CLOUDHSM_PIN=: openssl list -providers -provider cloudhsm
```
Vous devriez voir une sortie similaire à :
```
Providers:
cloudhsm
name: AWS CloudHSM OpenSSL Provider
version: 5.17.0
status: active
default
name: OpenSSL Default Provider
version: 3.2.2
status: active
```
# Types de clés pris en charge pour le fournisseur AWS CloudHSM OpenSSL pour le client SDK 5
Le fournisseur AWS CloudHSM OpenSSL prend en charge les types de clés suivants avec le SDK client 5.
****
| Type de clé | Description |
| --- | --- |
| RSA | RSA sign/verify et opérations de chiffrement asymétrique. La vérification est déchargée vers le logiciel OpenSSL. Pour générer des clés RSA interopérables avec le fournisseur OpenSSL, consultez. [Exporter une clé asymétrique avec la CLI CloudHSM](cloudhsm_cli-key-generate-file.md) |
| EC | ECDSA sign/verify pour les courbes P-256, P-384 et P-521. La vérification est déchargée vers le logiciel OpenSSL. Pour générer des clés EC interopérables avec le fournisseur OpenSSL, consultez. [Exporter une clé asymétrique avec la CLI CloudHSM](cloudhsm_cli-key-generate-file.md) |
# Mécanismes pris en charge par le fournisseur OpenSSL
Le SDK AWS CloudHSM OpenSSL Provider prend en charge un ensemble complet de mécanismes cryptographiques pour diverses opérations, notamment les signatures numériques, le chiffrement asymétrique, le chiffrement symétrique, l'échange de clés, etc.
## Types de signature RSA
Le fournisseur OpenSSL prend en charge les signatures numériques RSA avec plusieurs algorithmes de hachage et schémas de remplissage :
SHA1withRSA
Signatures RSA avec algorithme de hachage SHA-1
+ Rembourrage PKCS \$11 v1.5
+ Rembourrage PSS (Probabilistic Signature Scheme)
SHA224withRSA
Signatures RSA avec algorithme de hachage SHA-224
+ Rembourrage PKCS \$11 v1.5
+ Rembourrage en PSS
SHA256withRSA
Signatures RSA avec algorithme de hachage SHA-256
+ Rembourrage PKCS \$11 v1.5
+ Rembourrage en PSS
SHA384withRSA
Signatures RSA avec algorithme de hachage SHA-384
+ Rembourrage PKCS \$11 v1.5
+ Rembourrage en PSS
SHA512withRSA
Signatures RSA avec algorithme de hachage SHA-512
+ Rembourrage PKCS \$11 v1.5
+ Rembourrage en PSS
## Types de signature ECDSA
Le fournisseur OpenSSL prend en charge les signatures numériques ECDSA avec plusieurs algorithmes de hachage :
SHA1withECDSA
Signatures ECDSA avec algorithme de hachage SHA-1
SHA224withECDSA
Signatures ECDSA avec algorithme de hachage SHA-224
SHA256withECDSA
Signatures ECDSA avec algorithme de hachage SHA-256
SHA384withECDSA
Signatures ECDSA avec algorithme de hachage SHA-384
SHA512withECDSA
Signatures ECDSA avec algorithme de hachage SHA-512
# Configuration avancée du fournisseur OpenSSL
Le SDK AWS CloudHSM OpenSSL Provider fournit des options de configuration avancées pour personnaliser son comportement en fonction de différents cas d'utilisation et environnements. Utilisez l'outil de configuration pour définir ces options.
+ [Réessayer la configuration pour le fournisseur OpenSSL](openssl-provider-configs-retry.md)
# Commandes de nouvelle tentative pour le fournisseur OpenSSL pour AWS CloudHSM
AWS CloudHSM Le SDK client 5.8.0 et versions ultérieures disposent d'une stratégie de réessai 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-openssl-provider --default-retry-mode off
```
------
# Fournisseur de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5
Le Key Storage Provider (KSP) est une API cryptographique spécifique au système d'exploitation Microsoft Windows. Le fournisseur de stockage de clés (KSP) permet aux développeurs d'utiliser des techniques cryptographiques pour sécuriser les applications Windows.
Pour plus d'informations sur l’amorçage, veuillez consulter [Connexion au cluster](cluster-connect.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 de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5](ksp-library-install.md)
+ [Authentifiez-vous auprès du fournisseur de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5](ksp-library-authentication.md)
+ [Types de clés pris en charge par le fournisseur de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5](ksp-library--key-types.md)
+ [Opérations d'API prises en charge Fournisseur de stockage de clés (KSP) pour AWS CloudHSM le SDK client 5](ksp-library-apis.md)
+ [Configurations avancées pour KSP pour AWS CloudHSM](ksp-library-configs.md)
# Installation du fournisseur de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5
Utilisez les sections suivantes pour installer le fournisseur de stockage de clés (KSP) pour AWS CloudHSM le SDK client 5.
**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).
**Pour installer et configurer le fournisseur de stockage de clés (KSP)**
1. Installez le fournisseur de stockage de clés (KSP) 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/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. Utilisez l'outil de configuration pour spécifier l'emplacement du certificat émetteur. Pour obtenir des instructions, veuillez consulter [Spécifier l'emplacement du certificat émetteur](cluster-connect.md#specify-cert-location).
1. Pour vous connecter à votre cluster, consultez [Amorcez le SDK client](cluster-connect.md#connect-how-to).
1. Vous pouvez trouver les fichiers du fournisseur de stockage de clés (KSP) aux emplacements suivants :
+ Binaires Windows :
```
C:\Program Files\Amazon\CloudHSM
```
Scripts de configuration et fichiers journaux Windows :
```
C:\ProgramData\Amazon\CloudHSM
```
# Authentifiez-vous auprès du fournisseur de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5
Avant d'utiliser le fournisseur de stockage de clés (KSP) pour AWS CloudHSM le SDK client 5, vous devez définir les informations de connexion du HSM sur votre système. Vous avez deux options :
+ Gestionnaire d'informations d'identification Windows (recommandé pour une meilleure sécurité)
+ Variables d'environnement du système (configuration simplifiée)
## Gestionnaire d'informations d'identification Windows
Vous pouvez configurer les informations d'identification à l'aide de l'`set_cloudhsm_credentials`utilitaire ou de l'interface Windows Credentials Manager.
+ **Utilisation de l'utilitaire `set_cloudhsm_credentials`** :
L'`set_cloudhsm_credentials`utilitaire est inclus dans le programme d'installation de Windows. Vous pouvez utiliser cet utilitaire pour transmettre facilement les informations d'identification de connexion HSM au Gestionnaire d'informations d'identification Windows. Si vous souhaitez compiler cet utilitaire à partir des sources, vous pouvez utiliser le code Python inclus dans le programme d'installation.
1. Accédez à `C:\Program Files\Amazon\CloudHSM\tools\`.
1. Exécutez la commande suivante :
```
set_cloudhsm_credentials.exe --username --password
```
+ **Utilisation de l'interface du Gestionnaire d'informations d'identification** :
1. Ouvrez le gestionnaire d'informations d'identification :
+ Entrez `credential manager` dans le champ de recherche de la barre des tâches
+ Sélectionnez **Credential Manager**
1. Sélectionnez **Windows Credentials (Informations d'identification)** pour gérer les informations d'identification Windows.
1. Sélectionnez **Ajouter un identifiant générique**
1. Entrez les détails suivants :
+ **Adresse Internet ou réseau** :`CLOUDHSM_PIN`.
+ **Nom d'utilisateur** :**.
+ **Mot de passe** :**.
1. Sélectionnez **OK**
## Variables d'environnement du système
Vous pouvez définir des variables d'environnement système pour identifier votre HSM et votre [utilisateur cryptographique](understanding-users.md#crypto-user-chsm-cli) (CU).
**Avertissement**
La définition des informations d'identification par le biais de variables d'environnement système enregistre votre mot de passe en texte clair sur votre système. Pour une meilleure sécurité, utilisez plutôt Windows Credential Manager.
Vous pouvez définir des variables d'environnement en utilisant :
+ La valeur [https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx).
+ Panneau de configuration **des propriétés du système** Windows (onglet **Avancé**).
+ définir des variables d'environnement système permanentes Méthodes [programmatiques](https://msdn.microsoft.com/en-us/library/system.environment.setenvironmentvariable(v=vs.110).aspx).
Pour définir la variable d'environnement du système :
**`CLOUDHSM_PIN=:`**
Identifie un [utilisateur de chiffrement](understanding-users.md#crypto-user-chsm-cli) (CU) dans le HSM et fournit toutes les informations de connexion requises. Votre application s'authentifie et s'exécute en tant que ce CU. L'application possède les autorisations de ce CU et peut afficher et gérer uniquement les clés que le CU possède et partage. Pour créer une nouvelle CU, utilisez la commande [user create](cloudhsm_cli-user-create.md) dans la CLI CloudHSM. Pour rechercher un fichier existant CUs, utilisez la commande [user list](cloudhsm_cli-user-list.md) dans la CLI CloudHSM.
Par exemple :
```
setx /m CLOUDHSM_PIN test_user:password123
```
**Note**
Lorsque vous définissez les variables d'environnement CLOUDHSM\$1PIN, vous devez éviter tout caractère spécial susceptible d'être interprété par votre shell.
# Types de clés pris en charge par le fournisseur de stockage de clés (KSP) pour le SDK AWS CloudHSM client 5
Le fournisseur de stockage de AWS CloudHSM clés (KSP) prend en charge les types de clés suivants avec le SDK client 5.
****
| Type de clé | Description |
| --- | --- |
| EC | Générez des clés avec les courbes secp256r1 (P-256), secp384r1 (P-384) et secp521r1 (P-521). |
| RSA | Générez des clés RSA de 2048, 3072 et 4096 bits. |
# Opérations d'API prises en charge Fournisseur de stockage de clés (KSP) pour AWS CloudHSM le SDK client 5
Les paramètres du KSP sont définis par Microsoft KSP. Consultez la [documentation Microsoft](https://learn.microsoft.com/en-us/windows/win32/api/ncrypt/) pour plus d'informations.
Le fournisseur de stockage de clés (KSP) prend en charge les opérations d'API KSP suivantes pour le SDK AWS CloudHSM client 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 fonction avec le fournisseur de stockage de clés (KSP)
La `NCryptOpenStorageProvider` fonction charge et initialise le fournisseur de stockage de clés (KSP).
## Parameters
`phProvider`[dehors]
Un pointeur vers une `NCRYPT_PROV_HANDLE` variable qui stocke le descripteur du fournisseur.
`pszProviderName`[en]
Pointeur vers une chaîne Unicode terminée par un caractère nul identifiant le fournisseur de stockage de clés. Le fournisseur de stockage de clés (KSP) AWS CloudHSM prend en charge les valeurs suivantes :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-open-provider.html)
Les valeurs sont des chaînes de caractères larges littérales, comme indiqué par L avant le littéral.
`dwFlags`[en]
Indicateurs qui modifient le comportement de la fonction. Aucun drapeau n'est défini pour cette fonction.
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOT\$1FAIL | L'opération n'a pas pu être terminée. |
# NCryptOpenKey avec le fournisseur de stockage de clés (KSP)
La `NCryptOpenKey` fonction ouvre une clé qui existe dans le fournisseur de stockage de clés (KSP).
## Parameters
`hProvider`[en]
Le handle KSP qui contient la clé. [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)Utilisez-le pour obtenir le manche.
`phKey`[dehors]
Un pointeur vers une `NCRYPT_KEY_HANDLE` variable qui stocke le descripteur de touche.
`pszKeyName`[en]
Un pointeur vers une chaîne Unicode terminée par un caractère nul et contenant le nom de la clé.
`dwLegacyKeySpec`[en, non utilisé]
AWS CloudHSM Le fournisseur de stockage de clés (KSP) n'utilise pas ce paramètre.
`dwFlags`[en]
Indicateurs qui modifient le comportement de la fonction. Aucun drapeau n'est défini pour cette fonction.
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOT\$1FAIL | L'opération n'a pas pu être terminée. |
| NTE\$1INVALID\$1HANDLE | Le handle in n'`hProvider`est pas valide. |
| NTE\$1BAD\$1KEYSET | Le nom de clé fourni n'a pas renvoyé de résultat unique. |
# NCryptCreatePersistedKey avec le fournisseur de stockage de clés (KSP)
La `NCryptCreatePersistedKey` fonction crée une nouvelle clé et la stocke dans le fournisseur de stockage de clés (KSP). Vous pouvez utiliser la [`NCryptSetProperty`](ksp-library-apis-set-property.md)fonction pour définir ses propriétés après sa création. Vous devez appeler [`NCryptFinalizeKey`](ksp-library-apis-finalize-key.md)avant de pouvoir utiliser la clé.
## Parameters
`hProvider`[en]
Identifiant du fournisseur de stockage de clés dans lequel vous allez créer la clé. [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)Utilisez-le pour obtenir cette poignée.
`phKey`[dehors]
Adresse d'une `NCRYPT_KEY_HANDLE` variable qui stocke le descripteur de la clé.
`pszAlgId`[en]
Pointeur vers une chaîne Unicode terminée par un caractère nul qui indique l'identifiant de l'algorithme cryptographique utilisé pour créer la clé.
AWS CloudHSM Le fournisseur de stockage de clés (KSP) prend en charge les algorithmes suivants :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-create-persisted-key.html)
`pszKeyName`[en, facultatif]
Pointeur vers une chaîne Unicode terminée par un caractère nul et contenant le nom de la clé. Si ce paramètre est NULL, cette fonction créera une clé éphémère qui n'est pas conservée.
`dwLegacyKeySpec`[en, non utilisé]
AWS CloudHSM Le fournisseur de stockage de clés (KSP) n'utilise pas ce paramètre.
`dwFlags`[en]
Drapeaux permettant de modifier le comportement de la fonction. Utilisez zéro ou plusieurs des valeurs suivantes :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-create-persisted-key.html)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | La fonction s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOTE\$1FAIL | L'opération n'a pas pu être terminée. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
| NOTE NON PRISE EN CHARGE | Le `pszAlgId` paramètre contient une valeur non prise en charge. |
| NOTE\$1EXISTS | Une clé portant le nom spécifié existe déjà et l'opération n'a pas été utilisée` NCRYPT_OVERWRITE_KEY_FLAG`. |
# NCryptGetProperty avec le fournisseur de stockage de clés (KSP)
La `NCryptGetProperty` fonction récupère les valeurs des propriétés d'un objet de stockage clé.
## Parameters
`hObject`[en]
Le descripteur de l'objet dont vous souhaitez récupérer la propriété. Vous pouvez utiliser :
+ Un identifiant de fournisseur (`NCRYPT_PROV_HANDLE`)
+ Une poignée à clé (`NCRYPT_KEY_HANDLE`)
`pszProperty `[en]
Un pointeur vers une chaîne Unicode terminée par un caractère nul contenant le nom de la propriété à récupérer.
Lors de son utilisation`NCRYPT_PROV_HANDLE`, le fournisseur de stockage de AWS CloudHSM clés (KSP) prend en charge les identifiants KSP suivants :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
Lors de son utilisation`NCRYPT_KEY_HANDLE`, le fournisseur de stockage de AWS CloudHSM clés (KSP) prend en charge les identifiants KSP suivants :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
Les valeurs sont des chaînes de caractères larges littérales, comme indiqué par L avant le littéral.
`pbOutput`[dehors]
Adresse d'une mémoire tampon pour stocker la valeur de la propriété. Spécifiez la taille de la mémoire tampon à l'aide de`cbOutput`.
Pour déterminer la taille de tampon requise, définissez ce paramètre sur NULL. La fonction enregistre la taille requise (en octets) à l'emplacement indiqué par`pcbResult`.
`cbOutput`[en]
Taille de la `pbOutput` mémoire tampon en octets.
`pcbResult`[dehors]
Pointeur vers une variable DWORD qui stocke le nombre d'octets copiés dans la `pbOutput` mémoire tampon.
Si la valeur `pbOutput` est NULL, cela stocke la taille requise (en octets).
`dwFlags`[en]
Drapeaux permettant de modifier le comportement de la fonction. Vous pouvez utiliser zéro ou :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
Lorsque PSZProperty l'est`NCRYPT_SECURITY_DESCR_PROPERTY`, utilisez l'un ou une combinaison des éléments suivants :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOTE\$1FAIL | L'opération n'a pas pu être terminée. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
| NOTE NON PRISE EN CHARGE | Le `pszAlgId` paramètre contient une valeur qui n'est pas prise en charge. |
| NOTE\$1INVALID\$1HANDLE | Le handle in n'`hObject`est pas valide. |
| NTE\$1BUFFER\$1TOO\$1SMALL | Le `cbOutput` paramètre est trop petit pour les valeurs renvoyées. |
# NCryptSetProperty avec le fournisseur de stockage de clés (KSP)
La `NCryptSetProperty` fonction définit les valeurs des propriétés d'un objet de stockage clé.
## Parameters
`hObject`[en]
Le descripteur de l'objet dont vous souhaitez définir la propriété. Vous pouvez utiliser :
+ Un identifiant de fournisseur (`NCRYPT_PROV_HANDLE`)
+ Une poignée à clé (`NCRYPT_KEY_HANDLE`)
`pszProperty `[en]
Un pointeur vers une chaîne Unicode terminée par un caractère nul contenant le nom de la propriété à récupérer.
Lors de son utilisation`NCRYPT_PROV_HANDLE`, le fournisseur de stockage de AWS CloudHSM clés (KSP) prend en charge les identifiants KSP suivants :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-set-property.html)
Lors de son utilisation`NCRYPT_KEY_HANDLE`, le fournisseur de stockage de AWS CloudHSM clés (KSP) prend en charge les identifiants KSP suivants :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-set-property.html)
Les valeurs sont des chaînes de caractères larges littérales, comme indiqué par L avant le littéral.
`pbInput`[en]
Adresse d'un tampon contenant la nouvelle valeur de propriété. `cbInput`contient la taille de la mémoire tampon.
`cbInput`[en]
Taille de la `pbInput` mémoire tampon en octets.
`dwFlags`[en]
Indicateurs qui modifient le comportement de la fonction. Aucun drapeau n'est défini pour cette fonction.
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOTE\$1FAIL | L'opération n'a pas pu être terminée. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
| NOTE NON PRISE EN CHARGE | Le `pszProperty` paramètre contient une valeur qui n'est pas prise en charge. |
| NOTE\$1INVALID\$1HANDLE | Le handle in n'`hObject`est pas valide. |
| NOTE\$1BAD\$1DATA | Les données pointées par `pbInput` et ne `cbInput` sont pas valides. |
# NCryptFinalizeKey avec le fournisseur de stockage de clés (KSP)
La `NCryptFinalizeKey` fonction complète une touche KSP. Vous devez appeler cette fonction avant de pouvoir utiliser la touche.
## Parameters
`hKey`[en]
Le manche de la clé pour terminer. Obtenez ce descripteur en appelant la [NCryptCreatePersistedKey](ksp-library-apis-create-persisted-key.md)fonction.
`dwFlags`[en]
Drapeaux permettant de modifier le comportement de la fonction. Vous pouvez utiliser zéro ou les valeurs suivantes :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-finalize-key.html)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| NOTE\$1FAIL | L'opération n'a pas pu être terminée. |
| NOTE\$1INVALID\$1HANDLE | Le handle in n'`hKey`est pas valide. |
| NOTE NON PRISE EN CHARGE | Le `dwFlags` paramètre contient une valeur qui n'est pas prise en charge. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
# NCryptDeleteKey avec le fournisseur de stockage de clés (KSP)
La `NCryptDeleteKey` fonction supprime une clé KSP du fournisseur de stockage de clés (KSP).
## Parameters
`hKey`[en]
Poignée de la clé à supprimer.
`dwFlags`[en]
Drapeaux permettant de modifier le comportement de la fonction. Vous pouvez utiliser zéro ou plusieurs des valeurs suivantes :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-delete-key.html)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | La fonction s'est déroulée correctement. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
| NOT\$1FAIL | L'opération n'a pas pu être terminée. |
| NTE\$1INVALID\$1HANDLE | Le handle in n'`hKey`est pas valide. |
| ERREUR\$1INTERNE | Une erreur interne s'est produite lors de la suppression de la clé. |
# NCryptFreeObject avec le fournisseur de stockage de clés (KSP)
La `NCryptFreeObject` fonction libère le fournisseur ou le descripteur de clé du fournisseur de stockage de clés (KSP).
## Parameters
`hObject`[en]
Poignée de l'objet à libérer. Vous pouvez utiliser :
+ Un identifiant de fournisseur (`NCRYPT_PROV_HANDLE`)
+ Une poignée à clé (`NCRYPT_KEY_HANDLE`)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| NTE\$1INVALID\$1HANDLE | Le handle in n'`hObject`est pas valide. |
# NCryptFreeBuffer avec le fournisseur de stockage de clés (KSP)
La `NCryptFreeBuffer` fonction libère un bloc de mémoire alloué par le fournisseur de stockage de clés (KSP).
## Parameters
`pvInput`[en]
Adresse de la mémoire à libérer.
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| NOT\$1FAIL | L'opération n'a pas pu être terminée. |
# NCryptIsAlgSupported avec le fournisseur de stockage de clés (KSP)
NCryptIsAlgSupported fonction détermine si le fournisseur de stockage de clés (KSP) prend en charge un algorithme cryptographique spécifique.
## Parameters
`hProvider`[en]
Identifiant du fournisseur de stockage de clés. [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)Utilisez-le pour obtenir le manche.
`pszAlgId`[en]
Pointeur vers une chaîne Unicode terminée par un caractère nul qui contient l'identifiant de l'algorithme cryptographique utilisé pour créer la clé. Le fournisseur de stockage de clés (KSP) AWS CloudHSM prend en charge les algorithmes suivants :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-is-alg-supported.html)
`dwFlags`[en]
Indicateurs qui modifient le comportement des fonctions. Il peut s'agir de zéro ou de la valeur suivante :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-is-alg-supported.html)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
| NOTE NON PRISE EN CHARGE | Le `pszAlgId` paramètre contient une valeur non prise en charge. |
| NOTE\$1INVALID\$1HANDLE | Le handle in n'`hProvider`est pas valide. |
# NCryptEnumAlgorithms avec le fournisseur de stockage de clés (KSP)
La `NCryptEnumAlgorithms` fonction récupère les noms des algorithmes pris en charge par le fournisseur de stockage de clés (KSP).
## Parameters
`hProvider`[en]
Identifiant du fournisseur de stockage de clés pour lequel énumérer les algorithmes. Utilisez la [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)fonction pour obtenir ce descripteur.
`dwAlgOperations`[en]
Ensemble de valeurs qui spécifient les classes d'algorithmes à énumérer. Vous pouvez utiliser zéro pour énumérer tous les algorithmes ou combiner une ou plusieurs de ces valeurs :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-enum-algorithms.html)
`pdwAlgCount`[dehors]
Adresse d'un DWORD qui stocke le nombre d'éléments du `ppAlgList` tableau.
`ppAlgList`[dehors]
Adresse d'un pointeur de `NCryptAlgorithmName` structure qui stocke un tableau de noms d'algorithmes enregistrés. Le `pdwAlgCount` paramètre indique le nombre d'éléments de ce tableau.
`dwFlags`[en]
Drapeaux permettant de modifier le comportement de la fonction. Utilisez zéro ou la valeur suivante :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-enum-algorithms.html)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOTE\$1FAIL | L'opération n'a pas pu être terminée. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
| NOTE NON PRISE EN CHARGE | Le `dwAlgOperations` paramètre contient une valeur non prise en charge. |
# NCryptEnumKeys avec le fournisseur de stockage de clés (KSP)
NCryptEnumKeys fonction répertorie les clés stockées dans le fournisseur de stockage de clés (KSP).
## Parameters
`hProvider`[en]
Identifiant du fournisseur de stockage des clés. [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)Utilisez-le pour obtenir cette poignée.
`pszScope`[en, non utilisé]
Définissez ce paramètre sur NULL.
`ppKeyName`[dehors]
Adresse de pointeur vers une `NCryptKeyName` structure qui stocke le nom de la clé. Pour libérer cette mémoire après utilisation, appelez`NCryptFreeBuffer`.
`ppEnumState`[entrée, sortie]
Une adresse de pointeur VOID qui suit la progression de l'énumération. Le fournisseur de stockage de clés utilise ces informations en interne pour gérer la séquence d'énumération. Pour recommencer une nouvelle énumération depuis le début, définissez ce pointeur sur NULL.
Pour libérer cette mémoire une fois l'énumération terminée, passez ce pointeur au`NCryptFreeBuffer`.
`dwFlags`[en]
Drapeaux permettant de modifier le comportement de la fonction. Cette fonction n'a aucun drapeau.
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOT\$1FAIL | L'opération n'a pas pu être terminée. |
| NTE\$1INVALID\$1HANDLE | Le handle in n'`hProvider`est pas valide. |
| NE NOTEZ AUCUN AUTRE ARTICLE | L'énumération a répertorié toutes les clés disponibles. |
# NCryptExportKey avec le fournisseur de stockage de clés (KSP)
La `NCryptExportKey` fonction exporte une clé KSP vers une mémoireBLOB. Cette fonction prend uniquement en charge l'exportation de clés publiques.
## Parameters
`hKey`[en]
Poignée de la clé à exporter.
`hExportKey`[en, non utilisé]
AWS CloudHSM Le fournisseur de stockage de clés (KSP) n'utilise pas ce paramètre.
`pszBlobType`[en]
Chaîne Unicode terminée par un caractère nul qui indique le BLOB type à exporter. AWS CloudHSM Le fournisseur de stockage de clés (KSP) prend en charge les valeurs suivantes :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-export-key.html)
`pParameterList`[en, non utilisé]
AWS CloudHSM Le fournisseur de stockage de clés (KSP) n'utilise pas ce paramètre.
`pbOutput`[sortie, facultatif]
Adresse tampon pour stocker la clé BLOB. Spécifiez la taille de la mémoire tampon à l'aide de`cbOutput`. Si elle est définie sur NULL, la fonction stocke la taille requise (en octets) dans le DWORD pointé par`pcbResult`.
`cbOutput`[en]
Taille de la `pbOutput` mémoire tampon en octets.
`pcbResult`[dehors]
Adresse variable DWORD qui stocke le nombre d'octets copiés dans la `pbOutput` mémoire tampon. Si la valeur `pbOutput` est NULL, la fonction stocke la taille de tampon requise en octets.
`dwFlags`[en]
Drapeaux qui modifient le fonctionnement de la fonction. Vous pouvez utiliser zéro ou ce qui suit :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-export-key.html)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOTE\$1FAIL | L'opération n'a pas pu être terminée. |
| NOTE\$1INVALID\$1HANDLE | Le handle in n'`hProvider`est pas valide. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
| NOTE\$1BAD\$1KEY\$1STATE | L'état de la clé n'est pas valide. |
| NOTE NON PRISE EN CHARGE | Le `dwFlags` paramètre `pszBlobType` or contient une valeur non prise en charge. |
| ERREUR INTERNE D'ÉTAT | Une erreur interne s'est produite lors de l'opération. |
# NCryptSignHash avec le fournisseur de stockage de clés (KSP)
La `NCryptSignHash` fonction crée la signature d'une valeur de hachage.
## Parameters
`hKey`[en]
Le manche de la clé à utiliser pour signer le hachage.
`pPaddingInfo`[en, facultatif]
Pointeur vers une structure contenant des informations de remplissage. Le type de structure dépend de la `dwFlags` valeur. Utilisez ce paramètre uniquement avec des clés asymétriques ; défini sur NULL pour les autres types de clés.
`pbHashValue`[en]
Un pointeur vers un tampon contenant la valeur de hachage à signer. Spécifiez la taille de la mémoire tampon à l'aide de`cbHashValue`.
`cbHashValue`[en]
Taille, en octets, de la `pbHashValue` mémoire tampon à signer.
`pbSignature`[dehors]
Adresse d'une mémoire tampon pour stocker la signature. Spécifiez la taille de la mémoire tampon à l'aide de`cbSignature`.
Pour déterminer la taille de tampon requise, définissez ce paramètre sur NULL. La fonction stocke la taille requise (en octets) à l'emplacement indiqué par`pcbResult`.
`cbSignature`[en]
Taille de la `pbSignature` mémoire tampon en octets. La fonction ignore ce paramètre s'il `pbSignature` est NULL.
`pcbResult`[dehors]
Pointeur vers une variable DWORD qui stocke le nombre d'octets copiés dans la `pbSignature` mémoire tampon.
Si la valeur `pbSignature` est NULL, cela stocke la taille de mémoire tampon requise, en octets.
`dwFlags`[en]
Drapeaux permettant de modifier le comportement de la fonction. Les drapeaux autorisés dépendent du type de clé. Utilisez l'une des valeurs suivantes :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-sign-hash.html)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOTE\$1FAIL | L'opération n'a pas pu être terminée. |
| NOTE\$1INVALID\$1HANDLE | Le handle in n'`hKey`est pas valide. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
| NTE\$1BUFFER\$1TOO\$1SMALL | Le `pcbOutput` paramètre est trop petit pour les valeurs renvoyées. |
| NOTE\$1BAD\$1KEY\$1STATE | L'état de la clé n'est pas valide. |
| ERREUR\$1INTERNE | Une erreur interne s'est produite lors de la signature du hachage. |
# NCryptVerifySignature avec le fournisseur de stockage de clés (KSP)
La `NCryptVerifySignature` fonction confirme si une signature correspond à un hachage spécifié.
## Parameters
`hKey`[en]
Le descripteur de la clé à utiliser pour déchiffrer la signature. Vous devez utiliser la partie clé publique de la paire de clés utilisée pour signer les données avec le [`NCryptSignHash`](ksp-library-apis-sign-hash.md).
`pPaddingInfo`[en, facultatif]
Un pointeur vers une structure contenant des informations de remplissage. Le type de structure dépend de la `dwFlags` valeur. Utilisez ce paramètre uniquement avec des clés asymétriques ; défini sur NULL pour les autres types de clés.
`pbHashValue`[en]
Un pointeur vers un tampon contenant la valeur de hachage à signer. Spécifiez la taille de la mémoire tampon à l'aide de`cbHashValue`.
`cbHashValue`[en]
Taille de la `pbHashValue` mémoire tampon en octets.
`pbSignature`[dehors]
Adresse d'un tampon contenant le hachage signé des données. [`NCryptSignHash`](ksp-library-apis-sign-hash.md)À utiliser pour créer cette signature. Spécifiez la taille de la mémoire tampon à l'aide de`cbSignature`.
`cbSignature`[en]
Taille de la `pbSignature` mémoire tampon en octets. [`NCryptSignHash`](ksp-library-apis-sign-hash.md)À utiliser pour créer la signature.
`dwFlags`[en]
Drapeaux permettant de modifier le comportement de la fonction. Les drapeaux autorisés dépendent du type de clé. Utilisez l'une des valeurs suivantes :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/ksp-library-apis-verify-signature.html)
## Valeur renvoyée
La fonction renvoie un code d'état indiquant le succès ou l'échec.
Les codes de retour courants incluent :
****
| Code de retour | Description |
| --- | --- |
| ERREUR\$1SUCCÈS | L'opération s'est terminée avec succès. |
| PARAMÈTRE\$1INVALIDE | Un ou plusieurs paramètres ne sont pas valides. |
| NOTE\$1FAIL | L'opération n'a pas pu être terminée. |
| NOTE\$1INVALID\$1HANDLE | Le handle in n'`hKey`est pas valide. |
| BATE\$1BAD\$1FLAGS | Le `dwFlags` paramètre contient une valeur non valide. |
| NOTE\$1BAD\$1SIGNATURE | La signature n'a pas été vérifiée. |
| NOTE\$1BAD\$1KEY\$1STATE | L'état de la clé n'est pas valide. |
| ERREUR\$1INTERNE | Une erreur interne s'est produite lors de la vérification de la signature. |
# Configurations avancées pour KSP pour AWS CloudHSM
Le AWS CloudHSM Key Storage Provider (KSP) inclut la configuration avancée suivante, qui ne fait pas partie des configurations générales utilisées par la plupart des clients. Ces configurations fournissent des fonctionnalités supplémentaires.
+ [SDK3 mode de compatibilité pour KSP](ksp-library-configs-sdk3-compatibility-mode.md)
# SDK3 mode de compatibilité pour le fournisseur de stockage de clés (KSP) pour AWS CloudHSM
Le fournisseur de stockage de clés (KSP) met en œuvre différentes approches pour l'interaction entre les clés HSM :
+ SDK client 5 : fournit une communication directe avec les clés stockées dans le HSM, éliminant ainsi le besoin de fichiers de référence locaux
+ SDK client 3 : gère les fichiers locaux sur le serveur Windows qui font office de références aux clés stockées dans le HSM, en utilisant ces fichiers pour faciliter les opérations clés
Pour les clients qui migrent du SDK client 3 vers le SDK client 5, l'activation de l'option du mode de SDK3 compatibilité prend en charge les opérations utilisant les fichiers de référence clés existants tout en préservant l'architecture de stockage de clés HSM sous-jacente.
## Activer le mode SDK3 de compatibilité
------
#### [ Windows ]
**Pour activer le mode de SDK3 compatibilité pour le fournisseur de stockage de clés (KSP) pour le SDK client 5 sous Windows**
+ Vous pouvez utiliser la commande suivante pour activer le mode de SDK3 compatibilité :
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-ksp.exe" --enable-sdk3-compatibility-mode
```
------
## Désactiver le mode SDK3 de compatibilité
------
#### [ Windows ]
**Pour désactiver le mode de SDK3 compatibilité pour le fournisseur de stockage de clés (KSP) pour le SDK client 5 sous Windows**
+ Vous pouvez utiliser la commande suivante pour désactiver le mode de SDK3 compatibilité :
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-ksp.exe" --disable-sdk3-compatibility-mode
```
------
# 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
```
------
# Utilisation de la version précédente du SDK pour travailler avec AWS CloudHSM
****
Les versions 5.8.0 et antérieures du SDK ont atteint la fin de leur support. Après le 31 mars 2025, la documentation pour les versions 3.4.4 et antérieures du SDK ne sera plus disponible.
AWS CloudHSM inclut deux versions principales du SDK client :
+ SDK client 5 : il s'agit de notre dernier SDK client par défaut. Pour plus d'informations sur ses avantages, consultez [Avantages du SDK AWS CloudHSM client 5](client-sdk-5-benefits.md).
+ SDK client 3 : il s'agit de notre ancien SDK client. Il inclut un ensemble complet de composants pour la compatibilité des applications basées sur les plateformes et les langages ainsi que des outils de gestion.
Pour obtenir des instructions sur la migration du SDK client 3 vers le SDK client 5, consultez. [Migration du SDK AWS CloudHSM client 3 vers le SDK client 5](client-sdk-migration.md)
Cette rubrique décrit le SDK client 3. Pour connaître la version du SDK client que vous utilisez, consultez[Vérifiez la version de votre SDK AWS CloudHSM clientPour vérifier la version du démon client](check-client_version.md).
Pour procéder au téléchargement, reportez-vous à [Téléchargements pour AWS CloudHSM le SDK client](client-history.md).
**Topics**
+ [Mettre à niveau AWS CloudHSM le SDK client 3 sous Linux](client-upgrade.md)
+ [AWS CloudHSM Plateformes prises en charge par le SDK client 3](sdk3-support.md)
+ [bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 3](pkcs11-v3-library.md)
+ [Moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 3](openssl3-install.md)
+ [fournisseur JCE pour le SDK AWS CloudHSM client 3](java-library_3.md)
+ [API de cryptographie : fournisseurs de nouvelle génération (CNG) et de stockage de clés (KSP) pour AWS CloudHSM](ksp-v3-library.md)
# Mettre à niveau AWS CloudHSM le SDK client 3 sous Linux
****
Les versions 5.8.0 et antérieures du SDK ont atteint la fin de leur support. Après le 31 mars 2025, la documentation pour les versions 3.4.4 et antérieures du SDK ne sera plus disponible.
Avec AWS CloudHSM le SDK client 3.1 et versions ultérieures, la version du démon client et de tous les composants que vous installez doivent correspondre pour effectuer la mise à niveau. Pour tous les systèmes basés sur Linux, vous devez utiliser une seule commande pour mettre à niveau par lots le démon client avec la même version de la bibliothèque PKCS \$111, du fournisseur Java Cryptographic Extension (JCE) ou de OpenSSL Dynamic Engine. Cette exigence ne s'applique pas aux systèmes Windows, car les fichiers binaires des fournisseurs KSP et GNC sont déjà inclus dans le package du démon client.
## Pour vérifier la version du démon client
+ Sur un système Linux basé sur Red Hat (y compris Amazon Linux et CentOS), utilisez la commande suivante :
```
rpm -qa | grep ^cloudhsm
```
+ Sur un système Linux basé sur Debian, exécutez la commande suivante :
```
apt list --installed | grep ^cloudhsm
```
+ Sur un système Windows, exécutez la commande suivante :
```
wmic product get name,version
```
**Topics**
+ [Conditions préalables](#client-upgrade-prerequisites)
+ [Étape 1 : arrêter le démon client](#client-stop)
+ [Étape 2 : mettre à niveau le SDK client](#upgrade-commands)
+ [Étape 3 : démarrer le démon client](#client-start)
## Conditions préalables
Téléchargez la dernière version du démon AWS CloudHSM client et choisissez vos composants.
**Note**
Vous n'avez pas besoin d'installer tous les composants. Pour chaque composant installé, vous devez mettre à niveau ce composant pour qu'il corresponde à la version du démon du client.
### Dernier démon client Linux
------
#### [ Amazon Linux ]
```
wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-latest.el6.x86_64.rpm
```
------
#### [ Amazon Linux 2 ]
```
wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-latest.el7.x86_64.rpm
```
------
#### [ CentOS 7 ]
```
sudo yum install wget
```
```
wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-latest.el7.x86_64.rpm
```
------
#### [ CentOS 8 ]
```
sudo yum install wget
```
```
wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-latest.el8.x86_64.rpm
```
------
#### [ RHEL 7 ]
```
sudo yum install wget
```
```
wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-latest.el7.x86_64.rpm
```
------
#### [ RHEL 8 ]
```
sudo yum install wget
```
```
wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-latest.el8.x86_64.rpm
```
------
#### [ Ubuntu 16.04 LTS ]
```
wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Xenial/cloudhsm-client_latest_amd64.deb
```
------
#### [ Ubuntu 18.04 LTS ]
```
wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Bionic/cloudhsm-client_latest_u18.04_amd64.deb
```
------
### Dernière bibliothèque PKCS \$111
------
#### [ Amazon Linux ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-pkcs11-latest.el6.x86_64.rpm
```
------
#### [ Amazon Linux 2 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-pkcs11-latest.el7.x86_64.rpm
```
------
#### [ CentOS 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-pkcs11-latest.el7.x86_64.rpm
```
------
#### [ CentOS 8 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-pkcs11-latest.el8.x86_64.rpm
```
------
#### [ RHEL 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-pkcs11-latest.el7.x86_64.rpm
```
------
#### [ RHEL 8 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-pkcs11-latest.el8.x86_64.rpm
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Xenial/cloudhsm-client-pkcs11_latest_amd64.deb
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Bionic/cloudhsm-client-pkcs11_latest_u18.04_amd64.deb
```
------
### Dernier moteur OpenSSL Dynamic Engine
------
#### [ Amazon Linux ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-dyn-latest.el6.x86_64.rpm
```
------
#### [ Amazon Linux 2 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-dyn-latest.el7.x86_64.rpm
```
------
#### [ CentOS 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-dyn-latest.el7.x86_64.rpm
```
------
#### [ RHEL 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-dyn-latest.el7.x86_64.rpm
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Xenial/cloudhsm-client-dyn_latest_amd64.deb
```
------
### Dernier fournisseur JCE
------
#### [ Amazon Linux ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-jce-latest.el6.x86_64.rpm
```
------
#### [ Amazon Linux 2 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-jce-latest.el7.x86_64.rpm
```
------
#### [ CentOS 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-jce-latest.el7.x86_64.rpm
```
------
#### [ CentOS 8 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-jce-latest.el8.x86_64.rpm
```
------
#### [ RHEL 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-jce-latest.el7.x86_64.rpm
```
------
#### [ RHEL 8 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-jce-latest.el8.x86_64.rpm
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Xenial/cloudhsm-client-jce_latest_amd64.deb
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Bionic/cloudhsm-client-jce_latest_u18.04_amd64.deb
```
------
## Étape 1 : arrêter le démon client
Utilisez la commande suivante pour arrêter le démon client.
------
#### [ Amazon Linux ]
```
$ sudo stop cloudhsm-client
```
------
#### [ Amazon Linux 2 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ CentOS 7 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ CentOS 8 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ RHEL 7 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ RHEL 8 ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo service cloudhsm-client stop
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo service cloudhsm-client stop
```
------
## Étape 2 : mettre à niveau le SDK client
La commande suivante indique la syntaxe requise pour mettre à niveau le démon client et les composants. Avant d'exécuter la commande, supprimez tous les composants que vous n'avez pas l'intention de mettre à niveau.
------
#### [ Amazon Linux ]
```
$ sudo yum install ./cloudhsm-client-latest.el6.x86_64.rpm \
<./cloudhsm-client-pkcs11-latest.el6.x86_64.rpm> \
<./cloudhsm-client-dyn-latest.el6.x86_64.rpm> \
<./cloudhsm-client-jce-latest.el6.x86_64.rpm>
```
------
#### [ Amazon Linux 2 ]
```
$ sudo yum install ./cloudhsm-client-latest.el7.x86_64.rpm \
<./cloudhsm-client-pkcs11-latest.el7.x86_64.rpm> \
<./cloudhsm-client-dyn-latest.el7.x86_64.rpm> \
<./cloudhsm-client-jce-latest.el7.x86_64.rpm>
```
------
#### [ CentOS 7 ]
```
$ sudo yum install ./cloudhsm-client-latest.el7.x86_64.rpm \
<./cloudhsm-client-pkcs11-latest.el7.x86_64.rpm> \
<./cloudhsm-client-dyn-latest.el7.x86_64.rpm> \
<./cloudhsm-client-jce-latest.el7.x86_64.rpm>
```
------
#### [ CentOS 8 ]
```
$ sudo yum install ./cloudhsm-client-latest.el8.x86_64.rpm \
<./cloudhsm-client-pkcs11-latest.el8.x86_64.rpm> \
<./cloudhsm-client-jce-latest.el8.x86_64.rpm>
```
------
#### [ RHEL 7 ]
```
$ sudo yum install ./cloudhsm-client-latest.el7.x86_64.rpm \
<./cloudhsm-client-pkcs11-latest.el7.x86_64.rpm> \
<./cloudhsm-client-dyn-latest.el7.x86_64.rpm> \
<./cloudhsm-client-jce-latest.el7.x86_64.rpm>
```
------
#### [ RHEL 8 ]
```
$ sudo yum install ./cloudhsm-client-latest.el8.x86_64.rpm \
<./cloudhsm-client-pkcs11-latest.el8.x86_64.rpm> \
<./cloudhsm-client-jce-latest.el8.x86_64.rpm>
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo apt install ./cloudhsm-client_latest_amd64.deb \
\
\
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo apt install ./cloudhsm-client_latest_u18.04_amd64.deb \
\
```
------
## Étape 3 : démarrer le démon client
Utilisez la commande suivante pour démarrer le démon client.
------
#### [ Amazon Linux ]
```
$ sudo start cloudhsm-client
```
------
#### [ Amazon Linux 2 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ CentOS 7 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ CentOS 8 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ RHEL 7 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ RHEL 8 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 20.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
# AWS CloudHSM Plateformes prises en charge par le SDK client 3
****
Les versions 5.8.0 et antérieures du SDK ont atteint la fin de leur support. Après le 31 mars 2025, la documentation pour les versions 3.4.4 et antérieures du SDK ne sera plus disponible.
AWS CloudHSM Le SDK client 3 nécessite un démon client et propose des outils de ligne de commande, notamment l'utilitaire de gestion CloudHSM (CMU), l'utilitaire de gestion des clés (KMU) et l'outil de configuration.
Le support de base est différent pour chaque version du SDK AWS CloudHSM client. En général, le support de plateforme pour les composants d'un SDK correspond au support de base, mais pas toujours. Pour déterminer le support de plate-forme pour un composant donné, assurez-vous d'abord que la plate-forme que vous souhaitez apparaît dans la section de base du SDK, puis vérifiez les exclusions ou toute autre information pertinente dans la section du composant.
Le support de la plateforme évolue au fil du temps. Les versions antérieures du SDK du client CloudHSM peuvent ne pas prendre en charge tous les systèmes d'exploitation répertoriés ici. Utilisez les notes de mise à jour pour déterminer le système d'exploitation compatible avec les versions précédentes du SDK du client CloudHSM. Pour de plus amples informations, veuillez consulter [Téléchargements pour AWS CloudHSM le SDK client](client-history.md).
AWS CloudHSM ne prend en charge que les systèmes d'exploitation 64 bits.
**Topics**
+ [Support Linux pour AWS CloudHSM le SDK client 3](sdk3-linux.md)
+ [Support Windows pour AWS CloudHSM le SDK client 3](sdk3-windows.md)
+ [Compatibilité HSM pour le SDK AWS CloudHSM client 3](sdk3-hsm-types.md)
# Support Linux pour AWS CloudHSM le SDK client 3
AWS CloudHSM Le SDK client 3 prend en charge les systèmes d'exploitation et plateformes Linux suivants.
+ Amazon Linux
+ Amazon Linux 2
+ CentOS 6.10\$1 2
+ CentOS 7.3\$1
+ CentOS 8 1,4
+ Red Hat Enterprise Linux (RHEL) 6.10\$1 2
+ Red Hat Enterprise Linux (RHEL) 7.3\$1
+ Red Hat Enterprise Linux (RHEL) 8 1
+ Ubuntu 16.04 LTS 3
+ Ubuntu 18.04 LTS 1
[1] Aucune prise en charge pour le moteur dynamique OpenSSL. Pour de plus amples informations, veuillez consulter [OpenSSL Dynamic Engine](sdk3-compare.md#openssl-collapse).
[2] Aucune prise en charge pour le SDK client 3.3.0 et versions ultérieures.
[3] Le SDK 3.4 est la dernière version prise en charge sur Ubuntu 16.04.
[4] Le SDK 3.4 est la dernière version prise en charge sur CentOS 8.3\$1.
# Support Windows pour AWS CloudHSM le SDK client 3
AWS CloudHSM Le SDK client 3 prend en charge les versions suivantes de Windows Server.
+ Microsoft Windows Server 2012
+ Microsoft Windows Server 2012 R2
+ Microsoft Windows Server 2016
+ Microsoft Windows Server 2019
# Compatibilité HSM pour le SDK AWS CloudHSM client 3
Le tableau suivant décrit la compatibilité AWS CloudHSM du SDK client 3 pour HSMs.
| hsm1.medium | hsm2m.medium |
| --- | --- |
| Compatible avec la version client SDK 3.1.0 et versions ultérieures. | Non pris en charge. |
# bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 3
PKCS \$111 est une norme permettant d'effectuer des opérations cryptographiques sur des modules de sécurité matériels (HSM) dans. AWS CloudHSM
Pour plus d'informations sur l’amorçage, veuillez consulter [Connexion au cluster](cluster-connect.md).
**Topics**
+ [Installation de la bibliothèque PKCS \$111](install-pkcs11-v3.md)
+ [Authentifiez-vous auprès de la bibliothèque PKCS \$111](pkcs11-v3-pin.md)
+ [Types de clé](pkcs11-v3-key-types.md)
+ [Mécanismes](pkcs11-v3-mechanisms.md)
+ [opérations d’API](pkcs11-v3-apis.md)
+ [Attributs de clé](pkcs11-v3-attributes.md)
+ [Exemples de code](pkcs11-v3-samples.md)
# Installation de la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 3
Cette rubrique fournit des instructions pour installer la bibliothèque PKCS \$111 pour la série de versions 3 du SDK AWS CloudHSM client. Pour plus d'informations sur le SDK client ou la bibliothèque PKCS \$111, consultez la section [Utilisation du SDK client](use-hsm.md) et la [bibliothèque PKCS \$111](pkcs11-library.md).
## Prérequis pour le SDK client 3
La bibliothèque PKCS \$111 nécessite le AWS CloudHSM client.
Si vous n'avez pas installé ni configuré le AWS CloudHSM client, faites-le maintenant en suivant les étapes décrites dans[Installer le client (Linux)](cmu-install-and-configure-client-linux.md). Une fois que vous avez installé et configuré le client, utilisez la commande suivante pour le démarrer.
------
#### [ Amazon Linux ]
```
$ sudo start cloudhsm-client
```
------
#### [ Amazon Linux 2 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ CentOS 7 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ CentOS 8 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ RHEL 7 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ RHEL 8 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 20.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
## Installation de la bibliothèque PKCS \$111 pour le SDK client 3
La commande suivante télécharge et installe la bibliothèque PKCS \$111.
------
#### [ Amazon Linux ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-pkcs11-latest.el6.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-pkcs11-latest.el6.x86_64.rpm
```
------
#### [ Amazon Linux 2 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-pkcs11-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-pkcs11-latest.el7.x86_64.rpm
```
------
#### [ CentOS 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-pkcs11-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-pkcs11-latest.el7.x86_64.rpm
```
------
#### [ CentOS 8 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-pkcs11-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-pkcs11-latest.el8.x86_64.rpm
```
------
#### [ RHEL 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-pkcs11-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-pkcs11-latest.el7.x86_64.rpm
```
------
#### [ RHEL 8 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-pkcs11-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-pkcs11-latest.el8.x86_64.rpm
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Xenial/cloudhsm-client-pkcs11_latest_amd64.deb
```
```
$ sudo apt install ./cloudhsm-client-pkcs11_latest_amd64.deb
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Bionic/cloudhsm-client-pkcs11_latest_u18.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-client-pkcs11_latest_u18.04_amd64.deb
```
------
+ Si aucun autre composant du SDK client 3 n'est installé sur l'instance EC2 sur laquelle vous avez installé la bibliothèque PKCS \$111, vous devez démarrer le SDK client 3. Vous ne devez le faire qu'une seule fois sur chaque instance avec un composant du SDK client 3.
+ Vous trouverez les fichiers de bibliothèque PKCS \$111 dans les emplacements suivants :
Binaires, scripts de configuration, certificats et fichiers journaux Linux :
```
/opt/cloudhsm/lib
```
# Authentifiez-vous auprès de la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 3
Lorsque vous utilisez la bibliothèque PKCS \$111, votre application s'exécute en tant qu'[utilisateur cryptographique (CU)](manage-hsm-users.md) spécifique HSMs dans AWS CloudHSM votre fichier d'entrée. Votre application peut afficher et gérer uniquement les clés que le CU possède et partage. Vous pouvez utiliser une CU existante dans votre CU HSMs ou en créer une nouvelle. Pour plus d'informations sur la gestion CUs, consultez les sections [Gestion des utilisateurs HSM à l'aide de la CLI CloudHSM et Gestion des utilisateurs HSM](manage-hsm-users-chsm-cli.md) [à l'aide de l'utilitaire de gestion CloudHSM](manage-hsm-users-cmu.md) (CMU).
Pour spécifier le CU pour PKCS \$111, utilisez le paramètre de code PIN PKCS \$111 [fonction C\$1Login](http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/os/pkcs11-base-v2.40-os.html#_Toc385057915). En AWS CloudHSM effet, le paramètre pin a le format suivant :
```
:
```
Par exemple, la commande suivante définit le code PIN de bibliothèque PKCS \$111 sur le CU avec le nom d'utilisateur `CryptoUser` et le mot de passe `CUPassword123!`.
```
CryptoUser:CUPassword123!
```
# Types de clés pris en charge pour la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 3
La bibliothèque PKCS \$111 prend en charge les types de clés suivants avec AWS CloudHSM le SDK client 3.
****
| Type de clé | Description |
| --- | --- |
| RSA | Générez des clés RSA de 2 048 bits à 4 096 bits, par incréments de 256 bits. |
| EC | Générez des clés avec les courbes secp224r1 (P-224), secp256r1 (P-256), secp256k1 (Blockchain), secp384r1 (P-384) et secp521r1 (P-521). |
| AES | Générez des clés AES de 128, 192 et 256 bits. |
| DES3 (Triple DES) | Générez des clés 192 bits. DES3 Voir la note [1](#pkcs11-v3-key-note) ci-dessous pour un changement à venir. |
| GENERIC\$1SECRET | Générez des secrets génériques de 1 à 64 octets. |
+ [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.
# Mécanismes pris en charge pour AWS CloudHSM le SDK client 3
La bibliothèque PKCS \$111 prend en charge les algorithmes suivants pour le SDK AWS CloudHSM client 3 :
+ **Chiffrement et déchiffrement** — AES-CBC, AES-CTR, AES-ECB, AES-GCM, -CBC, -ECB, RSA-OAEP et RSA-PKCS DES3 DES3
+ **Signature et vérification** : RSA, HMAC et ECDSA ; avec et sans hachage
+ **Hash/digest** — SHA1,, SHA224 SHA256, et SHA384 SHA512
+ **Encapsulage de clés** – AES Key Wrap,[4](#pkcs11-v3-mech4) AES-GCM, RSA-AES et RSA-OAEP
+ **Dérivation de clés** — ECDH, [5](#pkcs11-v3-mech5) SP800-108 CTR KDF
## Le tableau des mécanismes et des fonctions de la bibliothèque PKCS \$111
La bibliothèque PKCS \$111 est conforme à la version 2.40 de la spécification PKCS \$111. Pour appeler une fonction de chiffrement utilisant PKCS \$111, appelez une fonction à l'aide d'un mécanisme donné. Le tableau suivant résume les combinaisons de fonctions et de mécanismes prises en charge par AWS CloudHSM.
**Interprétation du tableau de mécanismes/fonctions PKCS \$111 pris en charge**
La marque ✔ indique que le mécanisme de la fonction est pris en AWS CloudHSM charge. Nous ne prenons pas en charge toutes les fonctions possibles répertoriés dans la spécification PKCS \$111. La marque ✖ indique qu' AWS CloudHSM elle ne prend pas encore en charge le mécanisme pour la fonction donnée, même si la norme PKCS \$111 l'autorise. Les cellules vides indiquent que la norme PKCS \$111 ne prend pas en charge le mécanisme pour la fonction donnée.
**Mécanismes et fonctions de bibliothèque PKCS \$1 11 pris en charge**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-mechanisms.html)
**Annotations du mécanisme**
+ [1] Opérations à une seule partie uniquement.
+ [2] Le mécanisme est fonctionnellement identique au mécanisme `CKM_RSA_PKCS_KEY_PAIR_GEN`, mais offre de meilleures garanties pour la génération de `p` et `q`.
+ [3.1] AWS CloudHSM aborde le hachage différemment en fonction du SDK client. Pour le SDK client 3, l'endroit où nous effectuons le hachage dépend de la taille des données et du fait que vous utilisez des opérations en une ou plusieurs parties.
**Opérations en une seule partie dans le SDK client 3**
Le tableau 3.1 répertorie la taille maximale de l'ensemble de données pour chaque mécanisme du SDK client 3. Le hachage complet est calculé dans le HSM. Aucune prise en charge pour les tailles de données supérieures à 16 Ko.
**Tableau 3.1, Taille maximale de l'ensemble de données pour les opérations en une seule partie**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-mechanisms.html)
**SDK client 3 pour les opérations en plusieurs parties**
Prise en charge pour les tailles de données supérieures à 16 Ko, mais la taille des données détermine l'endroit où le hachage a lieu. Les tampons de données de moins de 16 Ko sont hachés dans le HSM. Les tampons compris entre 16 Ko et la taille de données maximale de votre système sont hachés localement dans le logiciel. *N'oubliez pas* : les fonctions de hachage ne nécessitent pas de secrets cryptographiques, vous pouvez donc les calculer en toute sécurité en dehors du HSM.
+ [3.2] AWS CloudHSM aborde le hachage différemment en fonction du SDK client. Pour le SDK client 3, l'endroit où nous effectuons le hachage dépend de la taille des données et du fait que vous utilisez des opérations en une ou plusieurs parties.
**SDK client 3 pour les opérations en une seule partie**
Le tableau 3.2 répertorie la taille maximale de l'ensemble de données pour chaque mécanisme du SDK client 3. Aucune prise en charge pour les tailles de données supérieures à 16 Ko.
**Tableau 3.2, Taille maximale de l'ensemble de données pour les opérations en une seule partie**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-mechanisms.html)
**SDK client 3 pour les opérations en plusieurs parties**
Prise en charge pour les tailles de données supérieures à 16 Ko, mais la taille des données détermine l'endroit où le hachage a lieu. Les tampons de données de moins de 16 Ko sont hachés dans le HSM. Les tampons compris entre 16 Ko et la taille de données maximale de votre système sont hachés localement dans le logiciel. *N'oubliez pas* : les fonctions de hachage ne nécessitent pas de secrets cryptographiques, vous pouvez donc les calculer en toute sécurité en dehors du HSM.
+ [3.3] Lors de l’utilisation de données avec l’un des mécanismes suivants, si la mémoire tampon des données dépasse la taille maximale des données, l’opération génère une erreur. Pour ces mécanismes, tout le traitement des données doit avoir lieu à l'intérieur du HSM. Le tableau suivant répertorie la taille maximale des données définie pour chaque mécanisme :
**Tableau 3.3, Taille maximale de l'ensemble de données**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-mechanisms.html)
+ [4] Lorsque vous procédez au chiffrement AES GCM, le HSM n'accepte pas de données du vecteur d'initialisation (VI) de l'application. Vous devez utiliser un vecteur d’initialisation qu’il génère. Le vecteur d'initialisation 12 octets fourni par le HSM est écrit dans la référence en mémoire vers lequel pointe l'élément pIV des paramètres `CK_GCM_PARAMS` de la structure que vous fournissez. Pour éviter toute confusion de l'utilisateur, le kit SDK PKCS\$111 version 1.1.1 et ultérieure s’assure que cet élément pIV pointe vers une mémoire tampon mise à zéro lorsque le chiffrement AES-GCM est initialisé.
+ [5] **SDK client 3 uniquement**. Ce mécanisme est mis en œuvre pour prendre en charge des cas de transfert de charge SSL/TLS et est exécuté uniquement partiellement dans le HSM. Avant d'utiliser ce mécanisme, consultez « Problème : La dérivation de clés ECDH est exécutée uniquement partiellement dans le HSM » dans [Problèmes connus relatifs à la bibliothèque PKCS \$111 pour AWS CloudHSMProblèmes connus pour la bibliothèque PKCS\$111](ki-pkcs11-sdk.md). `CKM_ECDH1_DERIVE` ne prend pas en charge la courbe secp521r1 (P-521).
+ [6] Les `CK_MECHANISM_TYPE` et `CK_RSA_PKCS_MGF_TYPE` suivants sont pris en charge en tant que `CK_RSA_PKCS_OAEP_PARAMS` pour `CKM_RSA_PKCS_OAEP` :
+ `CKM_SHA_1` utilisant `CKG_MGF1_SHA1`
+ `CKM_SHA224` utilisant `CKG_MGF1_SHA224`
+ `CKM_SHA256` utilisant `CKG_MGF1_SHA256`
+ `CKM_SHA384` utilisant `CKM_MGF1_SHA384`
+ `CKM_SHA512` utilisant `CKM_MGF1_SHA512`
+ [7.1] Mécanisme défini par le fournisseur. Afin d'utiliser les mécanismes définis par le fournisseur CloudHSM, les applications PKCS \$111 doivent inclure `/opt/cloudhsm/include/pkcs11/cloudhsm_pkcs11_vendor_defs.h` lors de la compilation.
`CKM_CLOUDHSM_AES_GCM` : Ce mécanisme propriétaire est une alternative plus sûre par programme à la norme `CKM_AES_GCM`. Il ajoute le IV généré par le HSM au chiffrement au lieu de l'écrire dans la structure `CK_GCM_PARAMS` fournie lors de l'initialisation du chiffrement. Vous pouvez utiliser ce mécanisme avec les fonctions `C_Encrypt`, `C_WrapKey`, `C_Decrypt` et `C_UnwrapKey`. Lors de l'utilisation de ce mécanisme, la variable PiV dans la structure `CK_GCM_PARAMS` doit être définie sur `NULL`. Lors de l'utilisation de ce mécanisme avec `C_Decrypt` et `C_UnwrapKey`, le IV doit être ajouté au texte chiffré qui est en cours de désencapsulage.
`CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD` : Encapsulage des clés AES avec remplissage PKCS \$15
`CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD` : Encapsulage des clés AES avec remplissage à l'aide de zéros
Pour plus d'informations sur l'encapsulage de clé AES, voir [Encapsulage de clé AES](manage-aes-key-wrapping.md).
+ [8] 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.
# Opérations d'API prises en charge pour AWS CloudHSM le SDK client 3
La bibliothèque PKCS \$111 prend en charge les opérations d'API PKCS \$111 suivantes pour le SDK AWS CloudHSM client 3.
+ `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_SignRecover` (prise en charge du SDK client 3 uniquement)
+ `C_SignRecoverInit` (prise en charge du SDK client 3 uniquement)
+ `C_SignUpdate`
+ `C_UnWrapKey`
+ `C_Verify`
+ `C_VerifyFinal`
+ `C_VerifyInit`
+ `C_VerifyRecover` (prise en charge du SDK client 3 uniquement)
+ `C_VerifyRecoverInit` (prise en charge du SDK client 3 uniquement)
+ `C_VerifyUpdate`
+ `C_WrapKey`
# Attributs clés de la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 3
Un objet de clé peut être une clé publique, privée ou secrète. Les actions autorisées sur un objet de clé sont spécifiées via des attributs. Les attributs sont définis lorsque l'objet de clé est créé. Lorsque vous utilisez la bibliothèque PKCS \$111 pour AWS CloudHSM, nous attribuons des valeurs par défaut conformément à la norme PKCS \$111.
AWS CloudHSM ne prend pas en charge tous les attributs répertoriés dans la spécification PKCS \$111. Nous nous conformons à la spécification pour tous les attributs que nous prenons en charge. Ces attributs sont indiqués dans les tableaux respectifs.
Les fonctions cryptographiques telles que `C_CreateObject`, `C_GenerateKey`, `C_GenerateKeyPair`, `C_UnwrapKey` et `C_DeriveKey` qui créent, modifient ou copient des objets utilisent un modèle d’attribut en tant que paramètre. Pour plus d'informations sur la transmission d'un modèle d’attributs lors de la création d’un objet, consultez l’échantillon [Generate keys through PKCS \$111 library](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate).
Les rubriques suivantes fournissent des informations supplémentaires sur les attributs AWS CloudHSM clés du SDK client 3.
**Topics**
+ [Tableau des attributs](pkcs11-v3-attributes-interpreting.md)
+ [Modification d’attributs](pkcs11-v3-modify-attr.md)
+ [Interprétation des codes d'erreur de la bibliothèque PKCS \$111 pour AWS CloudHSM le SDK client 3](pkcs11-v3-attr-errors.md)
# Tableau des attributs de bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 3
La table de bibliothèque PKCS \$111 pour AWS CloudHSM le SDK client 3 contient une liste d'attributs qui diffèrent selon le type de clé. Il indique si un attribut donné est pris en charge pour un type de clé particulier lors de l'utilisation d'une fonction cryptographique spécifique avec AWS CloudHSM.
**Légende :**
+ ✔ indique que CloudHSM prend en charge l'attribut pour le type de clé spécifique.
+ ✖ indique que CloudHSM ne prend pas en charge l'attribut pour le type de clé spécifique.
+ R indique que la valeur de l'attribut est définie en lecture seule pour le type de clé spécifique.
+ S indique que l'attribut ne peut pas être lu par `GetAttributeValue` car sensible.
+ Une cellule vide dans la colonne Default Value (Valeur par défaut) indique qu'il n'y a aucune valeur par défaut attribuée à l'attribut.
## GenerateKeyPair
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html)
## GenerateKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html)
## CreateObject
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html)
## UnwrapKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html)
## DeriveKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html)
## GetAttributeValue
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html)
**Annotations d'attributs**
+ [1] Cet attribut est partiellement pris en charge par le micrologiciel et doit être explicitement défini sur la valeur par défaut.
+ [2] Attribut obligatoire.
+ [3] **SDK client 3 uniquement**. L’attribut `CKA_SIGN_RECOVER` est dérivé de l’attribut `CKA_SIGN`. S’il est défini, il doit uniquement l’être avec la même valeur que celle définie pour `CKA_SIGN`. Dans le cas contraire, il prend la valeur par défaut de `CKA_SIGN`. Étant donné que CloudHSM prend uniquement en charge les mécanismes de signature récupérable basés sur RSA, cet attribut est actuellement applicable uniquement aux clés publiques RSA.
+ [4] **SDK client 3 uniquement**. L’attribut `CKA_VERIFY_RECOVER` est dérivé de l’attribut `CKA_VERIFY`. S’il est défini, il doit uniquement l’être avec la même valeur que celle définie pour `CKA_VERIFY`. Dans le cas contraire, il prend la valeur par défaut de `CKA_VERIFY`. Étant donné que CloudHSM prend uniquement en charge les mécanismes de signature récupérable basés sur RSA, cet attribut est actuellement applicable uniquement aux clés publiques RSA.
# Modification des attributs de bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 3
Certains attributs d'un objet peuvent être modifiés une fois que l'objet a été créé, tandis que d’autres ne le peuvent pas. Pour modifier des attributs, utilisez la commande [setAttribute](cloudhsm_mgmt_util-setAttribute.md) à partir de cloudhsm\$1mgmt\$1util. Vous pouvez également obtenir une liste des attributs et des constantes qui les représentent en utilisant la commande [listAttribute](cloudhsm_mgmt_util-listAttributes.md) à partir de cloudhsm\$1mgmt\$1util.
La liste suivante contient les attributs que vous pouvez modifier après la création de l'objet :
+ `CKA_LABEL`
+ `CKA_TOKEN`
**Note**
La modification est autorisée uniquement pour changer une clé de session en une clé de jeton. Utilisez la commande [setAttribute](key_mgmt_util-setAttribute.md) à partir de key\$1mgmt\$1util pour modifier la valeur de l’attribut.
+ `CKA_ENCRYPT`
+ `CKA_DECRYPT`
+ `CKA_SIGN`
+ `CKA_VERIFY`
+ `CKA_WRAP`
+ `CKA_UNWRAP`
+ `CKA_LABEL`
+ `CKA_SENSITIVE`
+ `CKA_DERIVE`
**Note**
Cet attribut prend en charge la dérivation de clé. Il doit être `False` pour toutes les clés publiques et ne peut pas être défini sur `True`. Pour les clés privées EC et secrètes, il peut être défini sur `True` ou `False`.
+ `CKA_TRUSTED`
**Note**
Cet attribut peut être défini sur `True` ou `False` par le responsable du chiffrement uniquement.
+ `CKA_WRAP_WITH_TRUSTED`
**Note**
Appliquez cet attribut à une clé de données exportable pour indiquer que vous ne pouvez encapsuler cette clé qu'avec des clés marquées comme `CKA_TRUSTED`. Une fois `CKA_WRAP_WITH_TRUSTED` défini sur true, l'attribut passe en lecture seule et vous ne pouvez ni le modifier ni le supprimer.
# Interprétation des codes d'erreur de la bibliothèque PKCS \$111 pour AWS CloudHSM le SDK client 3
La spécification dans le modèle d'un attribut de bibliothèque PKCS \$111 qui n'est pas pris en charge par une clé spécifique entraîne une erreur. Le tableau suivant contient des codes d'erreur qui sont générés lorsque vous violez des spécifications :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/pkcs11-v3-attr-errors.html)
# Exemples de code pour la bibliothèque PKCS \$111 pour le SDK AWS CloudHSM client 3
Les exemples de code ci-dessous vous GitHub montrent comment accomplir des tâches de base à l'aide de la bibliothèque PKCS \$111 pour AWS CloudHSM.
## Prérequis d'exemples de code
Avant d'exécuter les exemples, effectuez les étapes suivantes pour configurer votre environnement :
+ Installez et configurez la [bibliothèque PKCS \$111](install-pkcs11-v3.md) pour le SDK client 3.
+ Configurez un [utilisateur de chiffrement(CU).](manage-hsm-users.md) Votre application utilise ce compte HSM pour exécuter les exemples de code sur le HSM.
## Exemples de code
Des exemples de code pour la bibliothèque AWS CloudHSM logicielle de PKCS \$111 sont disponibles sur [GitHub](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples). Ce référentiel contient des exemples sur la façon d'effectuer des opérations courantes à l'aide de PKCS \$111, y compris le chiffrement, le déchiffrement, la signature et la vérification.
+ [Générer des clés (AES, RSA, EC)](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate)
+ [Afficher les attributs des clés](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/attributes/)
+ [Chiffrer et déchiffrer les données avec AES GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/encrypt/aes_gcm.c)
+ [Chiffrer et déchiffrer les données avec AES\$1CTR](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/aes_ctr.c)
+ [Chiffrer et déchiffrer les données avec 3DES](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/des_ecb.c)
+ [Signer et vérifier les données avec RSA](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/sign/rsa_sign.c)
+ [Dériver des clés à l'aide de HMAC KDF](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/derivation/hmac_kdf.c)
+ [Encapsuler et désencapsuler les clés avec AES en utilisant le remplissage PKCS \$15](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_wrapping.c)
+ [Encapsuler et désencapsuler les clés avec AES sans remplissage](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_no_padding_wrapping.c)
+ [Encapsuler et désencapsuler les clés avec AES à l'aide du remplissage avec des zéros](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_zero_padding_wrapping.c)
+ [Encapsuler et désencapsuler les clés avec AES-GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/wrapping/aes_gcm_wrapping.c)
+ [Encapsuler et désencapsuler les clés avec RSA](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/rsa_wrapping.c)
# Moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 3
Le moteur dynamique AWS CloudHSM OpenSSL vous permet de décharger les opérations cryptographiques vers votre cluster CloudHSM via l'API OpenSSL.
AWS CloudHSM Le SDK client 3 nécessite un démon client pour se connecter au cluster. Il prend en charge :
+ Génération de clés RSA de 2 048, 3 072 et 4 096 bits.
+ Signature vérification RSA.
+ Chiffrement/Déchiffrement RSA.
+ Génération de nombres aléatoires sécurisée par voie cryptographique et conforme à la spécification FIPS.
Utilisez les sections suivantes pour installer et configurer le moteur AWS CloudHSM dynamique pour OpenSSL.
**Topics**
+ [Conditions préalables pour OpenSSL Dynamic Engine avec le SDK client 3 AWS CloudHSM](openssl3-install-dyn3-prereqs.md)
+ [Installation du moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 3](openssl3-install-openssl-library.md)
+ [Utiliser le moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 3](openssl3-use-library.md)
# Conditions préalables pour OpenSSL Dynamic Engine avec le SDK client 3 AWS CloudHSM
Pour plus d’informations sur les plateformes prises en charge, veuillez consulter [AWS CloudHSM Plateformes prises en charge par le SDK client 3](sdk3-support.md).
Avant de pouvoir utiliser le moteur AWS CloudHSM dynamique pour OpenSSL avec le SDK client 3, vous avez besoin du client. AWS CloudHSM
Le client est un démon qui établit une communication end-to-end cryptée avec le composant HSMs de votre cluster, et le moteur OpenSSL communique localement avec le client. Pour installer et configurer le AWS CloudHSM client, consultez[Installer le client (Linux)](cmu-install-and-configure-client-linux.md). Utilisez la commande suivante pour le démarrer.
------
#### [ Amazon Linux ]
```
$ sudo start cloudhsm-client
```
------
#### [ Amazon Linux 2 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ CentOS 6 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ CentOS 7 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ RHEL 6 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ RHEL 7 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
# Installation du moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 3
Les étapes suivantes décrivent comment installer et configurer le moteur AWS CloudHSM dynamique pour OpenSSL avec le SDK client 3. Pour plus d'informations sur la mise à niveau, veuillez consulter [Mettre à niveau le SDK client 3](client-upgrade.md).
**Pour installer et configurer le moteur OpenSSL**
1. Utilisez les commandes suivantes pour télécharger et installer le moteur OpenSSL.
------
#### [ Amazon Linux ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-dyn-latest.el6.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-dyn-latest.el6.x86_64.rpm
```
------
#### [ Amazon Linux 2 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-dyn-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-dyn-latest.el7.x86_64.rpm
```
------
#### [ CentOS 6 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-dyn-latest.el6.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-dyn-latest.el6.x86_64.rpm
```
------
#### [ CentOS 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-dyn-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-dyn-latest.el7.x86_64.rpm
```
------
#### [ RHEL 6 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-dyn-latest.el6.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-dyn-latest.el6.x86_64.rpm
```
------
#### [ RHEL 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-dyn-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-dyn-latest.el7.x86_64.rpm
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Xenial/cloudhsm-client-dyn_latest_amd64.deb
```
```
$ sudo apt install ./cloudhsm-client-dyn_latest_amd64.deb
```
------
Le moteur OpenSSL est installé sur `/opt/cloudhsm/lib/libcloudhsm_openssl.so`.
1. Utilisez la commande suivante pour définir la variable d'environnement `n3fips_password` qui contient les informations d'identification d'un utilisateur de chiffrement (CU).
```
$ export n3fips_password=:
```
# Utiliser le moteur AWS CloudHSM dynamique OpenSSL pour le SDK client 3
Pour utiliser le moteur AWS CloudHSM dynamique pour OpenSSL à partir d'une application intégrée à OpenSSL, assurez-vous que votre application utilise le moteur dynamique OpenSSL nommé. `cloudhsm` La bibliothèque partagée du moteur dynamique est située dans `/opt/cloudhsm/lib/libcloudhsm_openssl.so`.
Pour utiliser le moteur AWS CloudHSM dynamique pour OpenSSL à partir de la ligne de commande OpenSSL, utilisez l'`-engine`option permettant de spécifier le moteur dynamique OpenSSL nommé. `cloudhsm` Par exemple :
```
$ openssl s_server -cert -key -engine cloudhsm
```
# fournisseur JCE pour le SDK AWS CloudHSM client 3
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.
**Topics**
+ [Installation du fournisseur JCE pour le SDK AWS CloudHSM client 3](java-library-install.md)
+ [Notions de base de la gestion des clés dans le fournisseur JCE pour AWS CloudHSM le SDK client 3](java-library-key-basics.md)
+ [Mécanismes pris en charge pour le SDK client 3 pour le SDK AWS CloudHSM client 3](java-lib-supported.md)
+ [Attributs clés Java pris en charge pour AWS CloudHSM le SDK client 3](java-lib-attributes.md)
+ [Exemples de code pour la bibliothèque de AWS CloudHSM logiciels pour Java for Client SDK 3](java-samples_3.md)
+ [AWS CloudHSM KeyStore Classe Java pour le SDK client 3](alternative-keystore.md)
# Installation du fournisseur JCE pour le SDK AWS CloudHSM client 3
Avant de pouvoir utiliser le fournisseur JCE, vous avez besoin du AWS CloudHSM client.
Le client est un démon qui établit une communication end-to-end cryptée avec le HSMs dans votre cluster. Le fournisseur JCE communique localement avec le client. Si vous n'avez pas installé ni configuré le package AWS CloudHSM client, faites-le maintenant en suivant les étapes décrites dans[Installer le client (Linux)](cmu-install-and-configure-client-linux.md). Une fois que vous avez installé et configuré le client, utilisez la commande suivante pour le démarrer.
Le fournisseur JCE est uniquement pris en charge sur les systèmes d'exploitation Linux et compatibles.
------
#### [ Amazon Linux ]
```
$ sudo start cloudhsm-client
```
------
#### [ Amazon Linux 2 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ CentOS 7 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ CentOS 8 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ RHEL 7 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ RHEL 8 ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
#### [ Ubuntu 20.04 LTS ]
```
$ sudo systemctl start cloudhsm-client
```
------
Utilisez les sections suivantes pour installer, valider et fournir des informations d'identification au fournisseur.
**Topics**
+ [Étape 1 : Installation du fournisseur JCE](#install-java-library)
+ [Étape 2 : valider l'installation](#validate-install)
+ [Étape 3 : Fournissez les informations d'identification au fournisseur JCE](#java-library-credentials)
## Étape 1 : Installation du fournisseur JCE
Utilisez les commandes suivantes pour télécharger et installer le fournisseur JCE. Cette bibliothèque est prise en charge uniquement sur les systèmes d'exploitation Linux et compatibles.
**Note**
Pour la mise à niveau, consultez [Mettre à niveau le SDK client 3](client-upgrade.md).
------
#### [ Amazon Linux ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-jce-latest.el6.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-jce-latest.el6.x86_64.rpm
```
------
#### [ Amazon Linux 2 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-jce-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-jce-latest.el7.x86_64.rpm
```
------
#### [ CentOS 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-jce-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-jce-latest.el7.x86_64.rpm
```
------
#### [ CentOS 8 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-jce-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-jce-latest.el8.x86_64.rpm
```
------
#### [ RHEL 7 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-jce-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-jce-latest.el7.x86_64.rpm
```
------
#### [ RHEL 8 ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-jce-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-client-jce-latest.el8.x86_64.rpm
```
------
#### [ Ubuntu 16.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Xenial/cloudhsm-client-jce_latest_amd64.deb
```
```
$ sudo apt install ./cloudhsm-client-jce_latest_amd64.deb
```
------
#### [ Ubuntu 18.04 LTS ]
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Bionic/cloudhsm-client-jce_latest_u18.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-client-jce_latest_u18.04_amd64.deb
```
------
Une fois que vous avez exécuté les commandes précédentes, vous pouvez trouver les fichiers du fournisseur JCE suivants :
+ `/opt/cloudhsm/java/cloudhsm-.jar`
+ `/opt/cloudhsm/java/cloudhsm-test-.jar`
+ `/opt/cloudhsm/java/hamcrest-all-1.3.jar`
+ `/opt/cloudhsm/java/junit.jar`
+ `/opt/cloudhsm/java/log4j-api-2.17.1.jar`
+ `/opt/cloudhsm/java/log4j-core-2.17.1.jar`
+ `/opt/cloudhsm/lib/libcaviumjca.so`
## Étape 2 : valider l'installation
Effectuez des opérations de base sur le HSM pour valider l'installation.
**Pour valider l'installation du fournisseur JCE**
1. (Facultatif) Si besoin, utilisez la commande suivante pour installer Java dans votre environnement.
------
#### [ Linux (and compatible libraries) ]
```
$ sudo yum install java-1.8.0-openjdk
```
------
#### [ Ubuntu ]
```
$ sudo apt-get install openjdk-8-jre
```
------
1. Utilisez les commandes suivantes pour définir les variables d'environnement nécessaires. Remplacez ** et ** par les informations d'identification d'un utilisateur cryptographique (CU).
```
$ export LD_LIBRARY_PATH=/opt/cloudhsm/lib
```
```
$ export HSM_PARTITION=PARTITION_1
```
```
$ export HSM_USER=
```
```
$ export HSM_PASSWORD=
```
1. Utilisez la commande suivante pour lancer le test des fonctionnalités de base. Si elle aboutit, la sortie de commande devrait ressembler à la sortie ci-dessous.
```
$ java8 -classpath "/opt/cloudhsm/java/*" org.junit.runner.JUnitCore TestBasicFunctionality
JUnit version 4.11
.2018-08-20 17:53:48,514 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:33) - Adding provider.
2018-08-20 17:53:48,612 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:42) - Logging in.
2018-08-20 17:53:48,612 INFO [main] cfm2.LoginManager (LoginManager.java:104) - Looking for credentials in HsmCredentials.properties
2018-08-20 17:53:48,612 INFO [main] cfm2.LoginManager (LoginManager.java:122) - Looking for credentials in System.properties
2018-08-20 17:53:48,613 INFO [main] cfm2.LoginManager (LoginManager.java:130) - Looking for credentials in System.env
SDK Version: 2.03
2018-08-20 17:53:48,655 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:54) - Generating AES Key with key size 256.
2018-08-20 17:53:48,698 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:63) - Encrypting with AES Key.
2018-08-20 17:53:48,705 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:84) - Deleting AES Key.
2018-08-20 17:53:48,707 DEBUG [main] TestBasicFunctionality (TestBasicFunctionality.java:92) - Logging out.
Time: 0.205
OK (1 test)
```
## Étape 3 : Fournissez les informations d'identification au fournisseur JCE
HSMs devez authentifier votre application Java avant que l'application puisse les utiliser. Chaque application peut utiliser une session. HSMs authentifier une session en utilisant une méthode de connexion explicite ou implicite.
**Connexion explicite** : Cette méthode vous permet de fournir les informations d’identification CloudHSM directement dans l’application. Elle utilise la méthode `LoginManager.login()`, dans laquelle vous transmettez le nom d'utilisateur et le mot de passe du CU, ainsi que l’ID de partition du HSM. Pour plus d'informations sur l'utilisation de la méthode de connexion explicite, consultez l’exemple de code [Connexion à un HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java).
**Connexion implicite** : Cette méthode vous permet de définir les informations de connexion CloudHSM dans un nouveau fichier de propriétés, dans les propriétés système ou en tant que variables d’environnement.
+ **Nouveau fichier de propriétés** : Créez un nouveau fichier intitulé `HsmCredentials.properties` et ajoutez-le dans le `CLASSPATH` de votre application. Le fichier doit contenir ce qui suit :
```
HSM_PARTITION = PARTITION_1
HSM_USER =
HSM_PASSWORD =
```
+ **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 :
```
$ java -DHSM_PARTITION=PARTITION_1 -DHSM_USER= -DHSM_PASSWORD=
```
```
System.setProperty("HSM_PARTITION","PARTITION_1");
System.setProperty("HSM_USER","");
System.setProperty("HSM_PASSWORD","");
```
+ **Variables d’environnement** : Définissez les informations d’identification en tant que variables d’environnement.
```
$ export HSM_PARTITION=PARTITION_1
$ export HSM_USER=
$ export 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. `HsmCredentials.properties`
1. Propriétés système
1. Variables d’environnement
**Gestion des erreurs**
La gestion des erreurs est plus facile avec la méthode de connexion explicite qu’avec la méthode de connexion implicite. Lorsque vous utilisez la classe `LoginManager`, vous maîtrisez mieux la manière dont votre application gère les pannes. La méthode de connexion implicite rend la gestion des erreurs difficile à comprendre lorsque les informations d'identification ne sont pas valides ou que l' HSMs authentification de session pose problème.
# Notions de base de la gestion des clés dans le fournisseur JCE pour AWS CloudHSM le SDK client 3
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/master/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_3.md).
# Mécanismes pris en charge pour le SDK client 3 pour le SDK AWS CloudHSM client 3
Cette rubrique fournit des informations sur les mécanismes pris en charge par le fournisseur JCE avec AWS CloudHSM le SDK client 3. 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**
+ [Clés prises en charge](#java-keys)
+ [Chiffrements pris en charge](#java-ciphers)
+ [Synthèses prises en charge](#java-digests)
+ [Algorithmes HMAC (Hash-Based Message Authentication Code) pris en charge](#java-mac)
+ [sign/verify Mécanismes pris en charge](#java-sign-verify)
+ [Annotations du mécanisme](#w2aac25c23c25c11c17)
## Clés prises en charge
La bibliothèque AWS CloudHSM logicielle pour Java vous permet de générer les types de clés suivants.
+ AES – Clés AES de 128, 192 et 256 bits.
+ DESede — Clé 3DES 92 bits. Voir la note [1](#java-keys-note-1) ci-dessous pour un changement à venir.
+ Paires de clés ECC pour courbes NIST secp256r1 (P-256), secp384r1 (P-384) et secp256k1 (Blockchain).
+ RSA : Clés RSA de 2 048 bits à 4 096 bits, par incréments de 256 bits.
Outre les paramètres standard, nous prenons en charge les paramètres suivants pour chaque clé générée.
+ **Label** : étiquette de clé que vous pouvez utiliser pour rechercher des clés.
+ **isExtractable** : indique si la clé peut être exportée depuis le HSM.
+ **isPersistent** : indique si la clé reste sur le HSM lorsque la session en cours se termine.
**Note**
La version 3.1 de la bibliothèque Java permet de spécifier les paramètres plus en détail. Pour plus d'informations, consultez [Attributs Java pris en charge](java-lib-attributes.md).
## Chiffrements pris en charge
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`. |
| AES | ECB | `AES/ECB/NoPadding` `AES/ECB/PKCS5Padding` | Implémente Cipher.ENCRYPT\$1MODE et Cipher.DECRYPT\$1MODE. Utilisez Transformation AES. |
| AES | CTR | `AES/CTR/NoPadding` | Implémente `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`. |
| AES | GCM | AES/GCM/NoPadding | Implémente `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`, `Cipher.WRAP_MODE` et `Cipher.UNWRAP_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/ZeroPadding` `AESWrap/ECB/NoPadding` `AESWrap/ECB/PKCS5Padding` | Implémente `Cipher.WRAP_MODE` et `Cipher.UNWRAP_MODE`. Utilisez Transformation AES. |
| DESede (Triple DES) | CBC | `DESede/CBC/NoPadding` `DESede/CBC/PKCS5Padding` | Implémente `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`. Les routines de génération de clé acceptent une taille de 168 ou 192 bits. Cependant, en interne, toutes les DESede clés sont de 192 bits. Voir la note [1](#java-keys-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`. Les routines de génération de clé acceptent une taille de 168 ou 192 bits. Cependant, en interne, toutes les DESede clés sont de 192 bits. Voir la note [1](#java-keys-note-1) ci-dessous pour un changement à venir. |
| RSA | ECB | `RSA/ECB/NoPadding``RSA/ECB/PKCS1Padding` | Implémente `Cipher.ENCRYPT_MODE` et `Cipher.DECRYPT_MODE`. Voir la note [1](#java-keys-note-1) ci-dessous pour un changement à venir. |
| RSA | ECB | `RSA/ECB/OAEPPadding` `RSA/ECB/OAEPWithSHA-1ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-224ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-256ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-384ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-512ANDMGF1Padding` | Implémente `Cipher.ENCRYPT_MODE`, `Cipher.DECRYPT_MODE`, `Cipher.WRAP_MODE` et `Cipher.UNWRAP_MODE`. `OAEPPadding` est `OAEP` avec le type de remplissage `SHA-1`. |
| RSAAESWrap | ECB | OAEPPADDING | Implémente Cipher.WRAP\$1Mode et Cipher.UNWRAP\$1MODE. |
## Synthèses prises en charge
La bibliothèque AWS CloudHSM logicielle pour Java prend en charge les résumés de messages suivants.
+ `SHA-1`
+ `SHA-224`
+ `SHA-256`
+ `SHA-384`
+ `SHA-512`
**Note**
Les données inférieures à 16 Ko en longueur sont hachées sur le HSM, tandis que les données plus grandes le sont localement dans le logiciel.
## Algorithmes HMAC (Hash-Based Message Authentication Code) pris en charge
La bibliothèque AWS CloudHSM logicielle pour Java prend en charge les algorithmes HMAC suivants.
+ `HmacSHA1`
+ `HmacSHA224`
+ `HmacSHA256`
+ `HmacSHA384`
+ `HmacSHA512`
## sign/verify Mécanismes pris en charge
La bibliothèque AWS CloudHSM logicielle pour Java prend en charge les types de signature et de vérification suivants.
**Types de signature RSA**
+ `NONEwithRSA`
+ `SHA1withRSA`
+ `SHA224withRSA`
+ `SHA256withRSA`
+ `SHA384withRSA`
+ `SHA512withRSA`
+ `SHA1withRSA/PSS`
+ `SHA224withRSA/PSS`
+ `SHA256withRSA/PSS`
+ `SHA384withRSA/PSS`
+ `SHA512withRSA/PSS`
**Types de signature ECDSA**
+ `NONEwithECDSA`
+ `SHA1withECDSA`
+ `SHA224withECDSA`
+ `SHA256withECDSA`
+ `SHA384withECDSA`
+ `SHA512withECDSA`
## 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.
# Attributs clés Java pris en charge pour AWS CloudHSM le SDK client 3
Cette rubrique décrit comment utiliser une extension propriétaire pour la bibliothèque Java version 3.1 afin de définir les attributs clés AWS CloudHSM du SDK client 3. 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
+ Désencapsulage de clés
**Note**
L'extension permettant de définir des attributs de clés personnalisés est une fonctionnalité facultative. Si vous avez déjà du code qui fonctionne dans la bibliothèque Java version 3.0, vous n'avez pas besoin de modifier ce code. Les clés que vous créez continueront de contenir les mêmes attributs qu'auparavant.
**Topics**
+ [Présentation des attributs](#java-understanding-attributes)
+ [Attributs pris en charge](#java-attributes)
+ [Définition des attributs pour une clé](#java-setting-attributes)
+ [Tout mettre en place](#java-attributes-summary)
## Présentation des attributs
Les attributs de clés 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és. 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 de la version 3.1 de la bibliothèque Java, 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 n'indiquez pas de valeur, 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 | |
| CKA\$1TOKEN | FALSE | FALSE | FALSE | Une clé permanente qui est répliquée sur l'ensemble HSMs du cluster et incluse dans les sauvegardes. CKA\$1TOKEN = FALSE implique une clé de session, qui n'est chargée que sur un seul HSM et automatiquement effacée lorsque la connexion au HSM est interrompue. |
| CKA\$1LABEL | | | | Chaîne définie par l'utilisateur. Permet d'identifier facilement les clés de votre HSM. |
| CKA\$1EXTRACTABLE | TRUE | | TRUE | True indique que vous pouvez exporter cette clé hors du HSM. |
| CKA\$1ENCRYPT | TRUE | TRUE | | True indique que vous pouvez utiliser la clé pour chiffrer n'importe quelle mémoire tampon. |
| CKA\$1DECRYPT | 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 CKA\$1WRAP est défini sur true. |
| CKA\$1WRAP | 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. |
| CKA\$1UNWRAP | TRUE | | TRUE | True indique que vous pouvez utiliser la clé pour décencapsuler (importer) une autre clé. |
| CKA\$1SIGN | 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. |
| CKA\$1VERIFY | 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. |
| CKA\$1PRIVATE | 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é sur CloudHSM tant qu'ils n'ont pas été authentifiés, même si cet attribut est défini sur FALSE. |
**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é
`CloudHsmKeyAttributesMap` est un objet de type [Java Map](https://devdocs.io/openjdk~8/java/util/map) que vous pouvez utiliser pour définir des valeurs d'attribut pour les objets de type clé. Les méthodes de `CloudHsmKeyAttributesMap` 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 `CloudHSMKeyAttributesMap` |
| --- | --- | --- |
| 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).
### Exemple de modèle de générateur
Les développeurs trouvent généralement plus pratique d'utiliser les classes via le modèle de générateur. À titre d'exemple :
```
import com.amazonaws.cloudhsm.CloudHsmKeyAttributes;
import com.amazonaws.cloudhsm.CloudHsmKeyAttributesMap;
import com.amazonaws.cloudhsm.CloudHsmKeyPairAttributesMap;
CloudHsmKeyAttributesMap keyAttributesSessionDecryptionKey =
new CloudHsmKeyAttributesMap.Builder()
.put(CloudHsmKeyAttributes.CKA_LABEL, "ExtractableSessionKeyEncryptDecrypt")
.put(CloudHsmKeyAttributes.CKA_WRAP, false)
.put(CloudHsmKeyAttributes.CKA_UNWRAP, false)
.put(CloudHsmKeyAttributes.CKA_SIGN, false)
.put(CloudHsmKeyAttributes.CKA_VERIFY, false)
.build();
CloudHsmKeyAttributesMap keyAttributesTokenWrappingKey =
new CloudHsmKeyAttributesMap.Builder()
.put(CloudHsmKeyAttributes.CKA_LABEL, "TokenWrappingKey")
.put(CloudHsmKeyAttributes.CKA_TOKEN, true)
.put(CloudHsmKeyAttributes.CKA_ENCRYPT, false)
.put(CloudHsmKeyAttributes.CKA_DECRYPT, false)
.put(CloudHsmKeyAttributes.CKA_SIGN, false)
.put(CloudHsmKeyAttributes.CKA_VERIFY, false)
.build();
```
Les développeurs peuvent également utiliser des ensembles d'attributs prédéfinis comme un moyen pratique d'imposer le respect des bonnes pratiques dans les modèles de clés. À titre d’exemple :
```
//best practice template for wrapping keys
CloudHsmKeyAttributesMap commonKeyAttrs = new CloudHsmKeyAttributesMap.Builder()
.put(CloudHsmKeyAttributes.CKA_EXTRACTABLE, false)
.put(CloudHsmKeyAttributes.CKA_DECRYPT, false)
.build();
// initialize a new instance of CloudHsmKeyAttributesMap by copying commonKeyAttrs
// but with an appropriate label
CloudHsmKeyAttributesMap firstKeyAttrs = new CloudHsmKeyAttributesMap(commonKeyAttrs);
firstKeyAttrs.put(CloudHsmKeyAttributes.CKA_LABEL, "key label");
// alternatively, putAll() will overwrite existing values to enforce conformance
CloudHsmKeyAttributesMap secondKeyAttrs = new CloudHsmKeyAttributesMap();
secondKeyAttrs.put(CloudHsmKeyAttributes.CKA_DECRYPT, true);
secondKeyAttrs.put(CloudHsmKeyAttributes.CKA_ENCRYPT, true);
secondKeyAttrs.put(CloudHsmKeyAttributes.CKA_LABEL, “safe wrapping key”);
secondKeyAttrs.putAll(commonKeyAttrs); // will overwrite CKA_DECRYPT to be FALSE
```
### Définition des attributs pour une paire de clés
Utilisez la classe Java `CloudHsmKeyPairAttributesMap` pour gérer les attributs d'une paire de clés. `CloudHsmKeyPairAttributesMap` encapsule deux objets `CloudHsmKeyAttributesMap` : 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é `CloudHsmKeyAttributes` 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.
### Exemple de modèle de générateur
Les développeurs trouvent généralement plus pratique de définir des attributs de clés via le modèle de générateur. Par exemple :
```
import com.amazonaws.cloudhsm.CloudHsmKeyAttributes;
import com.amazonaws.cloudhsm.CloudHsmKeyAttributesMap;
import com.amazonaws.cloudhsm.CloudHsmKeyPairAttributesMap;
//specify attributes up-front
CloudHsmKeyAttributesMap keyAttributes =
new CloudHsmKeyAttributesMap.Builder()
.put(CloudHsmKeyAttributes.CKA_SIGN, false)
.put(CloudHsmKeyAttributes.CKA_LABEL, "PublicCertSerial12345")
.build();
CloudHsmKeyPairAttributesMap keyPairAttributes =
new CloudHsmKeyPairAttributesMap.Builder()
.withPublic(keyAttributes)
.withPrivate(
new CloudHsmKeyAttributesMap.Builder() //or specify them inline
.put(CloudHsmKeyAttributes.CKA_LABEL, "PrivateCertSerial12345")
.put (CloudHSMKeyAttributes.CKA_WRAP, FALSE)
.build()
)
.build();
```
**Note**
Pour plus d'informations sur cette extension propriétaire, consultez l'archive [Javadoc](https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Docs/CloudHsm_CustomKeyAttributes_Javadoc.zip) et l'[exemple](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/CustomKeyAttributesRunner.java) sur. GitHub Pour explorer Javadoc, téléchargez et développez l'archive.
## Tout mettre en place
Pour spécifier des attributs de clés avec vos opérations de clés, procédez comme suit :
1. Instancier `CloudHsmKeyAttributesMap` pour les clés symétriques ou `CloudHsmKeyPairAttributesMap` pour les paires de clés.
1. Définissez l'objet Attributs de l'étape 1 avec les attributs et valeurs de clés requis.
1. Instanciez une classe `Cavium*ParameterSpec`, correspondant à votre type de clé spécifique, et transmettez cet objet d'attributs configuré à son constructeur.
1. Transmettez cet objet `Cavium*ParameterSpec` à une classe ou une méthode de chiffrement correspondante.
Pour référence, le tableau suivant contient les classes et méthodes `Cavium*ParameterSpec` qui prennent en charge les attributs de clé personnalisés.
****
| Type de clé | Classe de spécification de paramètre | Exemples de constructeurs |
| --- | --- | --- |
| Classe de base | CaviumKeyGenAlgorithmParameterSpec | CaviumKeyGenAlgorithmParameterSpec(CloudHsmKeyAttributesMap keyAttributesMap) |
| DES | CaviumDESKeyGenParameterSpec | CaviumDESKeyGenParameterSpec(int keySize, byte[] iv, CloudHsmKeyAttributesMap keyAttributesMap) |
| RSA | CaviumRSAKeyGenParameterSpec | CaviumRSAKeyGenParameterSpec(int keysize, BigInteger publicExponent, CloudHsmKeyPairAttributesMap keyPairAttributesMap) |
| Secret | CaviumGenericSecretKeyGenParameterSpec | CaviumGenericSecretKeyGenParameterSpec(int size, CloudHsmKeyAttributesMap keyAttributesMap) |
| AES | CaviumAESKeyGenParameterSpec | CaviumAESKeyGenParameterSpec(int keySize, byte[] iv, CloudHsmKeyAttributesMap keyAttributesMap) |
| EC | CaviumECGenParameterSpec | CaviumECGenParameterSpec(String stdName, CloudHsmKeyPairAttributesMap keyPairAttributesMap) |
### Exemple de code : générer et encapsuler une clé
Ces brefs exemples de code illustrent les étapes de deux opérations différentes : la génération d'une clé et son encapsulage :
```
// Set up the desired key attributes
KeyGenerator keyGen = KeyGenerator.getInstance("AES", "Cavium");
CaviumAESKeyGenParameterSpec keyAttributes = new CaviumAESKeyGenParameterSpec(
256,
new CloudHsmKeyAttributesMap.Builder()
.put(CloudHsmKeyAttributes.CKA_LABEL, "MyPersistentAESKey")
.put(CloudHsmKeyAttributes.CKA_EXTRACTABLE, true)
.put(CloudHsmKeyAttributes.CKA_TOKEN, true)
.build()
);
// Assume we already have a handle to the myWrappingKey
// Assume we already have the wrappedBytes to unwrap
// Unwrap a key using Custom Key Attributes
CaviumUnwrapParameterSpec unwrapSpec = new CaviumUnwrapParameterSpec(myInitializationVector, keyAttributes);
Cipher unwrapCipher = Cipher.getInstance("AESWrap", "Cavium");
unwrapCipher.init(Cipher.UNWRAP_MODE, myWrappingKey, unwrapSpec);
Key unwrappedKey = unwrapCipher.unwrap(wrappedBytes, "AES", Cipher.SECRET_KEY);
```
# Exemples de code pour la bibliothèque de AWS CloudHSM logiciels pour Java for Client SDK 3
Cette rubrique fournit des ressources et des informations sur des exemples de code Java pour AWS CloudHSM le SDK client 3.
## 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.md#install-java-library) et le [package client AWS CloudHSM](cmu-install-and-configure-client-linux.md).
+ 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.md#java-library-credentials).
## 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/).
+ [Se connecter à un HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java)
+ [Gérer les clés](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java)
+ [Générer une clé AES](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/SymmetricKeys.java)
+ [Chiffrer et déchiffrer avec AES-GCM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/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/master/src/main/java/com/amazonaws/cloudhsm/examples/AESCTREncryptDecryptRunner.java)
+ [Chiffrer et déchiffrer avec D3DES-ECB]( https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/DESedeECBEncryptDecryptRunner.java)**voir note [1](#java-samples-code-note-1)**
+ [Encapsuler et désencapsuler les clés avec AES-GCM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/AESGCMWrappingRunner.java)
+ [Encapsuler et désencapsuler les clés avec AES](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/AESWrappingRunner.java)
+ [Encapsuler et désencapsuler les clés avec RSA](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/RSAWrappingRunner.java)
+ [Utiliser les attributs de clé pris en charge](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/CustomKeyAttributesRunner.java)
+ [Énumérer les clés dans le magasin de clés](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/KeyStoreExampleRunner.java)
+ [Utiliser le magasin de clés CloudHSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/CloudHSMKeyStoreExampleRunner.java)
+ [Signer les messages d'un échantillon multi-thread](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/SignThreadedRunner.java)
+ [Signer et vérifier à l'aide des clés EC](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/master/src/main/java/com/amazonaws/cloudhsm/examples/ECOperationsRunner.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 KeyStore Classe Java pour le SDK client 3
**La AWS CloudHSM `KeyStore` classe fournit un magasin de PKCS12 clés spécial qui permet d'accéder aux AWS CloudHSM clés via des applications telles que **keytool** et jarsigner.** 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.
**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.
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://docs.oracle.com/javase/8/docs/api/java/security/KeyStore.html).
## Choisissez le magasin de clés approprié pour AWS CloudHSM le SDK client 3
Le fournisseur d'extension cryptographique AWS CloudHSM Java (JCE) est fourni avec un magasin de clés par défaut en lecture seule qui transmet toutes les transactions au HSM. Ce magasin de clés par défaut est distinct du magasin à usage spécial AWS CloudHSM KeyStore. Dans la plupart des cas, vous obtiendrez de meilleures performances d'exécution et débit en utilisant la valeur par défaut. Vous ne devez l'utiliser que AWS CloudHSM KeyStore pour les applications pour lesquelles vous avez besoin de support pour les certificats et les opérations basées sur des certificats, en plus du transfert des opérations clés vers le HSM.
Bien que les deux magasins de clés utilisent le fournisseur JCE pour leurs opérations, ce sont des entités indépendantes qui n'échangent pas d'informations entre elles.
Chargez le magasin de clés par défaut pour votre application Java comme suit :
```
KeyStore ks = KeyStore.getInstance("Cavium");
```
Chargez le CloudHSM spécialisé comme suit : KeyStore
```
KeyStore ks = KeyStore.getInstance("CloudHSM")
```
## Initialisez le SDK AWS CloudHSM KeyStore for Client 3
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/master/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);
```
## Utilisez le SDK AWS CloudHSM KeyStore for AWS CloudHSM Client 3
[Un objet KeyStore CloudHSM est généralement utilisé par le biais d'une application tierce telle [que](https://docs.oracle.com/javase/8/docs/technotes/tools/windows/jarsigner.html) jarsigner ou keytool.](https://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html) Vous pouvez également accéder directement à l'objet avec le code.
AWS CloudHSM KeyStore est conforme aux KeyStore spécifications de la [classe](https://docs.oracle.com/javase/8/docs/api/java/security/KeyStore.html) 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 avec l'outil [key\$1mgmt\$1util](https://docs.aws.amazon.com/cloudhsm/latest/userguide/key_mgmt_util.html) de CloudHSM.
+ `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 3.**
+ `SetKeyEntry` avec l'objet `Key`
Affecte la clé donnée à l'alias donné et la stocke dans le HSM. Si l'objet `Key` n'est pas de type `CaviumKey`, la clé est 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`).
# API de cryptographie : fournisseurs de nouvelle génération (CNG) et de stockage de clés (KSP) pour AWS CloudHSM
Le AWS CloudHSM client pour Windows inclut les fournisseurs CNG et KSP.
Les *fournisseurs de stockage de clés* (KSPs) permettent le stockage et la récupération des clés. Par exemple, si vous ajoutez le rôle de services de certificats Microsoft Active Directory (AD CS) à votre serveur Windows et choisissez de créer une nouvelle clé privée pour votre autorité de certification (CA), vous pouvez choisir le fournisseur de stockage de clés qui gèrera le stockage. Lorsque vous configurez le rôle AD CS, vous pouvez choisir ce KSP. Pour de plus amples informations, veuillez consulter [Créer une CA Windows Server](win-ca-overview-sdk5.md#win-ca-setup-sdk5).
*API Cryptography : Next Generation (CNG)* est une API de chiffrement spécifique au système d'exploitation Microsoft Windows. CNG permet aux développeurs d'utiliser les techniques de chiffrement pour sécuriser les applications Windows. À un niveau élevé, la AWS CloudHSM mise en œuvre du GNC fournit les fonctionnalités suivantes :
+ **Primitives cryptographiques** : elles vous permettent d'effectuer des opérations cryptographiques fondamentales.
+ **Importation et exportation de clés** : vous permet d'importer et d'exporter des clés asymétriques.
+ **API de protection des données (CNG DPAPI)** : vous permet de chiffrer et de déchiffrer facilement les données.
+ **Stockage et récupération des clés** : vous permettent de stocker et d'isoler en toute sécurité la clé privée d'une paire de clés asymétrique.
**Topics**
+ [Vérifiez les fournisseurs KSP et GNC pour AWS CloudHSM](ksp-v3-library-install.md)
+ [Conditions préalables à l'utilisation du client AWS CloudHSM Windows](ksp-library-prereq.md)
+ [Associer une AWS CloudHSM clé à un certificat](ksp-library-associate-key-certificate.md)
+ [Exemple de code pour le fournisseur de GNC pour AWS CloudHSM](ksp-library-sample.md)
# Vérifiez les fournisseurs KSP et GNC pour AWS CloudHSM
Les fournisseurs KSP et CNG sont installés lorsque vous installez le client Windows AWS CloudHSM . Vous pouvez installer le client en suivant les étapes indiquées dans [Installation du client (Windows)](kmu-install-and-configure-client-win.md).
Utilisez les sections suivantes pour vérifier l'installation des fournisseurs.
## Configuration et exécution du AWS CloudHSM client Windows
Pour démarrer le client Windows CloudHSM, vous devez d'abord respecter les [Conditions préalables](ksp-library-prereq.md). Mettez ensuite à jour les fichiers de configuration utilisés par les fournisseurs et démarrez le client en suivant les étapes ci-dessous. Vous devez effectuer ces étapes la première fois que vous utilisez les fournisseurs KSP et CNG et après avoir ajouté ou supprimé un élément HSMs dans votre cluster. De cette façon, AWS CloudHSM il est possible de synchroniser les données et de maintenir la cohérence HSMs dans l'ensemble du cluster.
### Étape 1 : Arrêter le AWS CloudHSM client
Avant de mettre à jour les fichiers de configuration utilisés par les fournisseurs, arrêtez le AWS CloudHSM client. Si le client est déjà été arrêté, l'exécution de la commande stop n'a aucun effet.
+ Pour le Client Windows version 1.1.2 et ultérieure :
```
C:\Program Files\Amazon\CloudHSM>net.exe stop AWSCloudHSMClient
```
+ Pour les clients Windows version 1.1.1 et antérieure :
Utilisez **Ctrl** \$1 **C** dans la fenêtre de commande dans laquelle vous avez démarré le AWS CloudHSM client.
### Étape 2 : mise à jour des fichiers AWS CloudHSM de configuration
Cette étape utilise le `-a` paramètre de l'[outil Configure](configure-tool.md) pour ajouter l'adresse IP ENI (Elastic Network Interface) de l' HSMs un des éléments du cluster au fichier de configuration.
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\configure.exe" -a
```
Pour obtenir l'adresse IP ENI d'un HSM de votre cluster, accédez à la AWS CloudHSM console, choisissez des **clusters**, puis sélectionnez le cluster souhaité. Vous pouvez également utiliser l'[DescribeClusters](https://docs.aws.amazon.com/cloudhsm/latest/APIReference/API_DescribeClusters.html)opération, la commande [describe-clusters](https://docs.aws.amazon.com/cli/latest/reference/cloudhsmv2/describe-clusters.html) ou l'applet de [Get-HSM2Cluster](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-HSM2Cluster.html) PowerShellcommande. Saisissez une seule adresse IP d'ENI. Peu importe l'adresse IP d'ENI que vous utilisez.
### Étape 3 : démarrer le AWS CloudHSM client
Ensuite, démarrez ou redémarrez le AWS CloudHSM client. Lorsque le AWS CloudHSM client démarre, il utilise l'adresse IP ENI dans son fichier de configuration pour interroger le cluster. Il ajoute ensuite les adresses IP ENI de tous HSMs les membres du cluster au fichier d'informations du cluster.
+ Pour le Client Windows version 1.1.2 et ultérieure :
```
C:\Program Files\Amazon\CloudHSM>net.exe start AWSCloudHSMClient
```
+ Pour les clients Windows version 1.1.1 et antérieure :
```
C:\Program Files\Amazon\CloudHSM>start "cloudhsm_client" cloudhsm_client.exe C:\ProgramData\Amazon\CloudHSM\data\cloudhsm_client.cfg
```
## Recherche de fournisseurs KSP et GNC
Vous pouvez utiliser l'une ou l'autre des commandes suivantes afin de déterminer les fournisseurs qui sont installés sur votre système. Les commandes répertorient les fournisseurs KSP et CNG enregistrée. Le client AWS CloudHSM n'a pas besoin d'être en cours d'exécution.
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\ksp_config.exe" -enum
```
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\cng_config.exe" -enum
```
Pour vérifier que les fournisseurs KSP et CNG sont installés sur votre instance Windows Server EC2, vous devriez voir les entrées suivantes dans la liste :
```
Cavium CNG Provider
Cavium Key Storage Provider
```
Si le fournisseur CNG est manquant, exécutez la commande suivante.
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\cng_config.exe" -register
```
Si le fournisseur KSP est manquant, exécutez la commande suivante.
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\ksp_config.exe" -register
```
# Conditions préalables à l'utilisation du client AWS CloudHSM Windows
Avant de démarrer le AWS CloudHSM client Windows et d'utiliser les fournisseurs KSP et CNG, vous devez définir les informations de connexion du HSM sur votre système. Vous pouvez définir les informations d'identification via le Gestionnaire d'informations d'identification Windows ou la variable d'environnement système. Nous vous recommandons d'utiliser le Gestionnaire d'informations d'identification Windows pour stocker les informations d'identification. Cette option est disponible avec les versions 2.0.4 et ultérieures du AWS CloudHSM client. L'utilisation de la variable d'environnement est plus facile à configurer, mais moins sécurisée que l'utilisation du Gestionnaire d'informations d'identification Windows.
## Gestionnaire d'informations d'identification Windows
Vous pouvez utiliser l'utilitaire `set_cloudhsm_credentials` ou l'interface du Gestionnaire d'informations d'identification Windows.
+ **Utilisation de l'utilitaire `set_cloudhsm_credentials`** :
L'utilitaire `set_cloudhsm_credentials` est inclus dans votre programme d'installation Windows. Vous pouvez utiliser cet utilitaire pour transmettre facilement les informations d'identification de connexion HSM au Gestionnaire d'informations d'identification Windows. Si vous souhaitez compiler cet utilitaire à partir de la source, vous pouvez utiliser le code Python inclus dans le programme d'installation.
1. Accédez au dossier `C:\Program Files\Amazon\CloudHSM\tools\`.
1. Exécutez le fichier `set_cloudhsm_credentials.exe` avec les paramètres de nom d'utilisateur et de mot de passe CU.
```
set_cloudhsm_credentials.exe --username --password
```
+ **Utilisation de l'interface du Gestionnaire d'informations d'identification** :
Vous pouvez utiliser l'interface du Gestionnaire d'informations d'identification pour gérer manuellement vos informations d'identification.
1. Pour ouvrir Credential Manager, tapez `credential manager` dans la zone de recherche de la barre des tâches et sélectionnez **Credential Manager (Gestionnaire d'informations d'identification)**.
1. Sélectionnez **Windows Credentials (Informations d'identification)** pour gérer les informations d'identification Windows.
1. Sélectionnez **Add a generic credential (Ajouter une information d'identification générique)** et remplissez les détails comme suit :
+ Dans **Internet ou Network Address (Adresse Internet ou réseau)**, entrez le nom de la cible en tant que `cloudhsm_client`.
+ Dans **Username (Nom d'utilisateur)** et **Password (Mot de passe)** entrez les informations d'identification CU.
+ Cliquez sur **OK**.
## Variables d'environnement du système
Vous pouvez définir des variables d'environnement système qui identifient un HSM et un [utilisateur de chiffrement](understanding-users-cmu.md#crypto-user-cmu) (CU) pour votre application Windows. Vous pouvez utiliser la [commande **setx**](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx) pour définir des variables d'environnement système temporaires ou pour définir des variables d'environnement système permanentes [par programmation](https://msdn.microsoft.com/en-us/library/system.environment.setenvironmentvariable(v=vs.110).aspx) ou sous l'onglet **Avancé** du Panneau de configuration **Propriétés système** de Windows.
**Avertissement**
Lorsque vous définissez des informations d'identification via des variables d'environnement système, le mot de passe est disponible en texte brut sur le système d'un utilisateur. Pour résoudre ce problème, utilisez le Gestionnaire d'informations d'identification Windows.
Définissez les variables d'environnement système suivantes :
**`n3fips_password=:`**
Identifie un [utilisateur de chiffrement](understanding-users-cmu.md#crypto-user-cmu) (CU) dans le HSM et fournit toutes les informations de connexion requises. Votre application s'authentifie et s'exécute en tant que ce CU. L'application possède les autorisations de ce CU et peut afficher et gérer uniquement les clés que le CU possède et partage. Pour créer un CU, utilisez [createUser](cloudhsm_mgmt_util-createUser.md). Pour rechercher les fichiers existants CUs, utilisez [ListUsers](cloudhsm_mgmt_util-listUsers.md).
Par exemple :
```
setx /m n3fips_password test_user:password123
```
# Associer une AWS CloudHSM clé à un certificat
Avant de pouvoir utiliser des AWS CloudHSM clés avec des outils tiers, tels que ceux de Microsoft [SignTool](https://docs.microsoft.com/en-us/windows/win32/seccrypto/signtool), vous devez importer les métadonnées de la clé dans le magasin de certificats local et associer les métadonnées à un certificat. Pour importer les métadonnées de la clé, utilisez l'utilitaire import\$1key.exe qui est inclus dans CloudHSM version 3.0 et supérieure. Les étapes suivantes fournissent des informations supplémentaires et un exemple de sortie.
## Étape 1 : Importer votre certificat
Sous Windows, vous pouvez normalement double-cliquer sur le certificat pour l'importer dans votre magasin de certificats local.
Toutefois, si un double-clic ne fonctionne pas, utilisez l'[outil Microsoft Certreq](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn296456%28v%3dws.11%29) pour importer le certificat dans le gestionnaire de certificats. Par exemple :
```
certreq -accept
```
Si cette action échoue et que vous recevez l'erreur `Key not found`, passez à l'étape 2. Si le certificat apparaît dans votre magasin de clés, vous avez terminé la tâche et aucune autre action n'est nécessaire.
## Étape 2 : Recueillir des renseignements permettant d'identifier les certificats
Si l'étape précédente n'a pas réussi, vous devrez associer votre clé privée à un certificat. Toutefois, avant de pouvoir créer l'association, vous devez d'abord trouver le nom de conteneur unique et le numéro de série du certificat. Utilisez un utilitaire, tel que**certutil**, pour afficher les informations de certificat requises. L'exemple de sortie suivant **certutil** indique le nom du conteneur et le numéro de série.
```
================ Certificate 1 ================ Serial Number:
72000000047f7f7a9d41851b4e000000000004Issuer: CN=Enterprise-CANotBefore: 10/8/2019 11:50
AM NotAfter: 11/8/2020 12:00 PMSubject: CN=www.example.com, OU=Certificate Management,
O=Information Technology, L=Seattle, S=Washington, C=USNon-root CertificateCert
Hash(sha1): 7f d8 5c 00 27 bf 37 74 3d 71 5b 54 4e c0 94 20 45 75 bc 65No key provider
information Simple container name: CertReq-39c04db0-6aa9-4310-93db-db0d9669f42c Unique
container name: CertReq-39c04db0-6aa9-4310-93db-db0d9669f42c
```
## Étape 3 : associer la clé AWS CloudHSM privée au certificat
Pour associer la clé au certificat, assurez-vous d'abord de [démarrer le daemon AWS CloudHSM client](key_mgmt_util-setup.md#key_mgmt_util-start-cloudhsm-client). Ensuite, utilisez import\$1key.exe (qui est inclus dans CloudHSM version 3.0 et supérieure) pour associer la clé privée au certificat. Lorsque vous spécifiez le certificat, utilisez son nom de conteneur simple. L'exemple suivant montre la commande et la réponse. Cette action copie uniquement les métadonnées de la clé ; la clé reste sur le HSM.
```
$> import_key.exe –RSA CertReq-39c04db0-6aa9-4310-93db-db0d9669f42c
Successfully opened Microsoft Software Key Storage Provider : 0NCryptOpenKey failed : 80090016
```
## Étape 4 : Mettre à jour le magasin de certificats
Assurez-vous que le démon AWS CloudHSM client est toujours en cours d'exécution. Utilisez ensuite le **certutil** verbe**-repairstore**, pour mettre à jour le numéro de série du certificat. L'exemple suivant montre la commande et la sortie. Consultez la documentation Microsoft pour plus d'informations sur le [**-repairstore**verbe](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/cc732443(v=ws.11)?redirectedfrom=MSDN#-repairstore).
```
C:\Program Files\Amazon\CloudHSM>certutil -f -csp "Cavium Key Storage Provider"-repairstore my "72000000047f7f7a9d41851b4e000000000004"
my "Personal"
================ Certificate 1 ================
Serial Number: 72000000047f7f7a9d41851b4e000000000004
Issuer: CN=Enterprise-CA
NotBefore: 10/8/2019 11:50 AM
NotAfter: 11/8/2020 12:00 PM
Subject: CN=www.example.com, OU=Certificate Management, O=Information Technology, L=Seattle, S=Washington, C=US
Non-root CertificateCert Hash(sha1): 7f d8 5c 00 27 bf 37 74 3d 71 5b 54 4e c0 94 20 45 75 bc 65
SDK Version: 3.0
Key Container = CertReq-39c04db0-6aa9-4310-93db-db0d9669f42c
Provider = "Cavium Key Storage Provider"
Private key is NOT exportableEncryption test passedCertUtil: -repairstore command completed successfully.
```
Après avoir mis à jour le numéro de série du certificat, vous pouvez utiliser ce certificat et la clé AWS CloudHSM privée correspondante avec n'importe quel outil de signature tiers sous Windows.
# Exemple de code pour le fournisseur de GNC pour AWS CloudHSM
****
\$1\$1 Exemple de code uniquement — Non destiné à une utilisation en production \$1\$1
Cet exemple de code est donné uniquement à titre d'illustration. N'exécutez pas ce code dans un environnement de production.
L'exemple suivant montre comment énumérer les fournisseurs de chiffrement enregistrés dans votre système pour trouver le fournisseur CNG installé avec le client CloudHSM pour Windows. L'exemple montre également comment créer une paire de clés asymétrique et comment utiliser la paire de clés pour vous signer les données.
**Important**
Avant d'exécuter cet exemple, vous devez configurer les informations d'identification HSM comme expliqué dans les prérequis. Pour en savoir plus, consultez [Conditions préalables à l'utilisation du client AWS CloudHSM Windows](ksp-library-prereq.md).
```
// CloudHsmCngExampleConsole.cpp : Console application that demonstrates CNG capabilities.
// This example contains the following functions.
//
// VerifyProvider() - Enumerate the registered providers and retrieve Cavium KSP and CNG providers.
// GenerateKeyPair() - Create an RSA key pair.
// SignData() - Sign and verify data.
//
#include "stdafx.h"
#include
#ifndef NT_SUCCESS
#define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)
#endif
#define CAVIUM_CNG_PROVIDER L"Cavium CNG Provider"
#define CAVIUM_KEYSTORE_PROVIDER L"Cavium Key Storage Provider"
// Enumerate the registered providers and determine whether the Cavium CNG provider
// and the Cavium KSP provider exist.
//
bool VerifyProvider()
{
NTSTATUS status;
ULONG cbBuffer = 0;
PCRYPT_PROVIDERS pBuffer = NULL;
bool foundCng = false;
bool foundKeystore = false;
// Retrieve information about the registered providers.
// cbBuffer - the size, in bytes, of the buffer pointed to by pBuffer.
// pBuffer - pointer to a buffer that contains a CRYPT_PROVIDERS structure.
status = BCryptEnumRegisteredProviders(&cbBuffer, &pBuffer);
// If registered providers exist, enumerate them and determine whether the
// Cavium CNG provider and Cavium KSP provider have been registered.
if (NT_SUCCESS(status))
{
if (pBuffer != NULL)
{
for (ULONG i = 0; i < pBuffer->cProviders; i++)
{
// Determine whether the Cavium CNG provider exists.
if (wcscmp(CAVIUM_CNG_PROVIDER, pBuffer->rgpszProviders[i]) == 0)
{
printf("Found %S\n", CAVIUM_CNG_PROVIDER);
foundCng = true;
}
// Determine whether the Cavium KSP provider exists.
else if (wcscmp(CAVIUM_KEYSTORE_PROVIDER, pBuffer->rgpszProviders[i]) == 0)
{
printf("Found %S\n", CAVIUM_KEYSTORE_PROVIDER);
foundKeystore = true;
}
}
}
}
else
{
printf("BCryptEnumRegisteredProviders failed with error code 0x%08x\n", status);
}
// Free memory allocated for the CRYPT_PROVIDERS structure.
if (NULL != pBuffer)
{
BCryptFreeBuffer(pBuffer);
}
return foundCng == foundKeystore == true;
}
// Generate an asymmetric key pair. As used here, this example generates an RSA key pair
// and returns a handle. The handle is used in subsequent operations that use the key pair.
// The key material is not available.
//
// The key pair is used in the SignData function.
//
NTSTATUS GenerateKeyPair(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_KEY_HANDLE *hKey)
{
NTSTATUS status;
// Generate the key pair.
status = BCryptGenerateKeyPair(hAlgorithm, hKey, 2048, 0);
if (!NT_SUCCESS(status))
{
printf("BCryptGenerateKeyPair failed with code 0x%08x\n", status);
return status;
}
// Finalize the key pair. The public/private key pair cannot be used until this
// function is called.
status = BCryptFinalizeKeyPair(*hKey, 0);
if (!NT_SUCCESS(status))
{
printf("BCryptFinalizeKeyPair failed with code 0x%08x\n", status);
return status;
}
return status;
}
// Sign and verify data using the RSA key pair. The data in this function is hardcoded
// and is for example purposes only.
//
NTSTATUS SignData(BCRYPT_KEY_HANDLE hKey)
{
NTSTATUS status;
PBYTE sig;
ULONG sigLen;
ULONG resLen;
BCRYPT_PKCS1_PADDING_INFO pInfo;
// Hardcode the data to be signed (for demonstration purposes only).
PBYTE message = (PBYTE)"d83e7716bed8a20343d8dc6845e57447";
ULONG messageLen = strlen((char*)message);
// Retrieve the size of the buffer needed for the signature.
status = BCryptSignHash(hKey, NULL, message, messageLen, NULL, 0, &sigLen, 0);
if (!NT_SUCCESS(status))
{
printf("BCryptSignHash failed with code 0x%08x\n", status);
return status;
}
// Allocate a buffer for the signature.
sig = (PBYTE)HeapAlloc(GetProcessHeap(), 0, sigLen);
if (sig == NULL)
{
return -1;
}
// Use the SHA256 algorithm to create padding information.
pInfo.pszAlgId = BCRYPT_SHA256_ALGORITHM;
// Create a signature.
status = BCryptSignHash(hKey, &pInfo, message, messageLen, sig, sigLen, &resLen, BCRYPT_PAD_PKCS1);
if (!NT_SUCCESS(status))
{
printf("BCryptSignHash failed with code 0x%08x\n", status);
return status;
}
// Verify the signature.
status = BCryptVerifySignature(hKey, &pInfo, message, messageLen, sig, sigLen, BCRYPT_PAD_PKCS1);
if (!NT_SUCCESS(status))
{
printf("BCryptVerifySignature failed with code 0x%08x\n", status);
return status;
}
// Free the memory allocated for the signature.
if (sig != NULL)
{
HeapFree(GetProcessHeap(), 0, sig);
sig = NULL;
}
return 0;
}
// Main function.
//
int main()
{
NTSTATUS status;
BCRYPT_ALG_HANDLE hRsaAlg;
BCRYPT_KEY_HANDLE hKey = NULL;
// Enumerate the registered providers.
printf("Searching for Cavium providers...\n");
if (VerifyProvider() == false) {
printf("Could not find the CNG and Keystore providers\n");
return 1;
}
// Get the RSA algorithm provider from the Cavium CNG provider.
printf("Opening RSA algorithm\n");
status = BCryptOpenAlgorithmProvider(&hRsaAlg, BCRYPT_RSA_ALGORITHM, CAVIUM_CNG_PROVIDER, 0);
if (!NT_SUCCESS(status))
{
printf("BCryptOpenAlgorithmProvider RSA failed with code 0x%08x\n", status);
return status;
}
// Generate an asymmetric key pair using the RSA algorithm.
printf("Generating RSA Keypair\n");
GenerateKeyPair(hRsaAlg, &hKey);
if (hKey == NULL)
{
printf("Invalid key handle returned\n");
return 0;
}
printf("Done!\n");
// Sign and verify [hardcoded] data using the RSA key pair.
printf("Sign/Verify data with key\n");
SignData(hKey);
printf("Done!\n");
// Remove the key handle from memory.
status = BCryptDestroyKey(hKey);
if (!NT_SUCCESS(status))
{
printf("BCryptDestroyKey failed with code 0x%08x\n", status);
return status;
}
// Close the RSA algorithm provider.
status = BCryptCloseAlgorithmProvider(hRsaAlg, NULL);
if (!NT_SUCCESS(status))
{
printf("BCryptCloseAlgorithmProvider RSA failed with code 0x%08x\n", status);
return status;
}
return 0;
}
```