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.
# AWS KMS exemples utilisant AWS CLI
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l'aide du AWS Command Line Interface with AWS KMS.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Actions](#actions)
## Actions
### `cancel-key-deletion`
L'exemple de code suivant montre comment utiliser`cancel-key-deletion`.
**AWS CLI**
**Pour annuler la suppression planifiée d’une clé KMS gérée par le client**
L’exemple `cancel-key-deletion` suivant annule la suppression planifiée d’une clé KMS gérée par le client.
```
aws kms cancel-key-deletion \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"KeyId": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}
```
Lorsque la commande `cancel-key-deletion` aboutit, la suppression planifiée est annulée. Toutefois, l’état de la clé KMS est `Disabled`, de sorte que vous ne pouvez pas utiliser la clé KMS dans des opérations de chiffrement. Pour restaurer ses fonctionnalités, utilisez la commande `enable-key`.
Pour plus d’informations, consultez [Planification et annulation d’une suppression de clé](https://docs.aws.amazon.com/kms/latest/developerguide/deleting-keys.html#deleting-keys-scheduling-key-deletion) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [CancelKeyDeletion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/cancel-key-deletion.html)à la section *Référence des AWS CLI commandes*.
### `connect-custom-key-store`
L'exemple de code suivant montre comment utiliser`connect-custom-key-store`.
**AWS CLI**
**Pour connecter un magasin de clés personnalisé**
L’exemple `connect-custom-key-store` suivant reconnecte le magasin de clés personnalisé spécifié. Vous pouvez utiliser une commande comme celle-ci pour connecter un magasin de clés personnalisé pour la première fois ou pour reconnecter un magasin de clés qui a été déconnecté.
Vous pouvez utiliser cette commande pour connecter un magasin de clés AWS CloudHSM ou un magasin de clés externe.
```
aws kms connect-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0
```
Cette commande ne renvoie aucune sortie. Pour vérifier que la commande est efficace, utilisez la commande `describe-custom-key-stores`.
*Pour plus d'informations sur la connexion d'un magasin de clés AWS CloudHSM, [consultez la section Connexion et déconnexion d'un magasin de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés](https://docs.aws.amazon.com/kms/latest/developerguide/disconnect-keystore.html).AWS *
Pour plus d’informations sur la connexion d’un magasin de clés externe, consultez [Connecting and disconnecting an external key store](https://docs.aws.amazon.com/kms/latest/developerguide/xks-connect-disconnect.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [ConnectCustomKeyStore](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/connect-custom-key-store.html)à la section *Référence des AWS CLI commandes*.
### `create-alias`
L'exemple de code suivant montre comment utiliser`create-alias`.
**AWS CLI**
**Pour créer un alias de clé KMS**
La commande `create-alias` suivante crée un alias nommé `example-alias` pour la clé KMS identifiée par son ID de clé `1234abcd-12ab-34cd-56ef-1234567890ab`.
Les noms d’alias doivent commencer par `alias/`. N'utilisez pas de noms d'alias commençant par `alias/aws` ; ils sont réservés à l'usage de AWS.
```
aws kms create-alias \
--alias-name alias/example-alias \
--target-key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Cette commande ne renvoie aucune sortie. Pour voir le nouvel alias, utilisez la commande `list-aliases`.
Pour plus d’informations, consultez [Utilisation des alias](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [CreateAlias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/create-alias.html)à la section *Référence des AWS CLI commandes*.
### `create-custom-key-store`
L'exemple de code suivant montre comment utiliser`create-custom-key-store`.
**AWS CLI**
**Exemple 1 : pour créer un magasin de AWS clés CloudHSM**
L'`create-custom-key-store`exemple suivant crée un magasin de clés AWS CloudHSM soutenu par un cluster AWS CloudHSM à l'aide des paramètres requis. Vous pouvez également ajouter `custom-key-store-type``parameter with the default value: ``AWS_CLOUDHSM`.
Pour spécifier l'entrée de fichier pour la `trust-anchor-certificate` commande dans la AWS CLI, le `file://` préfixe est obligatoire.
```
aws kms create-custom-key-store \
--custom-key-store-name ExampleCloudHSMKeyStore \
--cloud-hsm-cluster-id cluster-1a23b4cdefg \
--key-store-password kmsPswd \
--trust-anchor-certificate file://customerCA.crt
```
Sortie :
```
{
"CustomKeyStoreId": cks-1234567890abcdef0
}
```
Pour plus d'informations, consultez la section [Création d'un magasin de clés AWS CloudHSM](https://docs.aws.amazon.com/kms/latest/developerguide/create-keystore.html) dans *AWS le Guide du développeur du service de gestion des clés*.
**Exemple 2 : pour créer un magasin de clés externe avec une connectivité au point de terminaison public**
L'`create-custom-key-store`exemple suivant crée un magasin de clés externe (XKS) qui communique avec AWS KMS via Internet.
Dans cet exemple, `XksProxyUriPath` utilise le préfixe facultatif de `example-prefix`.
REMARQUE : Si vous utilisez la version 1.0 de la AWS CLI, exécutez la commande suivante avant de spécifier un paramètre avec une valeur HTTP ou HTTPS, tel que le XksProxyUriEndpoint paramètre.
```
aws configure set cli_follow_urlparam false
```
Sinon, la version 1.0 de la AWS CLI remplace la valeur du paramètre par le contenu trouvé à cette adresse URI.
```
aws kms create-custom-key-store \
--custom-key-store-name ExamplePublicEndpointXKS \
--custom-key-store-type EXTERNAL_KEY_STORE \
--xks-proxy-connectivity PUBLIC_ENDPOINT \
--xks-proxy-uri-endpoint "https://myproxy.xks.example.com" \
--xks-proxy-uri-path "/example-prefix/kms/xks/v1" \
--xks-proxy-authentication-credential "AccessKeyId=ABCDE12345670EXAMPLE, RawSecretAccessKey=DXjSUawnel2fr6SKC7G25CNxTyWKE5PF9XX6H/u9pSo="
```
Sortie :
```
{
"CustomKeyStoreId": cks-2234567890abcdef0
}
```
Pour plus d’informations, consultez [Création d’un magasin de clés externe](https://docs.aws.amazon.com/kms/latest/developerguide/create-keystorecreate-xks-keystore.html) dans le *Manuel du développeur AWS Key Management Service*.
**Exemple 3 : pour créer un magasin de clés externe avec une connectivité au service de point de terminaison d’un VPC**
L'`create-custom-key-store`exemple suivant crée un magasin de clés externe (XKS) qui utilise un service de point de terminaison Amazon VPC pour communiquer avec AWS KMS.
REMARQUE : Si vous utilisez la version 1.0 de la AWS CLI, exécutez la commande suivante avant de spécifier un paramètre avec une valeur HTTP ou HTTPS, tel que le XksProxyUriEndpoint paramètre.
```
aws configure set cli_follow_urlparam false
```
Sinon, la version 1.0 de la AWS CLI remplace la valeur du paramètre par le contenu trouvé à cette adresse URI.
```
aws kms create-custom-key-store \
--custom-key-store-name ExampleVPCEndpointXKS \
--custom-key-store-type EXTERNAL_KEY_STORE \
--xks-proxy-connectivity VPC_ENDPOINT_SERVICE \
--xks-proxy-uri-endpoint "https://myproxy-private.xks.example.com" \
--xks-proxy-uri-path "/kms/xks/v1" \
--xks-proxy-vpc-endpoint-service-name "com.amazonaws.vpce.us-east-1.vpce-svc-example1" \
--xks-proxy-authentication-credential "AccessKeyId=ABCDE12345670EXAMPLE, RawSecretAccessKey=DXjSUawnel2fr6SKC7G25CNxTyWKE5PF9XX6H/u9pSo="
```
Sortie :
```
{
"CustomKeyStoreId": cks-3234567890abcdef0
}
```
Pour plus d’informations, consultez [Création d’un magasin de clés externe](https://docs.aws.amazon.com/kms/latest/developerguide/create-keystorecreate-xks-keystore.html) dans le *Manuel du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [CreateCustomKeyStore](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/create-custom-key-store.html)à la section *Référence des AWS CLI commandes*.
### `create-grant`
L'exemple de code suivant montre comment utiliser`create-grant`.
**AWS CLI**
**Pour créer un octroi**
L’exemple `create-grant` suivant crée un octroi qui permet à l’utilisateur `exampleUser` d’utiliser la commande `decrypt` sur l’exemple `1234abcd-12ab-34cd-56ef-1234567890ab` de clé KMS. Le principal mis hors service est le rôle `adminRole`. L’octroi utilise la contrainte d’octroi `EncryptionContextSubset` pour accorder cette autorisation uniquement lorsque le contexte de chiffrement de la demande `decrypt` inclut une paire clé-valeur `"Department": "IT"`.
```
aws kms create-grant \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--grantee-principal arn:aws:iam::123456789012:user/exampleUser \
--operations Decrypt \
--constraints EncryptionContextSubset={Department=IT} \
--retiring-principal arn:aws:iam::123456789012:role/adminRole
```
Sortie :
```
{
"GrantId": "1a2b3c4d2f5e69f440bae30eaec9570bb1fb7358824f9ddfa1aa5a0dab1a59b2",
"GrantToken": ""
}
```
Pour afficher des informations détaillées sur l’octroi, utilisez la commande `list-grants`.
Pour plus d'informations, consultez la section [Subventions dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) dans le *Guide du développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [CreateGrant](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/create-grant.html)à la section *Référence des AWS CLI commandes*.
### `create-key`
L'exemple de code suivant montre comment utiliser`create-key`.
**AWS CLI**
**Exemple 1 : pour créer une clé KMS gérée par le client dans AWS KMS**
L’exemple `create-key` suivant crée une clé KMS de chiffrement symétrique.
Pour créer la clé KMS de base, une clé de chiffrement symétrique, il n’est pas nécessaire de spécifier de paramètres. Les valeurs par défaut de ces paramètres créent une clé de chiffrement symétrique.
Comme cette commande ne spécifie pas de stratégie de clé, la clé KMS obtient la [stratégie de clé par défaut](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default) pour les clés KMS créées par programmation. Pour afficher la stratégie de clé, utilisez la commande `get-key-policy`. Pour modifier la stratégie de clé, utilisez la commande `put-key-policy`.
```
aws kms create-key
```
La commande `create-key` renvoie les métadonnées de clé, y compris l’ID de clé et l’ARN de la nouvelle clé KMS. Vous pouvez utiliser ces valeurs pour identifier la clé KMS dans d'autres opérations AWS KMS. La sortie n’inclut pas les balises. Pour afficher les balises d’une clé KMS, utilisez `list-resource-tags command`.
Sortie :
```
{
"KeyMetadata": {
"AWSAccountId": "111122223333",
"Arn": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"CreationDate": "2017-07-05T14:04:55-07:00",
"CurrentKeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"Description": "",
"Enabled": true,
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "AWS_KMS"
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
]
}
}
```
Remarque : la commande `create-key` ne vous permet pas de spécifier un alias. Pour créer un alias pour la nouvelle clé KMS, utilisez la commande `create-alias`.
Pour plus d’informations, consultez [Création de clés](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) dans le *Guide du développeur AWS Key Management Service*.
**Exemple 2 : pour créer une clé KMS RSA asymétrique pour le chiffrement et le déchiffrement**
L’exemple `create-key` suivant crée une clé KMS contenant une paire de clés RSA asymétrique pour le chiffrement et le déchiffrement. La spécification de clé et l’utilisation des clés ne peuvent pas être modifiées une fois que la clé est créée :
```
aws kms create-key \
--key-spec RSA_4096 \
--key-usage ENCRYPT_DECRYPT
```
Sortie :
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2021-04-05T14:04:55-07:00",
"CustomerMasterKeySpec": "RSA_4096",
"Description": "",
"Enabled": true,
"EncryptionAlgorithms": [
"RSAES_OAEP_SHA_1",
"RSAES_OAEP_SHA_256"
],
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "RSA_4096",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "AWS_KMS"
}
}
```
Pour plus d'informations, consultez la section [Clés asymétriques dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) dans le *Guide du développeur du service de gestion des AWS clés*.
**Exemple 3 : pour créer une clé KMS de courbe elliptique asymétrique pour la signature et la vérification**
Pour créer une clé KMS asymétrique contenant une paire de clés de courbe elliptique asymétrique (ECC) pour la signature et la vérification. Le paramètre `--key-usage` est obligatoire même si `SIGN_VERIFY` est la seule valeur valide pour les clés KMS ECC. La spécification de clé et l’utilisation des clés ne peuvent pas être modifiées une fois que la clé est créée :
```
aws kms create-key \
--key-spec ECC_NIST_P521 \
--key-usage SIGN_VERIFY
```
Sortie :
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2019-12-02T07:48:55-07:00",
"CustomerMasterKeySpec": "ECC_NIST_P521",
"Description": "",
"Enabled": true,
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "ECC_NIST_P521",
"KeyState": "Enabled",
"KeyUsage": "SIGN_VERIFY",
"MultiRegion": false,
"Origin": "AWS_KMS",
"SigningAlgorithms": [
"ECDSA_SHA_512"
]
}
}
```
Pour plus d'informations, consultez la section [Clés asymétriques dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) dans le *Guide du développeur du service de gestion des AWS clés*.
**Exemple 4 : pour créer une clé KMS ML-DSA asymétrique pour la signature et la vérification**
Cet exemple crée une clé ML-DSA (Module-Lattice Digital Signature Algorithm) pour la signature et la vérification. Le paramètre « utilisation de clé » est obligatoire même si `SIGN_VERIFY` est la seule valeur valide pour les clés ML-DSA.
```
aws kms create-key \
--key-spec ML_DSA_65 \
--key-usage SIGN_VERIFY
```
Sortie :
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2019-12-02T07:48:55-07:00",
"Description": "",
"Enabled": true,
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "ML_DSA_65",
"KeyState": "Enabled",
"KeyUsage": "SIGN_VERIFY",
"MultiRegion": false,
"Origin": "AWS_KMS",
"SigningAlgorithms": [
"ML_DSA_SHAKE_256"
]
}
}
```
Pour plus d'informations, consultez la section [Clés asymétriques dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) dans le *Guide du développeur du service de gestion des AWS clés*.
**Exemple 5 : pour créer une clé KMS HMAC**
L’exemple `create-key` suivant crée une clé KMS HMAC de 384 bits. La valeur `GENERATE_VERIFY_MAC` du paramètre `--key-usage` est obligatoire même s’il s’agit de la seule valeur valide pour les clés KMS HMAC.
```
aws kms create-key \
--key-spec HMAC_384 \
--key-usage GENERATE_VERIFY_MAC
```
Sortie :
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2022-04-05T14:04:55-07:00",
"CustomerMasterKeySpec": "HMAC_384",
"Description": "",
"Enabled": true,
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "HMAC_384",
"KeyState": "Enabled",
"KeyUsage": "GENERATE_VERIFY_MAC",
"MacAlgorithms": [
"HMAC_SHA_384"
],
"MultiRegion": false,
"Origin": "AWS_KMS"
}
}
```
Pour plus d'informations, consultez la section [Clés HMAC dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/hmac.html) dans le *Guide du développeur du service de gestion des AWS clés*.
**Exemple 6 : pour créer une clé KMS primaire multi-région**
L’exemple `create-key` suivant crée une clé de chiffrement symétrique primaire multi-région. Étant donné que les valeurs par défaut de tous les paramètres créent une clé de chiffrement symétrique, seul le paramètre `--multi-region` est requis pour cette clé KMS. Dans la AWS CLI, pour indiquer qu'un paramètre booléen est vrai, il suffit de spécifier le nom du paramètre.
```
aws kms create-key \
--multi-region
```
Sortie :
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef12345678990ab",
"AWSAccountId": "111122223333",
"CreationDate": "2021-09-02T016:15:21-09:00",
"CurrentKeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"Description": "",
"Enabled": true,
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
],
"KeyId": "mrk-1234abcd12ab34cd56ef12345678990ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": true,
"MultiRegionConfiguration": {
"MultiRegionKeyType": "PRIMARY",
"PrimaryKey": {
"Arn": "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef12345678990ab",
"Region": "us-west-2"
},
"ReplicaKeys": []
},
"Origin": "AWS_KMS"
}
}
```
Pour plus d'informations, consultez la section [Clés asymétriques dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) dans le *Guide du développeur du service de gestion des AWS clés*.
**Exemple 7 : pour créer une clé KMS pour les éléments de clé importés**
L’exemple `create-key` suivant crée une clé KMS sans élément de clé. Lorsque l’opération est terminée, vous pouvez importer vos propres éléments de clé dans la clé KMS. Pour créer cette clé KMS, définissez le paramètre `--origin` sur `EXTERNAL`.
```
aws kms create-key \
--origin EXTERNAL
```
Sortie :
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2019-12-02T07:48:55-07:00",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"Description": "",
"Enabled": false,
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
],
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "PendingImport",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "EXTERNAL"
}
}
```
Pour plus d'informations, consultez la section [Importation de matériel clé dans les clés AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html) dans le *guide du développeur du service de gestion des AWS clés*.
**Exemple 6 : pour créer une clé KMS dans un magasin de clés AWS CloudHSM**
L'`create-key`exemple suivant crée une clé KMS dans le magasin de clés AWS CloudHSM spécifié. L'opération crée la clé KMS et ses métadonnées dans AWS KMS et crée le matériel clé dans le cluster AWS CloudHSM associé au magasin de clés personnalisé. Les paramètres `--custom-key-store-id` et `--origin` sont obligatoires.
```
aws kms create-key \
--origin AWS_CLOUDHSM \
--custom-key-store-id cks-1234567890abcdef0
```
Sortie :
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CloudHsmClusterId": "cluster-1a23b4cdefg",
"CreationDate": "2019-12-02T07:48:55-07:00",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"CustomKeyStoreId": "cks-1234567890abcdef0",
"Description": "",
"Enabled": true,
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
],
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "AWS_CLOUDHSM"
}
}
```
Pour plus d’informations, consultez [AWS CloudHSM key stores](https://docs.aws.amazon.com/kms/latest/developerguide/keystore-cloudhsm.html) dans le *Guide du développeur AWS Key Management Service*.
**Exemple 8 : pour créer une clé KMS dans un magasin de clés externe**
L’exemple `create-key` suivant crée une clé KMS dans le magasin de clés externe spécifié. Les paramètres `--custom-key-store-id`, `--origin` et `--xks-key-id` sont obligatoires dans cette commande.
Le paramètre `--xks-key-id` indique l’ID d’une clé de chiffrement symétrique existante dans votre gestionnaire de clés externe. Cette clé sert d’élément de clés externe pour la clé KMS. La valeur du paramètre `--origin` doit être `EXTERNAL_KEY_STORE`. Le paramètre `custom-key-store-id` doit identifier un magasin de clés externe connecté à son proxy de magasin de clés externe.
```
aws kms create-key \
--origin EXTERNAL_KEY_STORE \
--custom-key-store-id cks-9876543210fedcba9 \
--xks-key-id bb8562717f809024
```
Sortie :
```
{
"KeyMetadata": {
"Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"AWSAccountId": "111122223333",
"CreationDate": "2022-12-02T07:48:55-07:00",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"CustomKeyStoreId": "cks-9876543210fedcba9",
"Description": "",
"Enabled": true,
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
],
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyManager": "CUSTOMER",
"KeySpec": "SYMMETRIC_DEFAULT",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"MultiRegion": false,
"Origin": "EXTERNAL_KEY_STORE",
"XksKeyConfiguration": {
"Id": "bb8562717f809024"
}
}
}
```
Pour plus d’informations, consultez [Magasins de clés externes](https://docs.aws.amazon.com/kms/latest/developerguide/keystore-external.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [CreateKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/create-key.html)à la section *Référence des AWS CLI commandes*.
### `decrypt`
L'exemple de code suivant montre comment utiliser`decrypt`.
**AWS CLI**
**Exemple 1 : pour déchiffrer un message chiffré avec une clé KMS symétrique (Linux et macOS)**
L'exemple de `decrypt` commande suivant illustre la méthode recommandée pour déchiffrer des données à l'aide de la AWS CLI. Cette version montre comment déchiffrer des données sous une clé KMS symétrique.
Fournissez le texte chiffré dans un fichier. Dans la valeur du paramètre `--ciphertext-blob`, utilisez le préfixe `fileb://`, qui indique à l’interface de ligne de commande (CLI) de lire les données d’un fichier binaire. Si le fichier ne se trouve pas dans le répertoire actuel, saisissez le chemin complet du fichier. Pour plus d'informations sur la lecture des valeurs des paramètres de la AWS CLI depuis un fichier, consultez la section Chargement des paramètres de la AWS CLI depuis un fichier < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> dans le *guide de l'utilisateur de l'interface de ligne de AWS commande* et les meilleures pratiques pour les paramètres de fichiers locaux < https://aws.amazon.com/blogs/ developer/ best-practices-for-local -file-parameters/> dans le *blog des outils de ligne de AWS commande*. Spécifiez la clé KMS pour déchiffrer le texte chiffré. Le paramètre n'est pas obligatoire lors du déchiffrement avec une clé KMS symétrique. `--key-id` AWS KMS peut obtenir l'ID de la clé KMS qui a été utilisée pour chiffrer les données à partir des métadonnées du texte chiffré. Toutefois, la spécification de la clé KMS que vous utilisez est une bonne pratique. Cette pratique garantit que vous utilisez la clé KMS prévue et vous évite de déchiffrer par inadvertance un texte chiffré à l’aide d’une clé KMS à laquelle vous ne faites pas confiance. Demandez la sortie en texte brut sous forme de texte. Le paramètre `--query` indique à l’interface de ligne de commande (CLI) d’obtenir uniquement la valeur du champ `Plaintext` à partir de la sortie. Le paramètre `--output` renvoie la sortie sous forme de texte. Base64 décode le texte brut et l’enregistre dans un fichier. L’exemple suivant conduit (\$1) la valeur du paramètre `Plaintext` à l’utilitaire Base64, qui la décode. Ensuite, il redirige (>) la sortie décodée vers le fichier `ExamplePlaintext`.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.
```
aws kms decrypt \
--ciphertext-blob fileb://ExampleEncryptedFile \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--output text \
--query Plaintext | base64 \
--decode > ExamplePlaintextFile
```
Cette commande ne produit aucune sortie. La sortie de la commande `decrypt` est décodée en base64 et enregistrée dans un fichier.
Pour plus d’informations, consultez [Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) dans la *Référence des API d’AWS Key Management Service*.
**Exemple 2 : pour déchiffrer un message chiffré avec une clé KMS symétrique (invite de commande Windows)**
L’exemple suivant est identique au précédent, sauf qu’il utilise l’utilitaire `certutil` pour décoder les données en texte brut en Base64. Cette procédure requiert deux commandes, comme indiqué dans les exemples suivants.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.
```
aws kms decrypt ^
--ciphertext-blob fileb://ExampleEncryptedFile ^
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab ^
--output text ^
--query Plaintext > ExamplePlaintextFile.base64
```
Exécutez la commande `certutil`.
```
certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile
```
Sortie :
```
Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.
```
Pour plus d’informations, consultez [Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) dans la *Référence des API d’AWS Key Management Service*.
**Exemple 3 : pour déchiffrer un message chiffré avec une clé KMS asymétrique (Linux et macOS)**
L’exemple de commande `decrypt` suivant montre comment déchiffrer des données chiffrées avec une clé KMS asymétrique RSA.
Lors de l’utilisation d’une clé KMS asymétrique, le paramètre `encryption-algorithm`, qui spécifie l’algorithme utilisé pour chiffrer le texte brut, est obligatoire.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.
```
aws kms decrypt \
--ciphertext-blob fileb://ExampleEncryptedFile \
--key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
--encryption-algorithm RSAES_OAEP_SHA_256 \
--output text \
--query Plaintext | base64 \
--decode > ExamplePlaintextFile
```
Cette commande ne produit aucune sortie. La sortie de la commande `decrypt` est décodée en base64 et enregistrée dans un fichier.
Pour plus d'informations, consultez la section [Clés asymétriques dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) dans le *Guide du développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l’API, consultez [Decrypt](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/decrypt.html) dans la *Référence des commandes de l’AWS CLI *.
### `delete-alias`
L'exemple de code suivant montre comment utiliser`delete-alias`.
**AWS CLI**
**Pour supprimer un alias AWS KMS**
L’exemple `delete-alias` suivant supprime l’alias `alias/example-alias`. Le nom de l’alias doit commencer par alias/.
```
aws kms delete-alias \
--alias-name alias/example-alias
```
Cette commande ne produit aucune sortie. Pour trouver l’alias, utilisez la commande `list-aliases`.
Pour plus d’informations, consultez [Suppression d’un alias](https://docs.aws.amazon.com/kms/latest/developerguide/alias-manage.html#alias-delete) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [DeleteAlias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/delete-alias.html)à la section *Référence des AWS CLI commandes*.
### `delete-custom-key-store`
L'exemple de code suivant montre comment utiliser`delete-custom-key-store`.
**AWS CLI**
**Pour supprimer un magasin de clés personnalisé**
L’exemple `delete-custom-key-store` suivant supprime le magasin de clés personnalisé spécifié.
La suppression d'un magasin de clés AWS CloudHSM n'a aucun effet sur le cluster CloudHSM associé. La suppression d’un magasin de clés externe n’a aucun effet sur le proxy de magasin de clés externe, le gestionnaire de clés externe ou les clés externes associés.
**REMARQUE :** avant de pouvoir supprimer un magasin de clés personnalisé, vous devez planifier la suppression de toutes les clés KMS du magasin de clés personnalisé, puis attendre que ces clés KMS soient supprimées. Ensuite, vous devez déconnecter le magasin de clés personnalisé. Pour obtenir de l'aide pour trouver les clés KMS dans votre magasin de clés personnalisé, consultez la section [Supprimer un magasin de clés AWS CloudHSM (API](https://docs.aws.amazon.com/kms/latest/developerguide/delete-keystore.html#delete-keystore-api)) dans *AWS le guide du développeur du service de gestion des clés*.
```
delete-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0
```
Cette commande ne renvoie aucune sortie. Pour vérifier que le magasin de clés personnalisé a bien été supprimée, utilisez la commande `describe-custom-key-stores`.
*Pour plus d'informations sur la suppression d'une AWS banque de clés CloudHSM, consultez la section [Suppression d'une banque de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés](https://docs.aws.amazon.com/kms/latest/developerguide/delete-keystore.html).AWS *
Pour plus d’informations sur la suppression de magasins de clés externes, consultez [Deleting an external key store](https://docs.aws.amazon.com/kms/latest/developerguide/delete-xks.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [DeleteCustomKeyStore](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/delete-custom-key-store.html)à la section *Référence des AWS CLI commandes*.
### `delete-imported-key-material`
L'exemple de code suivant montre comment utiliser`delete-imported-key-material`.
**AWS CLI**
**Pour supprimer des éléments de clé importés depuis une clé KMS**
L’exemple `delete-imported-key-material` suivant supprime les éléments de clé qui ont été importés dans une clé KMS.
```
aws kms delete-imported-key-material \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
}
```
Pour plus d’informations, consultez [Suppression des éléments de clé importés](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys-delete-key-material.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [DeleteImportedKeyMaterial](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/delete-imported-key-material.html)à la section *Référence des AWS CLI commandes*.
### `derive-shared-secret`
L'exemple de code suivant montre comment utiliser`derive-shared-secret`.
**AWS CLI**
**Pour dériver un secret partagé**
L’exemple `derive-shared-secret` suivant dérive un secret partagé à l’aide d’un algorithme d’accord de clé.
Vous devez utiliser une paire de clés KMS asymétrique recommandée par le NIST (ECC) ou (régions de SM2 Chine uniquement) avec une `KeyUsage` valeur de to call. `KEY_AGREEMENT` DeriveSharedSecret
```
aws kms derive-shared-secret \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--key-agreement-algorithm ECDH \
--public-key "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvH3Yj0wbkLEpUl95Cv1cJVjsVNSjwGq3tCLnzXfhVwVvmzGN8pYj3U8nKwgouaHbBWNJYjP5VutbbkKS4Kv4GojwZBJyHN17kmxo8yTjRmjR15SKIQ8cqRA2uaERMLnpztIXdZp232PQPbWGxDyXYJ0aJ5EFSag"
```
Sortie :
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"SharedSecret": "MEYCIQCKZLWyTk5runarx6XiAkU9gv3lbwPO/pHa+DXFehzdDwIhANwpsIV2g/9SPWLLsF6p/hiSskuIXMTRwqrMdVKWTMHG",
"KeyAgreementAlgorithm": "ECDH",
"KeyOrigin": "AWS_KMS"
}
```
Pour plus d'informations, consultez la *référence [DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html)de l'API du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [DeriveSharedSecret](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/derive-shared-secret.html)à la section *Référence des AWS CLI commandes*.
### `describe-custom-key-stores`
L'exemple de code suivant montre comment utiliser`describe-custom-key-stores`.
**AWS CLI**
**Exemple 1 : pour obtenir des informations sur un magasin de AWS clés CloudHSM**
L'`describe-custom-key-store`exemple suivant affiche des détails sur le magasin de clés AWS CloudHSM spécifié. La commande est la même pour tous les types de magasins de clés personnalisés, mais le résultat diffère selon le type de magasin de clés et, pour un magasin de clés externe, son option de connectivité.
Par défaut, cette commande affiche des informations sur tous les magasins de clés personnalisés dans le compte et la région. Pour afficher des informations sur un magasin de clés personnalisé en particulier, utilisez le paramètre `custom-key-store-name` ou `custom-key-store-id`.
```
aws kms describe-custom-key-stores \
--custom-key-store-name ExampleCloudHSMKeyStore
```
Le résultat de cette commande inclut des informations utiles sur le magasin de clés AWS CloudHSM, notamment son état de connexion (). `ConnectionState` Si l’état de connexion est `FAILED`, la sortie contient également un champ `ConnectionErrorCode` qui décrit le problème.
Sortie :
```
{
"CustomKeyStores": [
{
"CloudHsmClusterId": "cluster-1a23b4cdefg",
"ConnectionState": "CONNECTED",
"CreationDate": "2022-04-05T14:04:55-07:00",
"CustomKeyStoreId": "cks-1234567890abcdef0",
"CustomKeyStoreName": "ExampleExternalKeyStore",
"TrustAnchorCertificate": ""
}
]
}
```
Pour plus d'informations, consultez la section [Affichage d'un magasin de clés AWS CloudHSM](https://docs.aws.amazon.com/kms/latest/developerguide/view-keystore.html) dans *AWS le Guide du développeur du service de gestion des clés*.
**Exemple 2 : pour obtenir les informations sur un magasin de clés externe avec une connectivité au point de terminaison public**
L’exemple `describe-custom-key-store` suivant affiche des informations sur le magasin de clés externe spécifié. La commande est la même pour tous les types de magasins de clés personnalisés, mais le résultat diffère selon le type de magasin de clés et, pour un magasin de clés externe, son option de connectivité.
Par défaut, cette commande affiche des informations sur tous les magasins de clés personnalisés dans le compte et la région. Pour afficher des informations sur un magasin de clés personnalisé en particulier, utilisez le paramètre `custom-key-store-name` ou `custom-key-store-id`.
```
aws kms describe-custom-key-stores \
--custom-key-store-id cks-9876543210fedcba9
```
Le résultat de cette commande inclut des informations utiles sur le magasin de clés externe, notamment son état de connexion (`ConnectionState`). Si l’état de connexion est `FAILED`, la sortie contient également un champ `ConnectionErrorCode` qui décrit le problème.
Sortie :
```
{
"CustomKeyStores": [
{
"CustomKeyStoreId": "cks-9876543210fedcba9",
"CustomKeyStoreName": "ExampleXKS",
"ConnectionState": "CONNECTED",
"CreationDate": "2022-12-02T07:48:55-07:00",
"CustomKeyStoreType": "EXTERNAL_KEY_STORE",
"XksProxyConfiguration": {
"AccessKeyId": "ABCDE12345670EXAMPLE",
"Connectivity": "PUBLIC_ENDPOINT",
"UriEndpoint": "https://myproxy.xks.example.com",
"UriPath": "/example-prefix/kms/xks/v1"
}
}
]
}
```
Pour plus d’informations, consultez [Affichage d’un magasin de clés externe](https://docs.aws.amazon.com/kms/latest/developerguide/view-xks-keystore.html) dans le *Manuel du développeur AWS Key Management Service*.
**Exemple 3 : pour obtenir les informations sur un magasin de clés externe avec une connectivité au service du point de terminaison d’un VPC**
L’exemple `describe-custom-key-store` suivant affiche des informations sur le magasin de clés externe spécifié. La commande est la même pour tous les types de magasins de clés personnalisés, mais le résultat diffère selon le type de magasin de clés et, pour un magasin de clés externe, son option de connectivité.
Par défaut, cette commande affiche des informations sur tous les magasins de clés personnalisés dans le compte et la région. Pour afficher des informations sur un magasin de clés personnalisé en particulier, utilisez le paramètre `custom-key-store-name` ou `custom-key-store-id`.
```
aws kms describe-custom-key-stores \
--custom-key-store-id cks-2234567890abcdef0
```
Le résultat de cette commande inclut des informations utiles sur le magasin de clés externe, notamment son état de connexion (`ConnectionState`). Si l’état de connexion est `FAILED`, la sortie contient également un champ `ConnectionErrorCode` qui décrit le problème.
Sortie :
```
{
"CustomKeyStores": [
{
"CustomKeyStoreId": "cks-3234567890abcdef0",
"CustomKeyStoreName": "ExampleVPCExternalKeyStore",
"ConnectionState": "CONNECTED",
"CreationDate": "2022-12-22T07:48:55-07:00",
"CustomKeyStoreType": "EXTERNAL_KEY_STORE",
"XksProxyConfiguration": {
"AccessKeyId": "ABCDE12345670EXAMPLE",
"Connectivity": "VPC_ENDPOINT_SERVICE",
"UriEndpoint": "https://myproxy-private.xks.example.com",
"UriPath": "/kms/xks/v1",
"VpcEndpointServiceName": "com.amazonaws.vpce.us-east-1.vpce-svc-example1"
}
}
]
}
```
Pour plus d’informations, consultez [Affichage d’un magasin de clés externe](https://docs.aws.amazon.com/kms/latest/developerguide/view-xks-keystore.html) dans le *Manuel du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [DescribeCustomKeyStores](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/describe-custom-key-stores.html)à la section *Référence des AWS CLI commandes*.
### `describe-key`
L'exemple de code suivant montre comment utiliser`describe-key`.
**AWS CLI**
**Exemple 1 : pour obtenir des informations détaillées sur une clé KMS**
L'`describe-key`exemple suivant fournit des informations détaillées sur la clé AWS gérée pour Amazon S3 dans l'exemple de compte et de région. Vous pouvez utiliser cette commande pour obtenir des informations sur les clés AWS gérées et les clés gérées par le client.
Pour spécifier la clé KMS, utilisez le paramètre `key-id`. Cet exemple utilise une valeur de nom d’alias, mais vous pouvez utiliser un ID de clé, un ARN de clé, un nom d’alias ou un ARN d’alias dans cette commande.
```
aws kms describe-key \
--key-id alias/aws/s3
```
Sortie :
```
{
"KeyMetadata": {
"AWSAccountId": "846764612917",
"KeyId": "b8a9477d-836c-491f-857e-07937918959b",
"Arn": "arn:aws:kms:us-west-2:846764612917:key/b8a9477d-836c-491f-857e-07937918959b",
"CurrentKeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
"CreationDate": 2017-06-30T21:44:32.140000+00:00,
"Enabled": true,
"Description": "Default KMS key that protects my S3 objects when no other key is defined",
"KeyUsage": "ENCRYPT_DECRYPT",
"KeyState": "Enabled",
"Origin": "AWS_KMS",
"KeyManager": "AWS",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
]
}
}
```
Pour plus d’informations, consultez [Affichage des clés](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html) dans le *Guide du développeur AWS Key Management Service*.
**Exemple 2 : pour obtenir des informations sur une clé KMS asymétrique RSA**
L’exemple `describe-key` suivant fournit des informations détaillées sur une clé KMS asymétrique utilisée pour la signature et la vérification.
```
aws kms describe-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"KeyMetadata": {
"AWSAccountId": "111122223333",
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"Arn": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"CreationDate": "2019-12-02T19:47:14.861000+00:00",
"CustomerMasterKeySpec": "RSA_2048",
"Enabled": false,
"Description": "",
"KeyState": "Disabled",
"Origin": "AWS_KMS",
"MultiRegion": false,
"KeyManager": "CUSTOMER",
"KeySpec": "RSA_2048",
"KeyUsage": "SIGN_VERIFY",
"SigningAlgorithms": [
"RSASSA_PKCS1_V1_5_SHA_256",
"RSASSA_PKCS1_V1_5_SHA_384",
"RSASSA_PKCS1_V1_5_SHA_512",
"RSASSA_PSS_SHA_256",
"RSASSA_PSS_SHA_384",
"RSASSA_PSS_SHA_512"
]
}
}
```
**Exemple 3 : pour obtenir des informations sur une clé de réplica multi-région**
L’exemple `describe-key` suivant fournit des métadonnées pour une clé de réplica multi-région. Cette clé multi-région est une clé de chiffrement symétrique. La sortie d’une commande `describe-key` pour une clé multi-région renvoie des informations sur la clé primaire et tous ses réplicas.
```
aws kms describe-key \
--key-id arn:aws:kms:ap-northeast-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab
```
Sortie :
```
{
"KeyMetadata": {
"MultiRegion": true,
"AWSAccountId": "111122223333",
"Arn": "arn:aws:kms:ap-northeast-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
"CreationDate": "2021-06-28T21:09:16.114000+00:00",
"CurrentKeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
"Description": "",
"Enabled": true,
"KeyId": "mrk-1234abcd12ab34cd56ef1234567890ab",
"KeyManager": "CUSTOMER",
"KeyState": "Enabled",
"KeyUsage": "ENCRYPT_DECRYPT",
"Origin": "AWS_KMS",
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
],
"MultiRegionConfiguration": {
"MultiRegionKeyType": "PRIMARY",
"PrimaryKey": {
"Arn": "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
"Region": "us-west-2"
},
"ReplicaKeys": [
{
"Arn": "arn:aws:kms:eu-west-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
"Region": "eu-west-1"
},
{
"Arn": "arn:aws:kms:ap-northeast-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
"Region": "ap-northeast-1"
},
{
"Arn": "arn:aws:kms:sa-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
"Region": "sa-east-1"
}
]
}
}
}
```
**Exemple 4 : pour obtenir des informations sur une clé KMS HMAC**
L’exemple `describe-key` suivant fournit des informations détaillées sur une clé KMS HMAC.
```
aws kms describe-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"KeyMetadata": {
"AWSAccountId": "123456789012",
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"Arn": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"CreationDate": "2022-04-03T22:23:10.194000+00:00",
"Enabled": true,
"Description": "Test key",
"KeyUsage": "GENERATE_VERIFY_MAC",
"KeyState": "Enabled",
"Origin": "AWS_KMS",
"KeyManager": "CUSTOMER",
"CustomerMasterKeySpec": "HMAC_256",
"MacAlgorithms": [
"HMAC_SHA_256"
],
"MultiRegion": false
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/describe-key.html)à la section *Référence des AWS CLI commandes*.
### `disable-key-rotation`
L'exemple de code suivant montre comment utiliser`disable-key-rotation`.
**AWS CLI**
**Pour désactiver la rotation automatique d’une clé KMS**
L’exemple `disable-key-rotation` suivant désactive la rotation automatique d’une clé KMS gérée par le client. Pour réactiver la rotation automatique, utilisez la commande `enable-key-rotation`.
```
aws kms disable-key-rotation \
--key-id arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
```
Cette commande ne produit aucune sortie. Pour vérifier que la rotation automatique est désactivée pour la clé KMS, utilisez la commande `get-key-rotation-status`.
Pour plus d’informations, consultez [Rotation des clés](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [DisableKeyRotation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/disable-key-rotation.html)à la section *Référence des AWS CLI commandes*.
### `disable-key`
L'exemple de code suivant montre comment utiliser`disable-key`.
**AWS CLI**
**Pour désactiver temporairement une clé KMS**
La commande `disable-key` suivante désactive une clé KMS gérée par le client. Pour réactiver la clé KMS, utilisez la commande `enable-key`.
```
aws kms disable-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Cette commande ne produit aucune sortie.
Pour plus d’informations, consultez [Activation et désactivation de clés](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [DisableKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/disable-key.html)à la section *Référence des AWS CLI commandes*.
### `disconnect-custom-key-store`
L'exemple de code suivant montre comment utiliser`disconnect-custom-key-store`.
**AWS CLI**
**Pour déconnecter un magasin de clés personnalisé**
L'`disconnect-custom-key-store`exemple suivant déconnecte un magasin de clés personnalisé de son cluster AWS CloudHSM. Vous pouvez déconnecter un magasin de clés pour résoudre un problème, pour mettre à jour ses paramètres ou pour empêcher l’utilisation des clés KMS du magasin de clés dans des opérations cryptographiques.
Cette commande est identique pour tous les magasins de clés personnalisés, y compris les magasins de clés AWS CloudHSM et les magasins de clés externes.
Avant d’exécuter la commande, remplacez l’exemple d’ID de magasin de clés personnalisé par un ID valide.
```
$ aws kms disconnect-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0
```
Cette commande ne produit aucune sortie. Pour vérifier que la commande est efficace, utilisez la commande `describe-custom-key-stores`.
*Pour plus d'informations sur la déconnexion d'un magasin de clés AWS CloudHSM, [consultez la section Connexion et déconnexion d'un magasin de clés AWS CloudHSM](https://docs.aws.amazon.com/kms/latest/developerguide/disconnect-keystore.html) dans le guide du développeur du service de gestion des clés.AWS *
Pour plus d’informations sur la déconnexion d’un magasin de clés externe, consultez [Connecting and disconnecting an external key store](https://docs.aws.amazon.com/kms/latest/developerguide/xks-connect-disconnect.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [DisconnectCustomKeyStore](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/disconnect-custom-key-store.html)à la section *Référence des AWS CLI commandes*.
### `enable-key-rotation`
L'exemple de code suivant montre comment utiliser`enable-key-rotation`.
**AWS CLI**
**Pour activer la rotation automatique d’une clé KMS**
L’exemple `enable-key-rotation` suivant permet la rotation automatique d’une clé KMS gérée par le client avec une période de rotation de 180 jours. La clé KMS fera l’objet d’une rotation d’un an (environ 365 jours) à compter de la date d’exécution de cette commande et chaque année par la suite.
Le paramètre `--key-id` identifie la clé KMS. Cet exemple utilise une valeur ARN de clé, mais vous pouvez utiliser l’ID de clé ou l’ARN de la clé KMS. Le paramètre `--rotation-period-in-days` indique le nombre de jours entre chaque date de rotation. Spécifiez une valeur comprise entre 90 et 2 560 jours. La valeur par défaut est 365 jours si aucune valeur n’est spécifiée.
```
aws kms enable-key-rotation \
--key-id arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab \
--rotation-period-in-days 180
```
Cette commande ne produit aucune sortie. Pour vérifier que la clé KMS est activée, utilisez la commande `get-key-rotation-status`.
Pour plus d’informations, consultez [Rotation des clés](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [EnableKeyRotation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/enable-key-rotation.html)à la section *Référence des AWS CLI commandes*.
### `enable-key`
L'exemple de code suivant montre comment utiliser`enable-key`.
**AWS CLI**
**Pour activer une clé KMS**
L’exemple `enable-key` suivant active une clé gérée par le client. Vous pouvez utiliser une commande comme celle-ci pour activer une clé KMS que vous avez temporairement désactivée à l’aide de la commande `disable-key`. Vous pouvez également l’utiliser pour activer une clé KMS qui est désactivée parce que sa suppression était programmée et qu’elle a été annulée.
Pour spécifier la clé KMS, utilisez le paramètre `key-id`. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser une valeur d’ID de clé ou une valeur d’ARN de clé dans cette commande.
Avant d’exécuter cette commande, remplacez l’exemple d’ID de clé par un ID valide.
```
aws kms enable-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Cette commande ne produit aucune sortie. Pour vérifier que la clé KMS est activée, utilisez la commande `describe-key`. Consultez les valeurs des champs `KeyState` et `Enabled` dans la sortie `describe-key`.
Pour plus d’informations, consultez [Activation et désactivation de clés](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [EnableKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/enable-key.html)à la section *Référence des AWS CLI commandes*.
### `encrypt`
L'exemple de code suivant montre comment utiliser`encrypt`.
**AWS CLI**
**Exemple 1 : pour chiffrer le contenu d’un fichier sous Linux ou macOS**
La `encrypt` commande suivante montre la méthode recommandée pour chiffrer les données avec la AWS CLI.
```
aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob | base64 \
--decode > ExampleEncryptedFile
```
La commande effectue plusieurs opérations :
Utilise le paramètre `--plaintext` pour indiquer les données à chiffrer. La valeur de ce paramètre doit être codée en base64. La valeur du `plaintext` paramètre doit être codée en base64, ou vous devez utiliser le préfixe`fileb://`, qui indique à la AWS CLI de lire les données binaires du fichier. Si le fichier ne se trouve pas dans le répertoire actuel, tapez le chemin complet du fichier. Par exemple, `fileb:///var/tmp/ExamplePlaintextFile` ou `fileb://C:\Temp\ExamplePlaintextFile`. [Pour plus d'informations sur la lecture des valeurs des paramètres de la AWS CLI depuis un fichier, consultez la section [AWS Chargement de paramètres depuis un fichier](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-file)*dans le guide de l'utilisateur de l'interface de ligne* de AWS commande et les [meilleures pratiques pour les paramètres de fichiers locaux](https://blogs.aws.amazon.com/cli/post/TxLWWN1O25V1HE/Best-Practices-for-Local-File-Parameters) sur le `--output` blog des outils de ligne de commande. Ces `--query` paramètres extraient les données chiffrées, appelées *texte chiffré*, de la sortie de la commande.Pour plus d'informations sur le contrôle de la sortie, voir Contrôle de la commande ](https://docs.aws.amazon.com/cli/latest/userguide/controlling-output.html)Sortie dans le *guide de l'utilisateur de l'interface de ligne de AWS commande*. Utilise l'`base64`utilitaire pour décoder la sortie extraite en données binaires. Le texte chiffré renvoyé par une commande réussie `encrypt` est du texte codé en base64. Vous devez décoder ce texte avant de pouvoir utiliser la AWS CLI pour le déchiffrer. Enregistre le texte chiffré binaire dans un fichier.La dernière partie de la commande (`> ExampleEncryptedFile`) enregistre le texte chiffré binaire dans un fichier pour faciliter le déchiffrement. Pour un exemple de commande utilisant la AWS CLI pour déchiffrer des données, consultez les exemples de déchiffrement.
**Exemple 2 : utilisation de la AWS CLI pour chiffrer des données sous Windows**
Cet exemple est identique au précédent, sauf qu’il utilise l’outil `certutil` au lieu de `base64`. Cette procédure requiert deux commandes, comme indiqué dans l’exemple suivant.
```
aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob > C:\Temp\ExampleEncryptedFile.base64
certutil -decode C:\Temp\ExampleEncryptedFile.base64 C:\Temp\ExampleEncryptedFile
```
**Exemple 3 : chiffrement avec une clé KMS asymétrique**
La commande `encrypt` suivante montre comment chiffrer du texte brut avec une clé KMS asymétrique. Le paramètre `--encryption-algorithm` est obligatoire. Comme dans toutes les commandes de la `encrypt` CLI, le `plaintext` paramètre doit être codé en base64, ou vous devez utiliser le `fileb://` préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.
```
aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--encryption-algorithm RSAES_OAEP_SHA_256 \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob | base64 \
--decode > ExampleEncryptedFile
```
Cette commande ne produit aucune sortie.
+ Pour plus de détails sur l’API, consultez [Encrypt](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/encrypt.html) dans la *Référence des commandes de l’AWS CLI *.
### `generate-data-key-pair-without-plaintext`
L'exemple de code suivant montre comment utiliser`generate-data-key-pair-without-plaintext`.
**AWS CLI**
**Pour générer une paire de clés de données asymétriques ECC NIST P384**
L'`generate-data-key-pair-without-plaintext`exemple suivant demande une paire de clés ECC NIST P384 pour une utilisation en dehors de. AWS
La commande renvoie une clé publique en texte brut et une copie de la clé privée chiffrée sous la clé KMS spécifiée. Elle ne renvoie pas de clé privée en texte brut. Vous pouvez stocker en toute sécurité la clé privée chiffrée avec les données chiffrées et appeler AWS KMS pour déchiffrer la clé privée lorsque vous devez l'utiliser.
Pour demander une paire de clés de données asymétriques ECC NIST P384, utilisez le paramètre `key-pair-spec` avec une valeur `ECC_NIST_P384`.
La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur `KeySpec` est `SYMMETRIC_DEFAULT`.
REMARQUE : les valeurs de la sortie de cet exemple sont tronquées pour être affichées.
```
aws kms generate-data-key-pair-without-plaintext \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--key-pair-spec ECC_NIST_P384
```
Sortie :
```
{
"PrivateKeyCiphertextBlob": "AQIDAHi6LtupRpdKl2aJTzkK6FbhOtQkMlQJJH3PdtHvS/y+hAFFxmiD134doUDzMGmfCEtcAAAHaTCCB2UGCSqGSIb3DQEHBqCCB1...",
"PublicKey": "MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA3A3eGMyPrvSn7+LdlJE1oUoQV5HpEuHAVbdOyND+NmYDH/mL1OSIEuLrcdZ5hrMH4pk83r40l...",
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
"KeyPairSpec": "ECC_NIST_P384"
}
```
Les clés `PublicKey` et `PrivateKeyCiphertextBlob` sont renvoyées au format encodé en base64.
Pour plus d’informations, consultez [Paires de clés de données](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-key-pairs) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [GenerateDataKeyPairWithoutPlaintext](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-data-key-pair-without-plaintext.html)à la section *Référence des AWS CLI commandes*.
### `generate-data-key-pair`
L'exemple de code suivant montre comment utiliser`generate-data-key-pair`.
**AWS CLI**
**Pour générer une paire de clés de données asymétriques RSA de 2 048 bits**
L'`generate-data-key-pair`exemple suivant demande une paire de clés de données asymétriques RSA de 2048 bits pour une utilisation en dehors de. AWS La commande renvoie une clé publique et une clé privée en texte brut pour une utilisation et une suppression immédiates, ainsi qu’une copie de la clé privée chiffrée sous la clé KMS spécifiée. Vous pouvez stocker en toute sécurité la clé privée chiffrée avec les données chiffrées.
Pour demander une paire de clés de données asymétriques RSA de 2 048 bits, utilisez le paramètre `key-pair-spec` avec une valeur `RSA_2048`.
La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur `KeySpec` est `SYMMETRIC_DEFAULT`.
REMARQUE : les valeurs de la sortie de cet exemple sont tronquées pour être affichées.
```
aws kms generate-data-key-pair \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--key-pair-spec RSA_2048
```
Sortie :
```
{
"PrivateKeyCiphertextBlob": "AQIDAHi6LtupRpdKl2aJTzkK6FbhOtQkMlQJJH3PdtHvS/y+hAFFxmiD134doUDzMGmfCEtcAAAHaTCCB2UGCSqGSIb3DQEHBqCCB1...",
"PrivateKeyPlaintext": "MIIG/QIBADANBgkqhkiG9w0BAQEFAASCBucwggbjAgEAAoIBgQDcDd4YzI+u9Kfv4t2UkTWhShBXkekS4cBVt07I0P42ZgMf+YvU5IgS4ut...",
"PublicKey": "MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA3A3eGMyPrvSn7+LdlJE1oUoQV5HpEuHAVbdOyND+NmYDH/mL1OSIEuLrcdZ5hrMH4pk83r40l...",
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
"KeyPairSpec": "RSA_2048"
}
```
Les clés `PublicKey`, `PrivateKeyPlaintext` et `PrivateKeyCiphertextBlob` sont renvoyées au format encodé en base64.
Pour plus d’informations, consultez [Paires de clés de données](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-key-pairs) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [GenerateDataKeyPair](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-data-key-pair.html)à la section *Référence des AWS CLI commandes*.
### `generate-data-key-without-plaintext`
L'exemple de code suivant montre comment utiliser`generate-data-key-without-plaintext`.
**AWS CLI**
**Pour générer une clé de données symétrique de 256 bits sans clé en texte brut**
L’exemple `generate-data-key-without-plaintext` suivant demande une copie chiffrée d’une clé de données symétrique de 256 bits pour une utilisation en dehors d’ AWS. Vous pouvez appeler AWS KMS pour déchiffrer la clé de données lorsque vous êtes prêt à l'utiliser.
Pour demander une clé de données de 256 bits, utilisez le paramètre `key-spec` avec une valeur `AES_256`. Pour demander une clé de données de 128 bits, utilisez le paramètre `key-spec` avec une valeur `AES_128`. Pour toutes les autres longueurs de clé de données, utilisez le paramètre `number-of-bytes`.
La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur de spécification de clé est SYMMETRIC\$1DEFAULT.
```
aws kms generate-data-key-without-plaintext \
--key-id "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab" \
--key-spec AES_256
```
Sortie :
```
{
"CiphertextBlob": "AQEDAHjRYf5WytIc0C857tFSnBaPn2F8DgfmThbJlGfR8P3WlwAAAH4wfAYJKoZIhvcNAQcGoG8wbQIBADBoBgkqhkiG9w0BBwEwHgYJYIZIAWUDBAEuMBEEDEFogL",
"KeyId": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
}
```
Le `CiphertextBlob` (clé de données chiffrée) est renvoyé au format encodé en base64.
Pour plus d’informations, consultez [Clés de données](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [GenerateDataKeyWithoutPlaintext](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-data-key-without-plaintext.html)à la section *Référence des AWS CLI commandes*.
### `generate-data-key`
L'exemple de code suivant montre comment utiliser`generate-data-key`.
**AWS CLI**
**Exemple 1 : pour générer une clé de données symétrique de 256 bits**
L'`generate-data-key`exemple suivant demande une clé de données symétrique de 256 bits à utiliser en dehors de. AWS La commande renvoie une clé de données en texte brut pour une utilisation et une suppression immédiates, ainsi qu’une copie de cette clé de données chiffrée sous la clé KMS spécifiée. Vous pouvez stocker en toute sécurité la clé de données chiffrée avec les données chiffrées.
Pour demander une clé de données de 256 bits, utilisez le paramètre `key-spec` avec une valeur `AES_256`. Pour demander une clé de données de 128 bits, utilisez le paramètre `key-spec` avec une valeur `AES_128`. Pour toutes les autres longueurs de clé de données, utilisez le paramètre `number-of-bytes`.
La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur de spécification de clé est SYMMETRIC\$1DEFAULT.
```
aws kms generate-data-key \
--key-id alias/ExampleAlias \
--key-spec AES_256
```
Sortie :
```
{
"Plaintext": "VdzKNHGzUAzJeRBVY+uUmofUGGiDzyB3+i9fVkh3piw=",
"KeyId": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
"CiphertextBlob": "AQEDAHjRYf5WytIc0C857tFSnBaPn2F8DgfmThbJlGfR8P3WlwAAAH4wfAYJKoZIhvcNAQcGoG8wbQIBADBoBgkqhkiG9w0BBwEwHgYJYIZIAWUDBAEuMBEEDEFogLqPWZconQhwHAIBEIA7d9AC7GeJJM34njQvg4Wf1d5sw0NIo1MrBqZa+YdhV8MrkBQPeac0ReRVNDt9qleAt+SHgIRF8P0H+7U="
}
```
Le `Plaintext` (clé de données en texte brut) et le `CiphertextBlob` (clé de données chiffrée) sont renvoyés au format encodé en base64.
Pour plus d’informations, consultez [Clés de données](https://docs.aws.amazon.com/kms/latest/developerguide/data-keys.html) dans le *Guide du développeur AWS Key Management Service*. **Exemple 2 : pour générer une clé de données symétrique de 512 bits**
L’exemple `generate-data-key` suivant demande une clé de données symétrique de 512 bits pour le chiffrement et le déchiffrement. La commande renvoie une clé de données en texte brut pour une utilisation et une suppression immédiates, ainsi qu’une copie de cette clé de données chiffrée sous la clé KMS spécifiée. Vous pouvez stocker en toute sécurité la clé de données chiffrée avec les données chiffrées.
Pour demander une longueur de clé autre que 128 ou 256 bits, utilisez le paramètre `number-of-bytes`. Pour demander une clé de données 512 bits, l’exemple suivant utilise le paramètre `number-of-bytes` avec une valeur de 64 (octets).
La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur de spécification de clé est SYMMETRIC\$1DEFAULT.
REMARQUE : les valeurs de la sortie de cet exemple sont tronquées pour être affichées.
```
aws kms generate-data-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--number-of-bytes 64
```
Sortie :
```
{
"CiphertextBlob": "AQIBAHi6LtupRpdKl2aJTzkK6FbhOtQkMlQJJH3PdtHvS/y+hAEnX/QQNmMwDfg2korNMEc8AAACaDCCAmQGCSqGSIb3DQEHBqCCAlUwggJRAgEAMIICSgYJKoZ...",
"Plaintext": "ty8Lr0Bk6OF07M2BWt6qbFdNB+G00ZLtf5MSEb4al3R2UKWGOp06njAwy2n72VRm2m7z/Pm9Wpbvttz6a4lSo9hgPvKhZ5y6RTm4OovEXiVfBveyX3DQxDzRSwbKDPk/...",
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
}
```
La `Plaintext` (clé de données en texte brut) et la `CiphertextBlob` (clé de données chiffrée) sont renvoyées au format encodé en base64.
Pour plus d’informations, consultez [Clés de données](https://docs.aws.amazon.com/kms/latest/developerguide/data-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [GenerateDataKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-data-key.html)à la section *Référence des AWS CLI commandes*.
### `generate-mac`
L'exemple de code suivant montre comment utiliser`generate-mac`.
**AWS CLI**
**Exemple 1 : pour générer un HMAC pour un message**
La commande `generate-mac` suivante génère un HMAC pour un message, une clé KMS HMAC et un algorithme MAC. L’algorithme doit être pris en charge par la clé KMS HMAC spécifiée.
Dans la AWS CLI v2, la valeur du `message` paramètre doit être codée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le `fileb://` préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS HMAC avec comme utilisation de `GENERATE_VERIFY_MAC`.
```
msg=(echo 'Hello World' | base64)
aws kms generate-mac \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--message fileb://Message \
--mac-algorithm HMAC_SHA_384
```
Sortie :
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"Mac": "",
"MacAlgorithm": "HMAC_SHA_384"
}
```
Pour plus d'informations sur l'utilisation des clés HMAC KMS dans AWS KMS, consultez la section [Clés HMAC dans AWS KMS dans](https://docs.aws.amazon.com/kms/latest/developerguide/hmac.html) le Guide du *développeur du service de gestion des AWS clés*.
**Exemple 2 : pour enregistrer un HMAC dans un fichier (Linux et macOS)**
L’exemple `generate-mac` suivant génère un HMAC pour un message court stocké dans un fichier local. La commande obtient également la `Mac` propriété à partir de la réponse, la décode en Base64 et l'enregistre dans le fichier. ExampleMac Vous pouvez utiliser le fichier MAC dans une commande `verify-mac` qui vérifie le MAC.
La commande `generate-mac` nécessite un message encodé en Base64 et un algorithme MAC pris en charge par votre clé KMS HMAC. Pour obtenir les algorithmes MAC pris en charge par votre clé KMS, utilisez la commande `describe-key`.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est GENERATE\$1VERIFY\$1MAC.
```
echo 'hello world' | base64 > EncodedMessage
aws kms generate-mac \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--message fileb://EncodedMessage \
--mac-algorithm HMAC_SHA_384 \
--output text \
--query Mac | base64 --decode > ExampleMac
```
Cette commande ne produit aucune sortie. Cet exemple récupère la propriété `Mac` de la sortie et l’enregistre dans un fichier.
Pour plus d'informations sur l'utilisation des clés HMAC KMS dans AWS KMS, consultez la section [Clés HMAC dans AWS KMS dans](https://docs.aws.amazon.com/kms/latest/developerguide/hmac.html) le Guide du *développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [GenerateMac](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-mac.html)à la section *Référence des AWS CLI commandes*.
### `generate-random`
L'exemple de code suivant montre comment utiliser`generate-random`.
**AWS CLI**
**Exemple 1 : pour générer une chaîne d’octets aléatoire de 256 bits (Linux ou macOS)**
L’exemple `generate-random` suivant génère une chaîne d’octets aléatoire de 256 bits (32 octets) encodée en base64. L’exemple décode la chaîne d’octets et l’enregistre dans le fichier aléatoire.
Lorsque vous exécutez cette commande, vous devez utiliser le paramètre `number-of-bytes` pour spécifier la longueur de la valeur aléatoire en octets.
Vous ne spécifiez pas de clé KMS lorsque vous exécutez cette commande. La chaîne d’octets aléatoire n’est liée à aucune clé KMS.
Par défaut, AWS KMS génère le nombre aléatoire. Toutefois, si vous spécifiez un [magasin de clés personnalisé](https://docs.aws.amazon.com/kms/latest/developerguide/custom-key-store-overview.html), la chaîne d'octets aléatoire est générée dans le cluster AWS CloudHSM associé au magasin de clés personnalisé.
Cet exemple utilise les paramètres et valeurs suivants :
Il utilise le `--number-of-bytes` paramètre requis avec une valeur de `32` pour demander une chaîne de 32 octets (256 bits). Il utilise le `--output` paramètre avec une valeur de pour demander à la AWS CLI de renvoyer la sortie sous forme de texte, au lieu de JSON. Il utilise le `--query parameter` pour extraire la valeur de la `Plaintext` propriété de la réponse. Il envoie (\$1) la sortie de la commande à l'`base64`utilitaire, qui décode la sortie extraite. Il utilise l'opérateur de `text` redirection (>) pour enregistrer la chaîne d'octets décodée dans le fichier .it utilise l'opérateur de redirection (>) `ExampleRandom` pour enregistrer le texte chiffré binaire dans un fichier.
```
aws kms generate-random \
--number-of-bytes 32 \
--output text \
--query Plaintext | base64 --decode > ExampleRandom
```
Cette commande ne produit aucune sortie.
Pour plus d'informations, consultez la *référence [GenerateRandom](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateRandom.html)de l'API du service de gestion des AWS clés*.
**Exemple 2 : pour générer un nombre aléatoire de 256 bits (invite de commande Windows)**
L’exemple suivant utilise la commande `generate-random` pour générer une chaîne d’octets aléatoire de 256 bits (32 octets) encodée en base64. L’exemple décode la chaîne d’octets et l’enregistre dans le fichier aléatoire. Cet exemple est identique à l’exemple précédent, sauf qu’il utilise l’utilitaire `certutil` de Windows pour décoder en base64 la chaîne d’octets aléatoire avant de l’enregistrer dans un fichier.
Tout d’abord, générez une chaîne d’octets aléatoire encodée en base64 et enregistrez-la dans un fichier temporaire, `ExampleRandom.base64`.
```
aws kms generate-random \
--number-of-bytes 32 \
--output text \
--query Plaintext > ExampleRandom.base64
```
La sortie de la commande `generate-random` étant enregistrée dans un fichier, cet exemple ne produit aucune sortie.
Utilisez maintenant la commande `certutil -decode` pour décoder la chaîne d’octets encodée en base64 dans le fichier `ExampleRandom.base64`. Ensuite, il enregistre la chaîne d’octets décodée dans le fichier `ExampleRandom`.
```
certutil -decode ExampleRandom.base64 ExampleRandom
```
Sortie :
```
Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.
```
Pour plus d'informations, consultez la *référence [GenerateRandom](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateRandom.html)de l'API du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [GenerateRandom](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-random.html)à la section *Référence des AWS CLI commandes*.
### `get-key-policy`
L'exemple de code suivant montre comment utiliser`get-key-policy`.
**AWS CLI**
**Pour copier une stratégie de clé d’une clé KMS vers une autre clé KMS**
L’exemple suivant `get-key-policy` obtient la stratégie de clé d’une clé KMS et l’enregistre dans un fichier texte. Il remplace ensuite la stratégie d’une autre clé KMS en utilisant le fichier texte comme entrée de stratégie.
Comme le paramètre `--policy` de `put-key-policy` nécessite une chaîne, vous devez utiliser l’option `--output text` pour renvoyer la sortie sous forme de chaîne de texte au lieu de JSON.
```
aws kms get-key-policy \
--policy-name default \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--query Policy \
--output text > policy.txt
aws kms put-key-policy \
--policy-name default \
--key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
--policy file://policy.txt
```
Cette commande ne produit aucune sortie.
Pour plus d'informations, consultez le [PutKeyPolicy](https://docs.aws.amazon.com/kms/latest/APIReference/API_PutKeyPolicy.html)manuel de *référence de l'API AWS KMS*.
+ Pour plus de détails sur l'API, reportez-vous [GetKeyPolicy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/get-key-policy.html)à la section *Référence des AWS CLI commandes*.
### `get-key-rotation-status`
L'exemple de code suivant montre comment utiliser`get-key-rotation-status`.
**AWS CLI**
**Pour extraire le statut de rotation d’une clé KMS**
L’exemple `get-key-rotation-status` suivant renvoie des informations sur le statut de rotation de la clé KMS spécifiée, notamment si la rotation automatique est activée, la période de rotation et la prochaine date de rotation planifiée. Vous pouvez utiliser cette commande sur les clés KMS gérées par le client et les clés KMS AWS gérées. Cependant, toutes les clés KMS AWS gérées font l'objet d'une rotation automatique chaque année.
```
aws kms get-key-rotation-status \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyRotationEnabled": true,
"NextRotationDate": "2024-02-14T18:14:33.587000+00:00",
"RotationPeriodInDays": 365
}
```
Pour plus d’informations, consultez [Rotation des clés](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [GetKeyRotationStatus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/get-key-rotation-status.html)à la section *Référence des AWS CLI commandes*.
### `get-parameters-for-import`
L'exemple de code suivant montre comment utiliser`get-parameters-for-import`.
**AWS CLI**
**Pour obtenir les éléments requis pour importer des éléments de clé dans une clé KMS**
L’exemple `get-parameters-for-import` suivant obtient la clé publique et le jeton d’importation dont vous avez besoin pour importer des éléments de clé dans une clé KMS. Lorsque vous utilisez la commande `import-key-material`, veillez à utiliser le jeton d’importation et les éléments de clé chiffrés par la clé publique renvoyés dans la même commande `get-parameters-for-import`. En outre, l’algorithme d’encapsulage que vous spécifiez dans cette commande doit être celui que vous utilisez pour chiffrer les éléments de clé avec la clé publique.
Pour spécifier la clé KMS, utilisez le paramètre `key-id`. Cet exemple utilise un ID de clé, mais vous pouvez utiliser un ID de clé ou un ARN de clé dans cette commande.
```
aws kms get-parameters-for-import \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--wrapping-algorithm RSAES_OAEP_SHA_256 \
--wrapping-key-spec RSA_2048
```
Sortie :
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"PublicKey": "",
"ImportToken": "",
"ParametersValidTo": 1593893322.32
}
```
Pour plus d’informations, consultez [Download the public key and import token](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys-get-public-key-and-token.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [GetParametersForImport](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/get-parameters-for-import.html)à la section *Référence des AWS CLI commandes*.
### `get-public-key`
L'exemple de code suivant montre comment utiliser`get-public-key`.
**AWS CLI**
**Exemple 1 : pour télécharger la clé publique d’une clé KMS asymétrique**
L’exemple `get-public-key` suivant télécharge la clé publique d’une clé KMS asymétrique.
Outre le renvoi de la clé publique, le résultat inclut les informations dont vous avez besoin pour utiliser la clé publique en toute sécurité en dehors de AWS KMS, notamment l'utilisation de la clé et les algorithmes de chiffrement pris en charge.
```
aws kms get-public-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"PublicKey": "jANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAl5epvg1/QtJhxSi2g9SDEVg8QV/...",
"CustomerMasterKeySpec": "RSA_4096",
"KeyUsage": "ENCRYPT_DECRYPT",
"EncryptionAlgorithms": [
"RSAES_OAEP_SHA_1",
"RSAES_OAEP_SHA_256"
]
}
```
Pour plus d'informations sur l'utilisation de clés KMS asymétriques dans AWS KMS, voir [Clés asymétriques dans AWS KMS dans](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) le Guide du *développeur du service de gestion des AWS clés*. **Exemple 2 : pour convertir une clé publique au format DER (Linux et macOS)**
L’exemple `get-public-key` suivant télécharge la clé publique d’une clé KMS asymétrique et l’enregistre dans un fichier DER.
Lorsque vous utilisez la `get-public-key` commande dans la AWS CLI, elle renvoie une clé publique X.509 codée DER codée en Base64. Cet exemple fournit la valeur de la propriété `PublicKey` sous forme de texte. Il décode en Base64 la `PublicKey` et l’enregistre dans le fichier `public_key.der`. Le paramètre `output` renvoie la sortie sous forme de texte, au lieu de JSON. Le `--query` paramètre obtient uniquement la `PublicKey` propriété, et non les propriétés dont vous avez besoin pour utiliser la clé publique en toute sécurité en dehors de AWS KMS.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.
```
aws kms get-public-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--output text \
--query PublicKey | base64 --decode > public_key.der
```
Cette commande ne produit aucune sortie.
Pour plus d'informations sur l'utilisation de clés KMS asymétriques dans AWS KMS, voir [Clés asymétriques dans AWS KMS dans](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) le Guide du *développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [GetPublicKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/get-public-key.html)à la section *Référence des AWS CLI commandes*.
### `import-key-material`
L'exemple de code suivant montre comment utiliser`import-key-material`.
**AWS CLI**
**Pour importer les éléments de clé dans une clé KMS**
L’exemple `import-key-material` suivant télécharge des éléments de clé dans une clé KMS créée sans élément de clé. L’état de la clé KMS doit être `PendingImport`.
Cette commande utilise des éléments de clé que vous avez chiffrés avec la clé publique renvoyée par la commande `get-parameters-for-import`. Elle utilise également le jeton d’importation issu de la même commande `get-parameters-for-import`.
Le paramètre `expiration-model` indique que les éléments de clé expirent automatiquement à la date et à l’heure spécifiées par le paramètre `valid-to`. Lorsque le contenu clé expire, AWS KMS le supprime, l'état de la clé KMS devient inutilisable. `Pending import` Pour restaurer la clé KMS, vous devez réimporter les mêmes éléments de clé. Pour utiliser un autre élément de clé, vous devez créer une nouvelle clé KMS.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé ou un ARN de clé valide provenant de votre AWS compte.
```
aws kms import-key-material \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--encrypted-key-material fileb://EncryptedKeyMaterial.bin \
--import-token fileb://ImportToken.bin \
--expiration-model KEY_MATERIAL_EXPIRES \
--valid-to 2021-09-21T19:00:00Z
```
Sortie :
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
}
```
Pour plus d’informations sur l’importation des éléments de clé, consultez [Importation des éléments de clé](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [ImportKeyMaterial](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/import-key-material.html)à la section *Référence des AWS CLI commandes*.
### `list-aliases`
L'exemple de code suivant montre comment utiliser`list-aliases`.
**AWS CLI**
**Exemple 1 : pour répertorier tous les alias d'un AWS compte et d'une région**
L'exemple suivant utilise la `list-aliases` commande pour répertorier tous les alias de la région par défaut du AWS compte. La sortie inclut les alias associés aux clés KMS AWS gérées et aux clés KMS gérées par le client.
```
aws kms list-aliases
```
Sortie :
```
{
"Aliases": [
{
"AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/testKey",
"AliasName": "alias/testKey",
"TargetKeyId": "1234abcd-12ab-34cd-56ef-1234567890ab"
},
{
"AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/FinanceDept",
"AliasName": "alias/FinanceDept",
"TargetKeyId": "0987dcba-09fe-87dc-65ba-ab0987654321"
},
{
"AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/aws/dynamodb",
"AliasName": "alias/aws/dynamodb",
"TargetKeyId": "1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d"
},
{
"AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/aws/ebs",
"AliasName": "alias/aws/ebs",
"TargetKeyId": "0987ab65-43cd-21ef-09ab-87654321cdef"
},
...
]
}
```
**Exemple 2 : pour répertorier tous les alias d’une clé KMS particulière**
L’exemple suivant utilise la commande `list-aliases` et son paramètre `key-id` pour répertorier tous les alias associés à une clé KMS spécifique.
Chaque alias est associé à une seule clé KMS, mais une clé KMS peut avoir plusieurs alias. Cette commande est très utile car la console AWS KMS ne répertorie qu'un seul alias pour chaque clé KMS. Pour trouver tous les alias d’une clé KMS, vous devez utiliser la commande `list-aliases`.
Cet exemple utilise l’ID de la clé KMS pour le paramètre `--key-id`, mais vous pouvez utiliser un ID de clé, un ARN de clé, un nom d’alias ou un ARN d’alias dans cette commande.
```
aws kms list-aliases --key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"Aliases": [
{
"TargetKeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/oregon-test-key",
"AliasName": "alias/oregon-test-key"
},
{
"TargetKeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/project121-test",
"AliasName": "alias/project121-test"
}
]
}
```
Pour plus d’informations, consultez [Utilisation des alias](https://docs.aws.amazon.com/kms/latest/developerguide/programming-aliases.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [ListAliases](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-aliases.html)à la section *Référence des AWS CLI commandes*.
### `list-grants`
L'exemple de code suivant montre comment utiliser`list-grants`.
**AWS CLI**
**Pour afficher les subventions sur une clé AWS KMS**
L'`list-grants`exemple suivant affiche toutes les autorisations associées à la clé KMS AWS gérée spécifiée pour Amazon DynamoDB dans votre compte. Cette autorisation permet à DynamoDB d’utiliser la clé KMS en votre nom pour chiffrer une table DynamoDB avant de l’écrire sur le disque. Vous pouvez utiliser une commande comme celle-ci pour afficher les autorisations relatives aux clés KMS AWS gérées et aux clés KMS gérées par le client dans le AWS compte et la région.
Cette commande utilise le paramètre `key-id` avec un ID de clé pour identifier la clé KMS. Vous pouvez utiliser un ID de clé ou un ARN de clé pour identifier la clé KMS. Pour obtenir l'ID de clé ou l'ARN d'une clé KMS AWS gérée, utilisez la `list-aliases` commande `list-keys` or.
```
aws kms list-grants \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
La sortie indique que l’octroi autorise Amazon DynamoDB à utiliser la clé KMS pour des opérations cryptographiques, à consulter les informations relatives à la clé KMS (`DescribeKey`) et à mettre les autorisations hors service (`RetireGrant`). La contrainte `EncryptionContextSubset` limite ces autorisations aux demandes qui incluent les paires de contextes de chiffrement spécifiées. Par conséquent, les autorisations de l’octroi ne sont effectives que sur le compte spécifié et sur la table DynamoDB.
```
{
"Grants": [
{
"Constraints": {
"EncryptionContextSubset": {
"aws:dynamodb:subscriberId": "123456789012",
"aws:dynamodb:tableName": "Services"
}
},
"IssuingAccount": "arn:aws:iam::123456789012:root",
"Name": "8276b9a6-6cf0-46f1-b2f0-7993a7f8c89a",
"Operations": [
"Decrypt",
"Encrypt",
"GenerateDataKey",
"ReEncryptFrom",
"ReEncryptTo",
"RetireGrant",
"DescribeKey"
],
"GrantId": "1667b97d27cf748cf05b487217dd4179526c949d14fb3903858e25193253fe59",
"KeyId": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"RetiringPrincipal": "dynamodb.us-west-2.amazonaws.com",
"GranteePrincipal": "dynamodb.us-west-2.amazonaws.com",
"CreationDate": "2021-05-13T18:32:45.144000+00:00"
}
]
}
```
Pour plus d'informations, consultez la section [Subventions dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) dans le *Guide du développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [ListGrants](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-grants.html)à la section *Référence des AWS CLI commandes*.
### `list-key-policies`
L'exemple de code suivant montre comment utiliser`list-key-policies`.
**AWS CLI**
**Pour obtenir les noms des stratégies de clé pour une clé KMS**
L’exemple `list-key-policies` suivant obtient les noms des stratégies de clé pour une clé gérée par le client dans les exemples de compte et de région. Vous pouvez utiliser cette commande pour rechercher les noms des politiques clés relatives aux clés AWS gérées et aux clés gérées par le client.
Comme le seul nom de stratégie de clé valide est `default`, cette commande n’est pas utile.
Pour spécifier la clé KMS, utilisez le paramètre `key-id`. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser un ID de clé ou un ARN de clé dans cette commande.
```
aws kms list-key-policies \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"PolicyNames": [
"default"
]
}
```
Pour plus d'informations sur les politiques clés AWS KMS, consultez la section [Utilisation des politiques clés dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) dans le *Guide du développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [ListKeyPolicies](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-key-policies.html)à la section *Référence des AWS CLI commandes*.
### `list-key-rotations`
L'exemple de code suivant montre comment utiliser`list-key-rotations`.
**AWS CLI**
**Pour extraire des informations sur toutes les rotations des éléments de clé terminées**
L’exemple `list-key-rotations` suivant répertorie les informations relatives à toutes les rotations des éléments de clé effectuées pour la clé KMS spécifiée.
```
aws kms list-key-rotations \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"Rotations": [
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"RotationDate": "2024-03-02T10:11:36.564000+00:00",
"RotationType": "AUTOMATIC"
},
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"RotationDate": "2024-04-05T15:14:47.757000+00:00",
"RotationType": "ON_DEMAND"
}
],
"Truncated": false
}
```
Pour plus d’informations, consultez [Rotation des clés](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [ListKeyRotations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-key-rotations.html)à la section *Référence des AWS CLI commandes*.
### `list-keys`
L'exemple de code suivant montre comment utiliser`list-keys`.
**AWS CLI**
**Pour obtenir les clés KMS dans un compte et une région**
L’exemple `list-keys` suivant fournit les clés KMS d’un compte et d’une région. Cette commande renvoie à la fois les clés AWS gérées et les clés gérées par le client.
```
aws kms list-keys
```
Sortie :
```
{
"Keys": [
{
"KeyArn": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab"
},
{
"KeyArn": "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321",
"KeyId": "0987dcba-09fe-87dc-65ba-ab0987654321"
},
{
"KeyArn": "arn:aws:kms:us-east-2:111122223333:key/1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d",
"KeyId": "1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d"
}
]
}
```
Pour plus d’informations, consultez [Affichage des clés](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [ListKeys](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-keys.html)à la section *Référence des AWS CLI commandes*.
### `list-resource-tags`
L'exemple de code suivant montre comment utiliser`list-resource-tags`.
**AWS CLI**
**Pour obtenir les balises d’une clé KMS**
L’exemple `list-resource-tags` suivant fournit les balises d’une clé KMS. Pour ajouter ou remplacer des balises de ressources sur des clés KMS, utilisez la commande `tag-resource`. La sortie indique que cette clé KMS possède deux balises de ressources, chacune ayant une clé et une valeur.
Pour spécifier la clé KMS, utilisez le paramètre `key-id`. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser un ID de clé ou un ARN de clé dans cette commande.
```
aws kms list-resource-tags \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"Tags": [
{
"TagKey": "Dept",
"TagValue": "IT"
},
{
"TagKey": "Purpose",
"TagValue": "Test"
}
],
"Truncated": false
}
```
Pour plus d'informations sur l'utilisation des balises dans AWS KMS, consultez la section [Balisage des clés](https://docs.aws.amazon.com/kms/latest/developerguide/tagging-keys.html) dans le *Guide du développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [ListResourceTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-resource-tags.html)à la section *Référence des AWS CLI commandes*.
### `list-retirable-grants`
L'exemple de code suivant montre comment utiliser`list-retirable-grants`.
**AWS CLI**
**Pour afficher les octrois qu’un principal peut mettre hors service**
L'`list-retirable-grants`exemple suivant affiche toutes les autorisations que l'`ExampleAdmin`utilisateur peut retirer sur les clés KMS d'un AWS compte et d'une région. Vous pouvez utiliser une commande comme celle-ci pour afficher les autorisations que tout directeur de compte peut retirer sur les clés KMS du AWS compte et de la région.
La valeur du paramètre `retiring-principal` requis doit être l’Amazon Resource Name (ARN) d’un compte, d’un utilisateur ou d’un rôle.
Vous ne pouvez pas spécifier de service pour la valeur de `retiring-principal` dans cette commande, même si un service peut être le principal mis hors service. Pour trouver les octrois dans lesquels un service particulier est le principal mis hors service, utilisez la commande `list-grants`.
Le résultat indique que l’utilisateur `ExampleAdmin` est autorisé à mettre hors service les octrois sur deux clés KMS différentes dans le compte et dans la région. Outre le principal mis hors service, le compte est autorisé à mettre hors service tout octroi du compte.
```
aws kms list-retirable-grants \
--retiring-principal arn:aws:iam::111122223333:user/ExampleAdmin
```
Sortie :
```
{
"Grants": [
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"GrantId": "156b69c63cb154aa21f59929ff19760717be8d9d82b99df53e18b94a15a5e88e",
"Name": "",
"CreationDate": 2021-01-14T20:17:36.419000+00:00,
"GranteePrincipal": "arn:aws:iam::111122223333:user/ExampleUser",
"RetiringPrincipal": "arn:aws:iam::111122223333:user/ExampleAdmin",
"IssuingAccount": "arn:aws:iam::111122223333:root",
"Operations": [
"Encrypt"
],
"Constraints": {
"EncryptionContextSubset": {
"Department": "IT"
}
}
},
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321",
"GrantId": "8c94d1f12f5e69f440bae30eaec9570bb1fb7358824f9ddfa1aa5a0dab1a59b2",
"Name": "",
"CreationDate": "2021-02-02T19:49:49.638000+00:00",
"GranteePrincipal": "arn:aws:iam::111122223333:role/ExampleRole",
"RetiringPrincipal": "arn:aws:iam::111122223333:user/ExampleAdmin",
"IssuingAccount": "arn:aws:iam::111122223333:root",
"Operations": [
"Decrypt"
],
"Constraints": {
"EncryptionContextSubset": {
"Department": "IT"
}
}
}
],
"Truncated": false
}
```
Pour plus d'informations, consultez la section [Subventions dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) dans le *Guide du développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [ListRetirableGrants](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-retirable-grants.html)à la section *Référence des AWS CLI commandes*.
### `put-key-policy`
L'exemple de code suivant montre comment utiliser`put-key-policy`.
**AWS CLI**
**Pour modifier la stratégie de clé d’une clé KMS**
L’exemple `put-key-policy` suivant modifie la stratégie de clé pour une clé gérée par le client.
Pour commencer, créez une stratégie de clé et enregistrez-la dans un fichier JSON local. Dans cet exemple, le fichier est `key_policy.json`. Vous pouvez également spécifier la stratégie de clé sous forme de valeur de chaîne du paramètre `policy`.
La première déclaration de cette politique clé autorise le AWS compte à utiliser les politiques IAM pour contrôler l'accès à la clé KMS. La deuxième instruction autorise l’utilisateur `test-user` à exécuter les commandes `describe-key` et `list-keys` sur la clé KMS.
Contenu de `key_policy.json` :
```
{
"Version":"2012-10-17",
"Id" : "key-default-1",
"Statement" : [
{
"Sid" : "Enable IAM User Permissions",
"Effect" : "Allow",
"Principal" : {
"AWS" : "arn:aws:iam::111122223333:root"
},
"Action" : "kms:*",
"Resource" : "*"
},
{
"Sid" : "Allow Use of Key",
"Effect" : "Allow",
"Principal" : {
"AWS" : "arn:aws:iam::111122223333:user/test-user"
},
"Action" : [
"kms:DescribeKey",
"kms:ListKeys"
],
"Resource" : "*"
}
]
}
```
Pour identifier la clé KMS, cet exemple utilise l’ID de clé, mais vous pouvez également utiliser un ARN de clé. Pour spécifier la stratégie de clé, la commande utilise le paramètre `policy`. Pour indiquer que la stratégie se trouve dans un fichier, elle utilise le préfixe `file://` requis. Ce préfixe est nécessaire pour identifier les fichiers sur tous les systèmes d’exploitation pris en charge. Enfin, la commande utilise le paramètre `policy-name` avec la valeur `default`. Si aucune stratégie de nom n’est spécifiée, la valeur par défaut est `default`. La seule valeur valide est `default`.
```
aws kms put-key-policy \
--policy-name default \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--policy file://key_policy.json
```
Cette commande ne génère pas de sortie. Pour vérifier que la commande est efficace, utilisez la commande `get-key-policy`. L’exemple de commande suivant permet d’obtenir la stratégie de clé pour la même clé KMS. Le paramètre `output` avec la valeur `text` renvoie un format de texte facile à lire.
```
aws kms get-key-policy \
--policy-name default \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--output text
```
Sortie :
```
{
"Version":"2012-10-17",
"Id" : "key-default-1",
"Statement" : [
{
"Sid" : "Enable IAM User Permissions",
"Effect" : "Allow",
"Principal" : {
"AWS" : "arn:aws:iam::111122223333:root"
},
"Action" : "kms:*",
"Resource" : "*"
},
{
"Sid" : "Allow Use of Key",
"Effect" : "Allow",
"Principal" : {
"AWS" : "arn:aws:iam::111122223333:user/test-user"
},
"Action" : [ "kms:Describe", "kms:List" ],
"Resource" : "*"
}
]
}
```
Pour plus d’informations, consultez [Modification d’une stratégie de clé](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [PutKeyPolicy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/put-key-policy.html)à la section *Référence des AWS CLI commandes*.
### `re-encrypt`
L'exemple de code suivant montre comment utiliser`re-encrypt`.
**AWS CLI**
**Exemple 1 : pour rechiffrer un message chiffré sous une autre clé KMS symétrique (Linux et macOS)**
L'exemple de `re-encrypt` commande suivant illustre la méthode recommandée pour rechiffrer les données à l'aide de la CLI AWS .
Fournissez le texte chiffré dans un fichier. Dans la valeur du paramètre `--ciphertext-blob`, utilisez le préfixe `fileb://`, qui indique à l’interface de ligne de commande (CLI) de lire les données d’un fichier binaire. Si le fichier ne se trouve pas dans le répertoire actuel, saisissez le chemin complet du fichier. Pour plus d'informations sur la lecture des valeurs des paramètres de la AWS CLI à partir d'un fichier, consultez la section [Chargement de paramètres AWS CLI depuis un fichier](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html) dans le *guide de l'utilisateur de l'interface de ligne de AWS commande* et les [meilleures pratiques relatives aux paramètres de fichiers locaux](https://aws.amazon.com/blogs/developer/best-practices-for-local-file-parameters/) dans le *blog des outils de ligne de AWS commande*. Spécifiez la clé KMS source, qui déchiffre le texte chiffré. Le `--source-key-id` paramètre n'est pas obligatoire lors du déchiffrement à l'aide de clés KMS de chiffrement symétriques. AWS KMS peut obtenir la clé KMS qui a été utilisée pour chiffrer les données à partir des métadonnées du blob de texte chiffré. Toutefois, la spécification de la clé KMS que vous utilisez est une bonne pratique. Cette pratique garantit que vous utilisez la clé KMS que vous avez l’intention d’utiliser et vous empêche de déchiffrer par inadvertance un texte chiffré à l’aide d’une clé KMS non fiable. Spécifiez la clé KMS de destination, qui rechiffre les données. Le paramètre `--destination-key-id` est toujours obligatoire. Cet exemple utilise un ARN de clé, mais vous pouvez utiliser n’importe quel identifiant de clé valide. Demandez la sortie en texte brut sous forme de valeur de texte. Le paramètre `--query` indique à l’interface de ligne de commande (CLI) de n’obtenir que la valeur du champ `Plaintext` à partir de la sortie. Le paramètre `--output` renvoie la sortie sous forme de texte. Base64 décode le texte brut et l’enregistre dans un fichier. L’exemple suivant conduit (\$1) la valeur du paramètre `Plaintext` à l’utilitaire Base64, qui la décode. Ensuite, il redirige (>) la sortie décodée vers le fichier `ExamplePlaintext`.
Avant d'exécuter cette commande, remplacez l'exemple de clé par IDs des identifiants de clé valides provenant de votre AWS compte.
```
aws kms re-encrypt \
--ciphertext-blob fileb://ExampleEncryptedFile \
--source-key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--destination-key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
--query CiphertextBlob \
--output text | base64 --decode > ExampleReEncryptedFile
```
Cette commande ne produit aucune sortie. La sortie de la commande `re-encrypt` est décodée en base64 et enregistrée dans un fichier.
Pour plus d'informations, consultez la *référence [ReEncrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html)de l'API du service de gestion des AWS clés*.
**Exemple 2 : pour rechiffrer un message chiffré sous une autre clé KMS symétrique (invite de commande Windows)**
L’exemple de commande `re-encrypt` suivant est identique au précédent, sauf qu’il utilise l’utilitaire `certutil` pour décoder les données en texte brut en Base64. Cette procédure requiert deux commandes, comme indiqué dans les exemples suivants.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.
```
aws kms re-encrypt ^
--ciphertext-blob fileb://ExampleEncryptedFile ^
--source-key-id 1234abcd-12ab-34cd-56ef-1234567890ab ^
--destination-key-id 0987dcba-09fe-87dc-65ba-ab0987654321 ^
--query CiphertextBlob ^
--output text > ExampleReEncryptedFile.base64
```
Ensuite, utilisez l’utilitaire `certutil`
```
certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile
```
Sortie :
```
Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.
```
Pour plus d'informations, consultez la *référence [ReEncrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html)de l'API du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [ReEncrypt](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/re-encrypt.html)à la section *Référence des AWS CLI commandes*.
### `retire-grant`
L'exemple de code suivant montre comment utiliser`retire-grant`.
**AWS CLI**
**Pour mettre hors service un octroi sur la clé principale d’un client**
L’exemple `retire-grant` suivant supprime un octroi d’une clé KMS.
L’exemple de commande suivant spécifie les paramètres `grant-id` et `key-id`. La valeur du paramètre `key-id` doit être l’ARN de clé de la clé KMS.
```
aws kms retire-grant \
--grant-id 1234a2345b8a4e350500d432bccf8ecd6506710e1391880c4f7f7140160c9af3 \
--key-id arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
```
Cette commande ne produit aucune sortie. Pour confirmer que l’octroi a été résilié, utilisez la commande `list-grants`.
Pour plus d’informations, consultez [Retrait et révocation d’octrois](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#grant-delete) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [RetireGrant](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/retire-grant.html)à la section *Référence des AWS CLI commandes*.
### `revoke-grant`
L'exemple de code suivant montre comment utiliser`revoke-grant`.
**AWS CLI**
**Pour révoquer un octroi sur la clé principale d’un client**
L’exemple `revoke-grant` suivant supprime un octroi d’une clé KMS. L’exemple de commande suivant spécifie les paramètres `grant-id` et `key-id`. La valeur du paramètre `key-id` peut être l’ID de clé ou l’ARN de clé de la clé KMS.
```
aws kms revoke-grant \
--grant-id 1234a2345b8a4e350500d432bccf8ecd6506710e1391880c4f7f7140160c9af3 \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Cette commande ne produit aucune sortie. Pour confirmer que l’octroi a été révoqué, utilisez la commande `list-grants`.
Pour plus d’informations, consultez [Retrait et révocation d’octrois](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#grant-delete) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [RevokeGrant](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/revoke-grant.html)à la section *Référence des AWS CLI commandes*.
### `rotate-key-on-demand`
L'exemple de code suivant montre comment utiliser`rotate-key-on-demand`.
**AWS CLI**
**Pour effectuer la rotation à la demande d’une clé KMS**
L’exemple `rotate-key-on-demand` suivant lance immédiatement la rotation des éléments de clé pour la clé KMS spécifiée.
```
aws kms rotate-key-on-demand \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Sortie :
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab"
}
```
Pour plus d’informations, consultez [How to perform on-demand key rotation](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html#rotating-keys-on-demand) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [RotateKeyOnDemand](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/rotate-key-on-demand.html)à la section *Référence des AWS CLI commandes*.
### `schedule-key-deletion`
L'exemple de code suivant montre comment utiliser`schedule-key-deletion`.
**AWS CLI**
**Pour planifier la suppression d’une clé KMS gérée par le client**
L’exemple `schedule-key-deletion` suivant planifie la suppression de la clé KMS gérée par le client spécifiée dans les 15 jours.
Le paramètre `--key-id` identifie la clé KMS. Cet exemple utilise une valeur ARN de clé, mais vous pouvez utiliser l’ID de clé ou l’ARN de la clé KMS. Le paramètre `--pending-window-in-days` indique la durée de la période d’attente de 7 à 30 jours. La période d’attente par défaut est de 30 jours. Cet exemple indique une valeur de 15, qui indique de AWS supprimer définitivement la clé KMS 15 jours après la fin de la commande.
```
aws kms schedule-key-deletion \
--key-id arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab \
--pending-window-in-days 15
```
La réponse inclut l’ARN de la clé, le statut de la clé, la période d’attente (`PendingWindowInDays`) et la date de suppression en heure Unix. Pour afficher la date de suppression en heure locale, utilisez la console AWS KMS. Il n’est pas possible d’utiliser des clés KMS avec le statut de clé `PendingDeletion` dans les opérations cryptographiques.
```
{
"KeyId": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"DeletionDate": "2022-06-18T23:43:51.272000+00:00",
"KeyState": "PendingDeletion",
"PendingWindowInDays": 15
}
```
Pour plus d’informations, consultez [Suppression des clés](https://docs.aws.amazon.com/kms/latest/developerguide/deleting-keys.html) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [ScheduleKeyDeletion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/schedule-key-deletion.html)à la section *Référence des AWS CLI commandes*.
### `sign`
L'exemple de code suivant montre comment utiliser`sign`.
**AWS CLI**
**Exemple 1 : pour générer une signature numérique pour un message**
L’exemple `sign` suivant génère une signature cryptographique pour un message court. La sortie de la commande inclut un champ `Signature` encodé en base-64 que vous pouvez vérifier à l’aide de la commande `verify`.
Vous devez spécifier un message à signer et un algorithme de signature pris en charge par votre clé KMS asymétrique. Pour obtenir les algorithmes pour votre clé KMS, utilisez la commande `describe-key`.
Dans la AWS CLI v2, la valeur du `message` paramètre doit être codée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le `fileb://` préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est SIGN\$1VERIFY.
```
msg=(echo 'Hello World' | base64)
aws kms sign \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--message fileb://UnsignedMessage \
--message-type RAW \
--signing-algorithm RSASSA_PKCS1_V1_5_SHA_256
```
Sortie :
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"Signature": "ABCDEFhpyVYyTxbafE74ccSvEJLJr3zuoV1Hfymz4qv+/fxmxNLA7SE1SiF8lHw80fKZZ3bJ...",
"SigningAlgorithm": "RSASSA_PKCS1_V1_5_SHA_256"
}
```
Pour plus d'informations sur l'utilisation de clés KMS asymétriques dans AWS KMS, voir [Clés asymétriques dans AWS KMS dans](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) le Guide du *développeur du service de gestion des AWS clés*.
**Exemple 2 : pour enregistrer une signature numérique dans un fichier (Linux et macOS)**
L’exemple `sign` suivant génère une signature cryptographique pour un message court stocké dans un fichier local. La commande obtient également la `Signature` propriété à partir de la réponse, la décode en Base64 et l'enregistre dans le fichier. ExampleSignature Vous pouvez utiliser le fichier de signature dans une commande `verify` qui vérifie la signature.
La commande `sign` nécessite un message encodé en Base64 et un algorithme de signature pris en charge par votre clé KMS asymétrique. Pour obtenir les algorithmes de signature pris en charge par votre clé KMS, utilisez la commande `describe-key`.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est SIGN\$1VERIFY.
```
echo 'hello world' | base64 > EncodedMessage
aws kms sign \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--message fileb://EncodedMessage \
--message-type RAW \
--signing-algorithm RSASSA_PKCS1_V1_5_SHA_256 \
--output text \
--query Signature | base64 --decode > ExampleSignature
```
Cette commande ne produit aucune sortie. Cet exemple récupère la propriété `Signature` de la sortie et l’enregistre dans un fichier.
Pour plus d'informations sur l'utilisation de clés KMS asymétriques dans AWS KMS, voir [Clés asymétriques dans AWS KMS dans](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) le Guide du *développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l’API, consultez [Sign](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/sign.html) dans la *Référence des commandes de l’AWS CLI *.
### `tag-resource`
L'exemple de code suivant montre comment utiliser`tag-resource`.
**AWS CLI**
**Pour ajouter une balise à une clé KMS**
L’exemple `tag-resource` suivant ajoute des balises `"Purpose":"Test"` et `"Dept":"IT"` à une clé KMS gérée par le client. Vous pouvez utiliser de telles balises pour étiqueter les clés KMS et créer des catégories de clés KMS à des fins d’autorisation et d’audit.
Pour spécifier la clé KMS, utilisez le paramètre `key-id`. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser un ID de clé ou un ARN de clé dans cette commande.
```
aws kms tag-resource \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--tags TagKey='Purpose',TagValue='Test' TagKey='Dept',TagValue='IT'
```
Cette commande ne produit aucune sortie. Pour afficher les balises d'une clé AWS KMS KMS, utilisez la `list-resource-tags` commande.
Pour plus d'informations sur l'utilisation des balises dans AWS KMS, consultez la section [Balisage des clés](https://docs.aws.amazon.com/kms/latest/developerguide/tagging-keys.html) dans le *Guide du développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/tag-resource.html)à la section *Référence des AWS CLI commandes*.
### `untag-resource`
L'exemple de code suivant montre comment utiliser`untag-resource`.
**AWS CLI**
**Pour supprimer une balise d’une clé KMS**
L’exemple `untag-resource` suivant supprime la balise contenant la clé `"Purpose"` d’une clé KMS gérée par le client.
Pour spécifier la clé KMS, utilisez le paramètre `key-id`. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser un ID de clé ou un ARN de clé dans cette commande. Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.
```
aws kms untag-resource \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--tag-key 'Purpose'
```
Cette commande ne produit aucune sortie. Pour afficher les balises d'une clé AWS KMS KMS, utilisez la `list-resource-tags` commande.
Pour plus d'informations sur l'utilisation des balises dans AWS KMS, consultez la section [Balisage des clés](https://docs.aws.amazon.com/kms/latest/developerguide/tagging-keys.html) dans le *Guide du développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/untag-resource.html)à la section *Référence des AWS CLI commandes*.
### `update-alias`
L'exemple de code suivant montre comment utiliser`update-alias`.
**AWS CLI**
**Pour associer un alias à une autre clé KMS**
L’exemple `update-alias` suivant associe l’alias `alias/test-key` à une autre clé KMS.
Le paramètre `--alias-name` spécifie l’alias. La valeur du nom d’alias doit commencer par `alias/` .Le paramètre `--target-key-id` spécifie la clé KMS à associer à l’alias. Vous n’avez pas besoin de spécifier la clé KMS actuelle pour l’alias.
```
aws kms update-alias \
--alias-name alias/test-key \
--target-key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Cette commande ne produit aucune sortie. Pour trouver l’alias, utilisez la commande `list-aliases`.
Pour plus d’informations, consultez [Mise à jour des alias](https://docs.aws.amazon.com/kms/latest/developerguide/alias-manage.html#alias-update) dans le *Guide du développeur AWS Key Management Service*.
+ Pour plus de détails sur l'API, reportez-vous [UpdateAlias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/update-alias.html)à la section *Référence des AWS CLI commandes*.
### `update-custom-key-store`
L'exemple de code suivant montre comment utiliser`update-custom-key-store`.
**AWS CLI**
**Exemple 1 : pour modifier le nom convivial d’un magasin de clés personnalisé**
L’exemple `update-custom-key-store` suivant modifie le nom du magasin de clés personnalisé. Cet exemple fonctionne pour un magasin de clés AWS CloudHSM ou un magasin de clés externe.
Utilisez `custom-key-store-id` pour identifier le magasin de clés. Utilisez le paramètre `new-custom-key-store-name` pour spécifier le nouveau nom convivial.
Pour mettre à jour le nom convivial d'un magasin de clés AWS CloudHSM, vous devez d'abord le déconnecter, par exemple à l'aide de la commande. `disconnect-custom-key-store` Vous pouvez modifier le nom convivial d’un magasin de clés externe lorsqu’il est connecté ou déconnecté. Pour déterminer l’état de connexion de votre magasin de clés personnalisé, utilisez la commande `describe-custom-key-store`.
```
aws kms update-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0 \
--new-custom-key-store-name ExampleKeyStore
```
Cette commande ne renvoie aucune donnée. Pour vérifier que la commande a fonctionné, utilisez une commande `describe-custom-key-stores`.
*Pour plus d'informations sur la mise à jour d'un magasin de clés AWS CloudHSM, consultez la section [Modification des paramètres du magasin de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés](https://docs.aws.amazon.com/kms/latest/developerguide/update-keystore.html).AWS *
Pour plus d’informations sur la mise à jour d’un magasin de clés externe, consultez [Editing external key store properties](https://docs.aws.amazon.com/kms/latest/developerguide/update-xks-keystore.html) dans le *Guide du développeur AWS Key Management Service *.
**Exemple 2 : pour modifier le mot de passe kmsuser d'un magasin de clés CloudHSM AWS **
L’exemple `update-custom-key-store` suivant met à jour la valeur du mot de passe `kmsuser` par le mot de passe actuel de `kmsuser` dans le cluster CloudHSM associé au magasin de clés spécifié. Cette commande ne modifie pas le mot de passe `kmsuser` du cluster. Il indique simplement à AWS KMS le mot de passe actuel. Si KMS ne possède pas le mot de `kmsuser` passe actuel, il ne peut pas se connecter au magasin de AWS clés CloudHSM.
**REMARQUE :** Avant de mettre à jour un magasin de clés AWS CloudHSM, vous devez le déconnecter. Utilisez la commande `disconnect-custom-key-store`. Une fois la commande terminée, vous pouvez reconnecter le magasin de clés AWS CloudHSM. Utilisez la commande `connect-custom-key-store`.
```
aws kms update-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0 \
--key-store-password ExamplePassword
```
Cette commande ne renvoie aucune sortie. Pour vérifier que la modification est en vigueur, utilisez la commande `describe-custom-key-stores`.
*Pour plus d'informations sur la mise à jour d'un magasin de clés AWS CloudHSM, consultez la section [Modification des paramètres du magasin de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés](https://docs.aws.amazon.com/kms/latest/developerguide/update-keystore.html).AWS *
**Exemple 3 : pour modifier le cluster AWS CloudHSM d'un AWS magasin de clés CloudHSM**
L'exemple suivant remplace le cluster AWS CloudHSM associé à un magasin de clés AWS CloudHSM par un cluster apparenté, tel qu'une sauvegarde différente du même cluster.
**REMARQUE :** Avant de mettre à jour un magasin de clés AWS CloudHSM, vous devez le déconnecter. Utilisez la commande `disconnect-custom-key-store`. Une fois la commande terminée, vous pouvez reconnecter le magasin de clés AWS CloudHSM. Utilisez la commande `connect-custom-key-store`.
```
aws kms update-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0 \
--cloud-hsm-cluster-id cluster-1a23b4cdefg
```
Cette commande ne renvoie aucune sortie. Pour vérifier que la modification est en vigueur, utilisez la commande `describe-custom-key-stores`.
*Pour plus d'informations sur la mise à jour d'un magasin de clés AWS CloudHSM, consultez la section [Modification des paramètres du magasin de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés](https://docs.aws.amazon.com/kms/latest/developerguide/update-keystore.html).AWS *
**Exemple 4 : pour modifier les informations d’identification pour l’authentification du proxy d’un magasin de clés externe**
L’exemple suivant met à jour les informations d’identification pour l’authentification du proxy pour votre magasin de clés externe. Vous devez spécifier à la fois `raw-secret-access-key` et `access-key-id`, même si vous ne modifiez qu’une seule des valeurs. Vous pouvez utiliser cette fonctionnalité pour corriger des informations d’identification non valides ou pour les modifier lorsque le proxy du magasin de clés externe les soumet immédiatement à une rotation.
Établissez les informations d'identification d'authentification proxy pour AWS KMS sur votre magasin de clés externe. Utilisez ensuite cette commande pour fournir les informations d'identification à AWS KMS. AWS KMS utilise ces informations d'identification pour signer ses demandes à votre proxy de stockage de clés externe.
Vous pouvez mettre à jour les informations d’identification pour l’authentification du proxy lorsque le magasin de clés externe est connecté ou déconnecté. Pour déterminer l’état de connexion de votre magasin de clés personnalisé, utilisez la commande `describe-custom-key-store`.
```
aws kms update-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0 \
--xks-proxy-authentication-credential "AccessKeyId=ABCDE12345670EXAMPLE, RawSecretAccessKey=DXjSUawnel2fr6SKC7G25CNxTyWKE5PF9XX6H/u9pSo="
```
Cette commande ne renvoie aucune sortie. Pour vérifier que la modification est en vigueur, utilisez la commande `describe-custom-key-stores`.
Pour plus d’informations sur la mise à jour d’un magasin de clés externe, consultez [Editing external key store properties](https://docs.aws.amazon.com/kms/latest/developerguide/update-xks-keystore.html) dans le *Guide du développeur AWS Key Management Service *.
**Exemple 5 : pour modifier la connectivité du proxy d’un magasin de clés externe**
L’exemple suivant modifie l’option de connectivité du proxy du magasin de clés externe, qui passe d’une connectivité au point de terminaison public à une connectivité au service de point de terminaison d’un VPC. Outre la modification de la valeur `xks-proxy-connectivity`, vous devez modifier la valeur `xks-proxy-uri-endpoint` afin de refléter le nom DNS privé associé au service de point de terminaison d’un VPC. Vous devez également ajouter une valeur `xks-proxy-vpc-endpoint-service-name`.
**REMARQUE :** avant de mettre à jour la connectivité du proxy d’un magasin externe, vous devez le déconnecter. Utilisez la commande `disconnect-custom-key-store`. Une fois la commande terminée, vous pouvez reconnecter le magasin de clés externe à l’aide de la commande `connect-custom-key-store`.
```
aws kms update-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0 \
--xks-proxy-connectivity VPC_ENDPOINT_SERVICE \
--xks-proxy-uri-endpoint "https://myproxy-private.xks.example.com" \
--xks-proxy-vpc-endpoint-service-name "com.amazonaws.vpce.us-east-1.vpce-svc-example"
```
Cette commande ne renvoie aucune sortie. Pour vérifier que la modification est en vigueur, utilisez la commande `describe-custom-key-stores`.
Pour plus d’informations sur la mise à jour d’un magasin de clés externe, consultez [Editing external key store properties](https://docs.aws.amazon.com/kms/latest/developerguide/update-xks-keystore.html) dans le *Guide du développeur AWS Key Management Service *.
+ Pour plus de détails sur l'API, reportez-vous [UpdateCustomKeyStore](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/update-custom-key-store.html)à la section *Référence des AWS CLI commandes*.
### `update-key-description`
L'exemple de code suivant montre comment utiliser`update-key-description`.
**AWS CLI**
**Exemple 1 : pour ajouter ou modifier une description à une clé KMS gérée par le client**
L’exemple `update-key-description` suivant ajoute une description à une clé KMS gérée par le client. Vous pouvez utiliser la même commande pour modifier une description existante.
Le paramètre `--key-id` identifie la clé KMS dans la commande. Cet exemple utilise une valeur ARN de clé, mais vous pouvez utiliser l’ID de clé ou l’ARN de la clé KMS. Le paramètre `--description` spécifie la nouvelle description. La valeur de ce paramètre remplace la description actuelle de la clé KMS, le cas échéant.
```
aws kms update-key-description \
--key-id arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab \
--description "IT Department test key"
```
Cette commande ne produit aucune sortie. Pour afficher la description d’une clé KMS, utilisez la commande `describe-key`.
Pour plus d'informations, consultez la *référence [UpdateKeyDescription](https://docs.aws.amazon.com/cli/latest/reference/kms/update-key-description.html)de l'API du service de gestion des AWS clés*.
**Exemple 2 : pour supprimer la description d’une clé KMS gérée par le client**
L’exemple `update-key-description` suivant supprime la description d’une clé KMS gérée par le client.
Le paramètre `--key-id` identifie la clé KMS dans la commande. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser l’ID de clé ou l’ARN de la clé KMS. Le paramètre `--description` avec une valeur de chaîne vide (’’) supprime la description existante.
```
aws kms update-key-description \
--key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
--description ''
```
Cette commande ne produit aucune sortie. Pour afficher la description d’une clé KMS, utilisez la commande describe-key.
Pour plus d'informations, consultez la *référence [UpdateKeyDescription](https://docs.aws.amazon.com/cli/latest/reference/kms/update-key-description.html)de l'API du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [UpdateKeyDescription](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/update-key-description.html)à la section *Référence des AWS CLI commandes*.
### `verify-mac`
L'exemple de code suivant montre comment utiliser`verify-mac`.
**AWS CLI**
**Exemple 1 : pour vérifier un HMAC**
La commande `verify-mac` suivante vérifie un HMAC pour un message particulier, des clés KMS HMAC et un algorithme MAC. La valeur « true » dans la MacValid réponse indique que le HMAC est valide.
Dans la AWS CLI v2, la valeur du `message` paramètre doit être codée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le `fileb://` préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.
Le MAC que vous spécifiez ne peut pas être encodé en base64. Pour obtenir de l’aide pour décoder le MAC renvoyé par la commande `generate-mac`, consultez les exemples de commandes `generate-mac`.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS HMAC avec comme utilisation de `GENERATE_VERIFY_MAC`.
```
msg=(echo 'Hello World' | base64)
aws kms verify-mac \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--message fileb://Message \
--mac-algorithm HMAC_SHA_384 \
--mac fileb://ExampleMac
```
Sortie :
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"MacValid": true,
"MacAlgorithm": "HMAC_SHA_384"
}
```
Pour plus d'informations sur l'utilisation des clés HMAC KMS dans AWS KMS, consultez la section [Clés HMAC dans AWS KMS dans](https://docs.aws.amazon.com/kms/latest/developerguide/hmac.html) le Guide du *développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l'API, reportez-vous [VerifyMac](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/verify-mac.html)à la section *Référence des AWS CLI commandes*.
### `verify`
L'exemple de code suivant montre comment utiliser`verify`.
**AWS CLI**
**Pour vérifier une signature numérique**
La commande `verify` suivante vérifie la signature cryptographique d’un court message encodé en Base64. L’ID de clé, le message, le type de message et l’algorithme de signature doivent être identiques à ceux utilisés pour signer le message.
Dans la AWS CLI v2, la valeur du `message` paramètre doit être codée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le `fileb://` préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.
La signature que vous spécifiez ne peut pas être encodée en base64. Pour obtenir de l’aide pour décoder la signature renvoyée par la commande `sign`, consultez les exemples de commandes `sign`.
La sortie de la commande inclut un champ `SignatureValid` booléen qui indique que la signature a été vérifiée. Si la validation de la signature échoue, la commande `verify` échoue également.
Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.
```
aws kms verify \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--message fileb://EncodedMessage \
--message-type RAW \
--signing-algorithm RSASSA_PKCS1_V1_5_SHA_256 \
--signature fileb://ExampleSignature
```
Sortie :
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"SignatureValid": true,
"SigningAlgorithm": "RSASSA_PKCS1_V1_5_SHA_256"
}
```
Pour plus d'informations sur l'utilisation de clés KMS asymétriques dans AWS KMS, consultez la section [Utilisation de clés asymétriques](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) dans le Guide du *développeur du service de gestion des AWS clés*.
+ Pour plus de détails sur l’API, consultez [Verify](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/verify.html) dans la *Référence des commandes de l’AWS CLI *.