Exemples d’utilisation de l’AWS CLI avec AWS KMS

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é dans le Manuel du développeur AWS Key Management Service.

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 Connecting and disconnecting an AWS CloudHSM key store dans le Manuel du développeur AWS Key Management Service.

Pour plus d’informations sur la connexion d’un magasin de clés externe, consultez Connecter et déconnecter un magasin de clés externe dans le Manuel du développeur AWS Key Management Service.

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 dans le Manuel du développeur AWS Key Management Service.

Exemple 1 : pour créer un magasin de clés AWS CloudHSM

L’exemple create-custom-key-store 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 commande trust-anchor-certificate dans l’interface de ligne de commande (CLI) AWS, le préfixe file:// 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 Creating an AWS CloudHSM key store dans le Manuel du développeur AWS Key Management Service.

Exemple 2 : pour créer un magasin de clés externe avec une connectivité au point de terminaison public

L’exemple create-custom-key-store 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 l’interface de ligne de commande (CLI) AWS version 1.0, exécutez la commande suivante avant de spécifier un paramètre avec une valeur HTTP ou HTTPS, tel que le paramètre XksProxyUriEndpoint.

aws configure set cli_follow_urlparam false

Sinon, l’interface de ligne de commande (CLI) AWS version 1.0 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éer un magasin de clés externe 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’exemple create-custom-key-store 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 l’interface de ligne de commande (CLI) AWS version 1.0, exécutez la commande suivante avant de spécifier un paramètre avec une valeur HTTP ou HTTPS, tel que le paramètre XksProxyUriEndpoint.

aws configure set cli_follow_urlparam false

Sinon, l’interface de ligne de commande (CLI) AWS version 1.0 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éer un magasin de clés externe dans le Manuel du développeur AWS Key Management Service.

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": "<grant token here>"
}

Pour afficher des informations détaillées sur l’octroi, utilisez la commande list-grants.

Pour plus d’informations, consultez Grants in AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 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 dans le Manuel 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 Clés asymétriques dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 Clés asymétriques dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 Clés asymétriques dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 Clés HMAC dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

Exemple 6 : pour créer une clé KMS primaire multi-régions

L’exemple create-key suivant crée une clé de chiffrement symétrique primaire multi-régions. É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 l’interface de ligne de commande (CLI) AWS, 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 Clés asymétriques dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 Importation des éléments de clé dans les clés AWS KMS dans le Manuel du développeur AWS Key Management Service.

Exemple 6 : pour créer une clé KMS dans un magasin de clés AWS CloudHSM

L’exemple create-key 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 les éléments de 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 dans le Manuel 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 dans le Manuel du développeur AWS Key Management Service.

Exemple 1 : pour déchiffrer un message chiffré avec une clé KMS symétrique (Linux et macOS)

L’exemple de commande decrypt suivant illustre la méthode recommandée pour déchiffrer des données à l’aide de l’interface de ligne de commande (CLI) AWS. 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 l’interface de ligne de commande (CLI) AWS à partir d’un fichier, consultez Chargement des paramètres d’AWS CLI à partir d’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 commande AWS et Best Practices for Local File Parameters<https://aws.amazon.com/blogs/developer/best-practices-for-local-file-parameters/> dans le Blog de l’outil de ligne de commande AWS. Spécifiez la clé KMS pour déchiffrer le texte chiffré. Le paramètre --key-id n’est pas nécessaire lors du déchiffrement avec une clé KMS symétrique. 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 (|) 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 compte AWS.

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 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 compte AWS.

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 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 compte AWS.

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 Clés asymétriques dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

Pour supprimer un alias AWS KMS

L’exemple delete-alias suivant supprime l’alias alias/example-alias. Le nom d’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 dans le Manuel du développeur AWS Key Management Service.

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 afin de trouver les clés KMS dans votre magasin de clés personnalisé, consultez Suppression d’un magasin de clés AWS CloudHSM (API) dans le Manuel du développeur AWS Key Management Service.

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’un magasin de clés AWS CloudHSM, consultez Deleting an AWS CloudHSM key store dans le Manuel du développeur AWS Key Management Service.

Pour plus d’informations sur la suppression de magasins de clés externes, consultez Supprimer un magasin de clés externe dans le Manuel du développeur AWS Key Management Service.

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 dans le Manuel du développeur AWS Key Management Service.

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étriques de courbe elliptique (ECC) ou SM2 (régions de Chine uniquement) recommandée par le NIST avec une valeur KeyUsage de KEY_AGREEMENT pour appeler 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 DeriveSharedSecret dans la Référence des API d’AWS Key Management Service.

Exemple 1 : pour obtenir les informations sur un magasin de clés AWS CloudHSM

L’exemple describe-custom-key-store suivant affiche les informations 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": "<certificate appears here>"
        }
    ]
}

Pour plus d’informations, consultez Viewing an AWS CloudHSM key store dans le Manuel du développeur AWS Key Management Service.

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 les 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 Afficher un magasin de clés externe 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 les 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 Afficher un magasin de clés externe dans le Manuel du développeur AWS Key Management Service.

Exemple 1 : pour obtenir des informations détaillées sur une clé KMS

L’exemple describe-key suivant fournit les informations détaillées sur la clé gérée par AWS 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 gérées par AWS 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 dans le Manuel du développeur AWS Key Management Service.

Exemple 2 : pour obtenir les informations sur une clé KMS asymétrique RSA

L’exemple describe-key suivant fournit les 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 les informations sur une clé de réplica multi-régions

L’exemple describe-key suivant fournit des métadonnées pour une clé de réplica multi-régions. Cette clé multi-régions est une clé de chiffrement symétrique. La sortie d’une commande describe-key pour une clé multi-régions 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 les informations sur une clé KMS HMAC

L’exemple describe-key suivant fournit les 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 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 dans le Manuel du développeur AWS Key Management Service.

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 dans le Manuel du développeur AWS Key Management Service.

Pour déconnecter un magasin de clés personnalisé

L’exemple disconnect-custom-key-store 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 la même 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 Connecting and disconnecting an AWS CloudHSM key store dans le Manuel du développeur AWS Key Management Service.

Pour plus d’informations sur la déconnexion d’un magasin de clés externe, consultez Connecter et déconnecter un magasin de clés externe dans le Manuel du développeur AWS Key Management Service.

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 dans le Manuel du développeur AWS Key Management Service.

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 dans le Manuel du développeur AWS Key Management Service.

Exemple 1 : pour chiffrer le contenu d’un fichier sous Linux ou macOS

La commande encrypt suivant illustre la méthode recommandée pour chiffrer des données à l’aide de l’interface de ligne de commande (CLI) AWS.

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 encodée en base64. La valeur du paramètre plaintext doit être encodée en base64, ou vous devez utiliser le préfixe fileb://, qui indique à l’interface de ligne de commande (CLI) AWS de lire les données binaires du fichier. Si le fichier ne se trouve pas dans le répertoire actuel, saisissez 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 l’interface de ligne de commande (CLI) AWS à partir d’un fichier, consultez Chargement des paramètres à partir d’un fichier dans le Guide de l’utilisateur de l’interface de ligne de commande (CLI) AWS et Best Practices for Local File Parameters dans le Blog de l’outil de ligne de commande AWS. Utilise les paramètres --output et --query pour contrôler la sortie de la commande. Ces 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, consultez Contrôle de la sortie de commande dans le Guide de l’utilisateur de l’interface de ligne de commande AWS. Utilise l’utilitaire base64 pour décoder la sortie extraite en données binaires. Le texte chiffré renvoyé par une commande encrypt réussie est du texte encodé en base64. Vous devez décoder ce texte avant de pouvoir utiliser l’interface de ligne de commande (CLI) AWS pour le déchiffrer. Enregistrez 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 l’interface de ligne de commande (CLI) AWS pour déchiffrer des données, consultez les exemples de déchiffrement.

Exemple 2 : utilisation de l’interface de ligne de commande (CLI) AWS 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 l’interface de ligne de commande (CLI) encrypt, le paramètre plaintext doit être encodé en base64, ou vous devez utiliser le préfixe fileb://, qui indique à l’interface de ligne de commande (CLI) AWS 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 générer une paire de clés de données asymétriques ECC NIST P384

L’exemple generate-data-key-pair-without-plaintext suivant demande une paire de clés ECC NIST P384 pour une utilisation en dehors d’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 la 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 dans le Manuel du développeur AWS Key Management Service.

Pour générer une paire de clés de données asymétriques RSA de 2048 bits

L’exemple generate-data-key-pair suivant demande une paire de clés de données asymétriques RSA de 2048 bits pour une utilisation en dehors d’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 2048 bits, utilisez le paramètre key-pair-spec avec la 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 dans le Manuel du développeur AWS Key Management Service.

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 la valeur AES_256. Pour demander une clé de données de 128 bits, utilisez le paramètre key-spec avec la 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_DEFAULT.

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"
}

La valeur CiphertextBlob (clé de données chiffrée) est renvoyée au format encodé en base64.

Pour plus d’informations, consultez Clés de données dans le Manuel du développeur AWS Key Management Service.

Exemple 1 : pour générer une clé de données symétrique de 256 bits

L’exemple generate-data-key suivant demande une clé de données symétrique de 256 bits pour une utilisation en dehors d’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 la valeur AES_256. Pour demander une clé de données de 128 bits, utilisez le paramètre key-spec avec la 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_DEFAULT.

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="
}

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 dans le Manuel 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_DEFAULT.

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 dans le Manuel du développeur AWS Key Management Service.

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 l’interface de ligne de commande (CLI) AWS v2, la valeur du paramètre message doit être encodée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le préfixe fileb://, qui indique à l’interface de ligne de commande (CLI) AWS 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 compte AWS. L’ID de clé doit représenter une clé KMS HMAC dont l’utilisation de la clé est 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": "<HMAC_TAG>",
    "MacAlgorithm": "HMAC_SHA_384"
}

Pour plus d’informations sur l’utilisation des clés KMS HMAC dans AWS KMS, consultez Clés HMAC dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 récupère également la propriété Mac 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 compte AWS. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est GENERATE_VERIFY_MAC.

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 KMS HMAC dans AWS KMS, consultez Clés HMAC dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

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é, 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 paramètre --number-of-bytes requis avec une valeur de 32 pour demander une chaîne de 32 octets (256 bits). Il utilise le paramètre --output avec une valeur de text pour demander à l’interface de ligne de commande (CLI) AWS de renvoyer la sortie sous forme de texte, au lieu de JSON. Il utilise le paramètre --query parameter pour récupérer la valeur de la propriété Plaintext de la réponse. Il dirige ( | ) la sortie de la commande vers l’utilitaire base64, qui décode la sortie récupérée. Il utilise l’opérateur de redirection ( > ) pour enregistrer la chaîne d’octets décodée dans le fichier ExampleRandom. Il utilise l’opérateur de redirection ( > ) 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 GenerateRandom dans la Référence des API d’AWS Key Management Service.

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 GenerateRandom dans la Référence des API d’AWS Key Management Service.

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 PutKeyPolicy dans la Référence des API d’AWS KMS.

Pour récupérer le statut de rotation d’une clé KMS.

L’exemple get-key-rotation-status suivant renvoie les 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 gérées par AWS. Toutefois, toutes les clés KMS gérées par AWS sont automatiquement soumises à rotation 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 dans le Manuel du développeur AWS Key Management Service.

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": "<public key base64 encoded data>",
    "ImportToken": "<import token base64 encoded data>",
    "ParametersValidTo": 1593893322.32
}

Pour plus d’informations, consultez Download the public key and import token dans le Manuel du développeur AWS Key Management Service.

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, la sortie inclut des informations dont vous avez besoin pour utiliser la clé publique en toute sécurité en dehors d’AWS KMS, y compris 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 des clés KMS asymétriques dans AWS KMS, consultez Clés asymétriques dans AWS KMS dans le Manuel du développeur AWS Key Management Service. 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 commande get-public-key dans l’interface de ligne de commande (CLI) AWS, elle renvoie une clé publique X.509 encodée DER qui est encodé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 paramètre --query fournit uniquement la propriété PublicKey, et non les propriétés dont vous avez besoin pour utiliser la clé publique en toute sécurité en dehors d’AWS KMS.

Avant d’exécuter cette commande, remplacez l’exemple d’ID de clé par un ID de clé valide provenant de votre compte AWS.

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 des clés KMS asymétriques dans AWS KMS, consultez Clés asymétriques dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

Pour importer les éléments de clé dans une clé KMS

L’exemple import-key-material suivant charge des éléments de clé dans une clé KMS créée sans élément de clé. Le statut de la 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 les éléments de clé expirent, AWS KMS supprime les éléments de clé, le statut de la clé KMS passe à Pending import et la clé KMS devient inutilisable. 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 compte AWS.

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é dans le Manuel du développeur AWS Key Management Service.

Exemple 1 : pour répertorier tous les alias d’un compte AWS et d’une région

L’exemple suivant utilise la commande list-aliases pour répertorier tous les alias de la région par défaut du compte AWS. La sortie inclut des alias associés aux clés KMS gérées par AWS 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 dans le Manuel du développeur AWS Key Management Service.

Pour afficher les octrois sur une clé AWS KMS

L’exemple list-grants suivant affiche tous les octrois associés à la clé KMS gérée par AWS 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 octrois relatifs aux clés KMS gérées par AWS et aux clés KMS gérées par le client dans le compte et la région AWS.

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 gérée par AWS, utilisez la commande list-keys ou list-aliases.

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 à résilier les autorisations (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 Grants in AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 obtenir les noms des stratégies de clé pour les clés gérées par AWS et les 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 stratégies de clé AWS KMS, consultez Utilisation de stratégies de clé dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

Pour récupérer les 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 dans le Manuel du développeur AWS Key Management Service.

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 des clés gérées par AWS et des 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 dans le Manuel du développeur AWS Key Management Service.

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 Clés de balisage dans le Manuel du développeur AWS Key Management Service.

Pour afficher les octrois qu’un principal peut résilier

L’exemple list-retirable-grants suivant affiche tous les octrois que l’utilisateur ExampleAdmin peut mettre hors service sur les clés KMS d’un compte et une région AWS. Vous pouvez utiliser une commande comme celle-ci pour afficher les octrois que tout principal de compte peut mettre hors service sur les clés KMS du compte et de la région AWS.

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 Grants in AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 instruction de cette stratégie de clé donne au compte AWS l’autorisation d’utiliser des 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 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 obtient 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é dans le Manuel du développeur AWS Key Management Service.

Exemple 1 : pour rechiffrer un message chiffré sous une autre clé KMS symétrique (Linux et macOS).

L’exemple de commande re-encrypt suivant illustre la méthode recommandée pour rechiffrer les données à l’aide de l’interface de ligne de commande (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 l’interface de ligne de commande (CLI) AWS à partir d’un fichier, consultez Chargement des paramètres d’AWS CLI à partir d’un fichier dans le Guide de l’utilisateur de l’interface de ligne de commande AWS et Best Practices for Local File Parameters dans le Blog de l’outil de ligne de commande AWS. Spécifiez la clé KMS source, qui déchiffre le texte chiffré. Le paramètre --source-key-id 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 (|) 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 des ID de clé valides provenant de votre compte AWS.

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 ReEncrypt dans la Référence des API d’AWS Key Management Service.

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 compte AWS.

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 ReEncrypt dans la Référence des API d’AWS Key Management Service.

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 dans le Manuel du développeur AWS Key Management Service.

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 dans le Manuel du développeur AWS Key Management Service.

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 Comment effectuer une rotation des clés à la demande dans le Manuel du développeur AWS Key Management Service.

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 à AWS de 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 de clés dans le Manuel du développeur AWS Key Management Service.

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 l’interface de ligne de commande (CLI) AWS v2, la valeur du paramètre message doit être encodée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le préfixe fileb://, qui indique à l’interface de ligne de commande (CLI) AWS 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 compte AWS. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est SIGN_VERIFY.

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 des clés KMS asymétriques dans AWS KMS, consultez Clés asymétriques dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 récupère également la propriété Signature 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 compte AWS. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est SIGN_VERIFY.

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 des clés KMS asymétriques dans AWS KMS, consultez Clés asymétriques dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

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, utilisez la commande list-resource-tags.

Pour plus d’informations sur l’utilisation des balises dans AWS KMS, consultez Clés de balisage dans le Manuel du développeur AWS Key Management Service.

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 compte AWS.

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, utilisez la commande list-resource-tags.

Pour plus d’informations sur l’utilisation des balises dans AWS KMS, consultez Clés de balisage dans le Manuel du développeur AWS Key Management Service.

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 dans le Manuel du développeur AWS Key Management Service.

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 Editing AWS CloudHSM key store settings dans le Manuel du développeur AWS Key Management Service.

Pour plus d’informations sur la mise à jour d’un magasin de clés externe, consultez Modifier les propriétés du magasin de clés externe dans le Manuel du développeur AWS Key Management Service.

Exemple 2 : pour modifier le mot de passe kmsuser d’un magasin de clés AWS CloudHSM

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. Elle indique simplement à AWS KMS le mot de passe actuel. Si KMS ne possède pas le mot de passe kmsuser actuel, la connexion au magasin de clés AWS CloudHSM est impossible.

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 Editing AWS CloudHSM key store settings dans le Manuel du développeur AWS Key Management Service.

Exemple 3 : pour modifier le cluster AWS CloudHSM d’un magasin de clés AWS 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 Editing AWS CloudHSM key store settings dans le Manuel du développeur AWS Key Management Service.

Exemple 4 : pour modifier les informations d’identification pour 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 pour l’authentification du 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 ses demandes auprès du proxy de votre magasin 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 Modifier les propriétés du magasin de clés externe dans le Manuel 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 Modifier les propriétés du magasin de clés externe dans le Manuel du développeur AWS Key Management Service.

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 UpdateKeyDescription dans la Référence des API d’AWS Key Management Service.

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 UpdateKeyDescription dans la Référence des API d’AWS Key Management Service.

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 valeur MacValid dans la réponse indique que le HMAC est valide.

Dans l’interface de ligne de commande (CLI) AWS v2, la valeur du paramètre message doit être encodée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le préfixe fileb://, qui indique à l’interface de ligne de commande (CLI) AWS 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 compte AWS. L’ID de clé doit représenter une clé KMS HMAC dont l’utilisation de la clé est 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 KMS HMAC dans AWS KMS, consultez Clés HMAC dans AWS KMS dans le Manuel du développeur AWS Key Management Service.

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 l’interface de ligne de commande (CLI) AWS v2, la valeur du paramètre message doit être encodée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le préfixe fileb://, qui indique à l’interface de ligne de commande (CLI) AWS 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 compte AWS.

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 des clés KMS asymétriques dans AWS KMS, consultez Utilisation de clés asymétriques dans le Manuel du développeur AWS Key Management Service.