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. # 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)