AWS KMS exemples utilisant AWS CLI

Pour annuler la suppression planifiée d’une clé KMS gérée par le client

L’exemple cancel-key-deletion suivant annule la suppression planifiée d’une clé KMS gérée par le client.

aws kms cancel-key-deletion \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Sortie :

{
    "KeyId": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}

Lorsque la commande cancel-key-deletion aboutit, la suppression planifiée est annulée. Toutefois, l’état de la clé KMS est Disabled, de sorte que vous ne pouvez pas utiliser la clé KMS dans des opérations de chiffrement. Pour restaurer ses fonctionnalités, utilisez la commande enable-key.

Pour plus d’informations, consultez Planification et annulation d’une suppression de clé dans le Guide 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 la section Connexion et déconnexion d'un magasin de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés.AWS

Pour plus d’informations sur la connexion d’un magasin de clés externe, consultez Connecting and disconnecting an external key store dans le Guide 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 Guide du développeur AWS  Key Management Service.

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

L'create-custom-key-storeexemple suivant crée un magasin de clés AWS CloudHSM soutenu par un cluster AWS CloudHSM à l'aide des paramètres requis. Vous pouvez également ajouter custom-key-store-type``parameter with the default value: ``AWS_CLOUDHSM.

Pour spécifier l'entrée de fichier pour la trust-anchor-certificate commande dans la AWS CLI, le file:// préfixe est obligatoire.

aws kms create-custom-key-store \
    --custom-key-store-name ExampleCloudHSMKeyStore \
    --cloud-hsm-cluster-id cluster-1a23b4cdefg \
    --key-store-password kmsPswd \
    --trust-anchor-certificate file://customerCA.crt

Sortie :

{
    "CustomKeyStoreId": cks-1234567890abcdef0
}

Pour plus d'informations, consultez la section Création d'un magasin de clés AWS CloudHSM dans AWS le Guide du développeur du service de gestion des clés.

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

L'create-custom-key-storeexemple suivant crée un magasin de clés externe (XKS) qui communique avec AWS KMS via Internet.

Dans cet exemple, XksProxyUriPath utilise le préfixe facultatif de example-prefix.

REMARQUE : Si vous utilisez la version 1.0 de la AWS CLI, exécutez la commande suivante avant de spécifier un paramètre avec une valeur HTTP ou HTTPS, tel que le XksProxyUriEndpoint paramètre.

aws configure set cli_follow_urlparam false

Sinon, la version 1.0 de la AWS CLI remplace la valeur du paramètre par le contenu trouvé à cette adresse URI.

aws kms create-custom-key-store \
    --custom-key-store-name ExamplePublicEndpointXKS \
    --custom-key-store-type EXTERNAL_KEY_STORE \
    --xks-proxy-connectivity PUBLIC_ENDPOINT \
    --xks-proxy-uri-endpoint "https://myproxy.xks.example.com" \
    --xks-proxy-uri-path "/example-prefix/kms/xks/v1" \
    --xks-proxy-authentication-credential "AccessKeyId=ABCDE12345670EXAMPLE, RawSecretAccessKey=DXjSUawnel2fr6SKC7G25CNxTyWKE5PF9XX6H/u9pSo="

Sortie :

{
    "CustomKeyStoreId": cks-2234567890abcdef0
}

Pour plus d’informations, consultez Création d’un magasin de clés externe dans le Manuel du développeur AWS  Key Management Service.

Exemple 3 : pour créer un magasin de clés externe avec une connectivité au service de point de terminaison d’un VPC

L'create-custom-key-storeexemple suivant crée un magasin de clés externe (XKS) qui utilise un service de point de terminaison Amazon VPC pour communiquer avec AWS KMS.

REMARQUE : Si vous utilisez la version 1.0 de la AWS CLI, exécutez la commande suivante avant de spécifier un paramètre avec une valeur HTTP ou HTTPS, tel que le XksProxyUriEndpoint paramètre.

aws configure set cli_follow_urlparam false

Sinon, la version 1.0 de la AWS CLI remplace la valeur du paramètre par le contenu trouvé à cette adresse URI.

aws kms create-custom-key-store \
    --custom-key-store-name ExampleVPCEndpointXKS \
    --custom-key-store-type EXTERNAL_KEY_STORE \
    --xks-proxy-connectivity VPC_ENDPOINT_SERVICE \
    --xks-proxy-uri-endpoint "https://myproxy-private.xks.example.com" \
    --xks-proxy-uri-path "/kms/xks/v1" \
    --xks-proxy-vpc-endpoint-service-name "com.amazonaws.vpce.us-east-1.vpce-svc-example1" \
    --xks-proxy-authentication-credential "AccessKeyId=ABCDE12345670EXAMPLE, RawSecretAccessKey=DXjSUawnel2fr6SKC7G25CNxTyWKE5PF9XX6H/u9pSo="

Sortie :

{
    "CustomKeyStoreId": cks-3234567890abcdef0
}

Pour plus d’informations, consultez Création d’un magasin de clés externe 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 la section Subventions dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

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

Exemple 2 : pour créer une clé KMS RSA asymétrique pour le chiffrement et le déchiffrement

L’exemple create-key suivant crée une clé KMS contenant une paire de clés RSA asymétrique pour le chiffrement et le déchiffrement. La spécification de clé et l’utilisation des clés ne peuvent pas être modifiées une fois que la clé est créée :

aws kms create-key \
   --key-spec RSA_4096 \
   --key-usage ENCRYPT_DECRYPT

Sortie :

{
    "KeyMetadata": {
        "Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
        "AWSAccountId": "111122223333",
        "CreationDate": "2021-04-05T14:04:55-07:00",
        "CustomerMasterKeySpec": "RSA_4096",
        "Description": "",
        "Enabled": true,
        "EncryptionAlgorithms": [
            "RSAES_OAEP_SHA_1",
            "RSAES_OAEP_SHA_256"
        ],
        "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
        "KeyManager": "CUSTOMER",
        "KeySpec": "RSA_4096",
        "KeyState": "Enabled",
        "KeyUsage": "ENCRYPT_DECRYPT",
        "MultiRegion": false,
        "Origin": "AWS_KMS"
    }
}

Pour plus d'informations, consultez la section Clés asymétriques dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Exemple 3 : pour créer une clé KMS de courbe elliptique asymétrique pour la signature et la vérification

Pour créer une clé KMS asymétrique contenant une paire de clés de courbe elliptique asymétrique (ECC) pour la signature et la vérification. Le paramètre --key-usage est obligatoire même si SIGN_VERIFY est la seule valeur valide pour les clés KMS ECC. La spécification de clé et l’utilisation des clés ne peuvent pas être modifiées une fois que la clé est créée :

aws kms create-key \
    --key-spec ECC_NIST_P521 \
    --key-usage SIGN_VERIFY

Sortie :

{
    "KeyMetadata": {
        "Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
        "AWSAccountId": "111122223333",
        "CreationDate": "2019-12-02T07:48:55-07:00",
        "CustomerMasterKeySpec": "ECC_NIST_P521",
        "Description": "",
        "Enabled": true,
        "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
        "KeyManager": "CUSTOMER",
        "KeySpec": "ECC_NIST_P521",
        "KeyState": "Enabled",
        "KeyUsage": "SIGN_VERIFY",
        "MultiRegion": false,
        "Origin": "AWS_KMS",
        "SigningAlgorithms": [
            "ECDSA_SHA_512"
        ]
    }
}

Pour plus d'informations, consultez la section Clés asymétriques dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Exemple 4 : pour créer une clé KMS ML-DSA asymétrique pour la signature et la vérification

Cet exemple crée une clé ML-DSA (Module-Lattice Digital Signature Algorithm) pour la signature et la vérification. Le paramètre « utilisation de clé » est obligatoire même si SIGN_VERIFY est la seule valeur valide pour les clés ML-DSA.

aws kms create-key \
    --key-spec ML_DSA_65 \
    --key-usage SIGN_VERIFY

Sortie :

{
    "KeyMetadata": {
        "Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
        "AWSAccountId": "111122223333",
        "CreationDate": "2019-12-02T07:48:55-07:00",
        "Description": "",
        "Enabled": true,
        "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
        "KeyManager": "CUSTOMER",
        "KeySpec": "ML_DSA_65",
        "KeyState": "Enabled",
        "KeyUsage": "SIGN_VERIFY",
        "MultiRegion": false,
        "Origin": "AWS_KMS",
        "SigningAlgorithms": [
            "ML_DSA_SHAKE_256"
        ]
    }
}

Pour plus d'informations, consultez la section Clés asymétriques dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Exemple 5 : pour créer une clé KMS HMAC

L’exemple create-key suivant crée une clé KMS HMAC de 384 bits. La valeur GENERATE_VERIFY_MAC du paramètre --key-usage est obligatoire même s’il s’agit de la seule valeur valide pour les clés KMS HMAC.

aws kms create-key \
    --key-spec HMAC_384 \
    --key-usage GENERATE_VERIFY_MAC

Sortie :

{
    "KeyMetadata": {
        "Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
        "AWSAccountId": "111122223333",
        "CreationDate": "2022-04-05T14:04:55-07:00",
        "CustomerMasterKeySpec": "HMAC_384",
        "Description": "",
        "Enabled": true,
        "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
        "KeyManager": "CUSTOMER",
        "KeySpec": "HMAC_384",
        "KeyState": "Enabled",
        "KeyUsage": "GENERATE_VERIFY_MAC",
        "MacAlgorithms": [
            "HMAC_SHA_384"
        ],
        "MultiRegion": false,
        "Origin": "AWS_KMS"
    }
}

Pour plus d'informations, consultez la section Clés HMAC dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

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

L’exemple create-key suivant crée une clé de chiffrement symétrique primaire multi-région. Étant donné que les valeurs par défaut de tous les paramètres créent une clé de chiffrement symétrique, seul le paramètre --multi-region est requis pour cette clé KMS. Dans la AWS CLI, pour indiquer qu'un paramètre booléen est vrai, il suffit de spécifier le nom du paramètre.

aws kms create-key \
    --multi-region

Sortie :

{
    "KeyMetadata": {
        "Arn": "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef12345678990ab",
        "AWSAccountId": "111122223333",
        "CreationDate": "2021-09-02T016:15:21-09:00",
        "CurrentKeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
        "CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
        "Description": "",
        "Enabled": true,
        "EncryptionAlgorithms": [
          "SYMMETRIC_DEFAULT"
        ],
        "KeyId": "mrk-1234abcd12ab34cd56ef12345678990ab",
        "KeyManager": "CUSTOMER",
        "KeySpec": "SYMMETRIC_DEFAULT",
        "KeyState": "Enabled",
        "KeyUsage": "ENCRYPT_DECRYPT",
        "MultiRegion": true,
        "MultiRegionConfiguration": {
            "MultiRegionKeyType": "PRIMARY",
            "PrimaryKey": {
                "Arn": "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef12345678990ab",
                "Region": "us-west-2"
            },
            "ReplicaKeys": []
        },
        "Origin": "AWS_KMS"
    }
}

Pour plus d'informations, consultez la section Clés asymétriques dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Exemple 7 : pour créer une clé KMS pour les éléments de clé importés

L’exemple create-key suivant crée une clé KMS sans élément de clé. Lorsque l’opération est terminée, vous pouvez importer vos propres éléments de clé dans la clé KMS. Pour créer cette clé KMS, définissez le paramètre --origin sur EXTERNAL.

aws kms create-key \
    --origin EXTERNAL

Sortie :

{
     "KeyMetadata": {
         "Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
         "AWSAccountId": "111122223333",
         "CreationDate": "2019-12-02T07:48:55-07:00",
         "CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
         "Description": "",
         "Enabled": false,
         "EncryptionAlgorithms": [
             "SYMMETRIC_DEFAULT"
         ],
         "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
         "KeyManager": "CUSTOMER",
         "KeySpec": "SYMMETRIC_DEFAULT",
         "KeyState": "PendingImport",
         "KeyUsage": "ENCRYPT_DECRYPT",
         "MultiRegion": false,
         "Origin": "EXTERNAL"
     }
 }

Pour plus d'informations, consultez la section Importation de matériel clé dans les clés AWS KMS dans le guide du développeur du service de gestion des AWS clés.

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

L'create-keyexemple suivant crée une clé KMS dans le magasin de clés AWS CloudHSM spécifié. L'opération crée la clé KMS et ses métadonnées dans AWS KMS et crée le matériel clé dans le cluster AWS CloudHSM associé au magasin de clés personnalisé. Les paramètres --custom-key-store-id et --origin sont obligatoires.

aws kms create-key \
    --origin AWS_CLOUDHSM \
    --custom-key-store-id cks-1234567890abcdef0

Sortie :

{
    "KeyMetadata": {
        "Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
        "AWSAccountId": "111122223333",
        "CloudHsmClusterId": "cluster-1a23b4cdefg",
        "CreationDate": "2019-12-02T07:48:55-07:00",
        "CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
        "CustomKeyStoreId": "cks-1234567890abcdef0",
        "Description": "",
        "Enabled": true,
        "EncryptionAlgorithms": [
            "SYMMETRIC_DEFAULT"
        ],
        "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
        "KeyManager": "CUSTOMER",
        "KeySpec": "SYMMETRIC_DEFAULT",
        "KeyState": "Enabled",
        "KeyUsage": "ENCRYPT_DECRYPT",
        "MultiRegion": false,
        "Origin": "AWS_CLOUDHSM"
    }
}

Pour plus d’informations, consultez AWS CloudHSM key stores dans le Guide du développeur AWS  Key Management Service.

Exemple 8 : pour créer une clé KMS dans un magasin de clés externe

L’exemple create-key suivant crée une clé KMS dans le magasin de clés externe spécifié. Les paramètres --custom-key-store-id, --origin et --xks-key-id sont obligatoires dans cette commande.

Le paramètre --xks-key-id indique l’ID d’une clé de chiffrement symétrique existante dans votre gestionnaire de clés externe. Cette clé sert d’élément de clés externe pour la clé KMS. La valeur du paramètre --origin doit être EXTERNAL_KEY_STORE. Le paramètre custom-key-store-id doit identifier un magasin de clés externe connecté à son proxy de magasin de clés externe.

aws kms create-key \
    --origin EXTERNAL_KEY_STORE \
    --custom-key-store-id cks-9876543210fedcba9 \
    --xks-key-id bb8562717f809024

Sortie :

{
    "KeyMetadata": {
        "Arn": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
        "AWSAccountId": "111122223333",
        "CreationDate": "2022-12-02T07:48:55-07:00",
        "CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
        "CustomKeyStoreId": "cks-9876543210fedcba9",
        "Description": "",
        "Enabled": true,
        "EncryptionAlgorithms": [
            "SYMMETRIC_DEFAULT"
        ],
        "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
        "KeyManager": "CUSTOMER",
        "KeySpec": "SYMMETRIC_DEFAULT",
        "KeyState": "Enabled",
        "KeyUsage": "ENCRYPT_DECRYPT",
        "MultiRegion": false,
        "Origin": "EXTERNAL_KEY_STORE",
        "XksKeyConfiguration": {
            "Id": "bb8562717f809024"
        }
    }
}

Pour plus d’informations, consultez Magasins de clés externes dans le Guide 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 decrypt commande suivant illustre la méthode recommandée pour déchiffrer des données à l'aide de la AWS CLI. Cette version montre comment déchiffrer des données sous une clé KMS symétrique.

Fournissez le texte chiffré dans un fichier. Dans la valeur du paramètre --ciphertext-blob, utilisez le préfixe fileb://, qui indique à l’interface de ligne de commande (CLI) de lire les données d’un fichier binaire. Si le fichier ne se trouve pas dans le répertoire actuel, saisissez le chemin complet du fichier. Pour plus d'informations sur la lecture des valeurs des paramètres de la AWS CLI depuis un fichier, consultez la section Chargement des paramètres de la AWS CLI depuis un fichier < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> dans le guide de l'utilisateur de l'interface de ligne de AWS commande et les meilleures pratiques pour les paramètres de fichiers locaux < https://aws.amazon.com/blogs/ developer/ best-practices-for-local -file-parameters/> dans le blog des outils de ligne de AWS commande. Spécifiez la clé KMS pour déchiffrer le texte chiffré. Le paramètre n'est pas obligatoire lors du déchiffrement avec une clé KMS symétrique. --key-id AWS KMS peut obtenir l'ID de la clé KMS qui a été utilisée pour chiffrer les données à partir des métadonnées du texte chiffré. Toutefois, la spécification de la clé KMS que vous utilisez est une bonne pratique. Cette pratique garantit que vous utilisez la clé KMS prévue et vous évite de déchiffrer par inadvertance un texte chiffré à l’aide d’une clé KMS à laquelle vous ne faites pas confiance. Demandez la sortie en texte brut sous forme de texte. Le paramètre --query indique à l’interface de ligne de commande (CLI) d’obtenir uniquement la valeur du champ Plaintext à partir de la sortie. Le paramètre --output renvoie la sortie sous forme de texte. Base64 décode le texte brut et l’enregistre dans un fichier. L’exemple suivant conduit (|) la valeur du paramètre Plaintext à l’utilitaire Base64, qui la décode. Ensuite, il redirige (>) la sortie décodée vers le fichier ExamplePlaintext.

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

aws kms decrypt \
    --ciphertext-blob fileb://ExampleEncryptedFile \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --output text \
    --query Plaintext | base64 \
    --decode > ExamplePlaintextFile

Cette commande ne produit aucune sortie. La sortie de la commande decrypt est décodée en base64 et enregistrée dans un fichier.

Pour plus d’informations, consultez Decrypt dans la Référence des API d’AWS  Key Management Service.

Exemple 2 : pour déchiffrer un message chiffré avec une clé KMS symétrique (invite de commande Windows)

L’exemple suivant est identique au précédent, sauf qu’il utilise l’utilitaire certutil pour décoder les données en texte brut en Base64. Cette procédure requiert deux commandes, comme indiqué dans les exemples suivants.

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

aws kms decrypt ^
    --ciphertext-blob fileb://ExampleEncryptedFile ^
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab ^
    --output text ^
    --query Plaintext > ExamplePlaintextFile.base64

Exécutez la commande certutil.

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Sortie :

Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.

Pour plus d’informations, consultez Decrypt dans la Référence des API d’AWS  Key Management Service.

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

L’exemple de commande decrypt suivant montre comment déchiffrer des données chiffrées avec une clé KMS asymétrique RSA.

Lors de l’utilisation d’une clé KMS asymétrique, le paramètre encryption-algorithm, qui spécifie l’algorithme utilisé pour chiffrer le texte brut, est obligatoire.

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

aws kms decrypt \
    --ciphertext-blob fileb://ExampleEncryptedFile \
    --key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
    --encryption-algorithm RSAES_OAEP_SHA_256 \
    --output text \
    --query Plaintext | base64 \
    --decode > ExamplePlaintextFile

Cette commande ne produit aucune sortie. La sortie de la commande decrypt est décodée en base64 et enregistrée dans un fichier.

Pour plus d'informations, consultez la section Clés asymétriques dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Pour supprimer un alias AWS KMS

L’exemple delete-alias suivant supprime l’alias alias/example-alias. Le nom de l’alias doit commencer par alias/.

aws kms delete-alias \
    --alias-name alias/example-alias

Cette commande ne produit aucune sortie. Pour trouver l’alias, utilisez la commande list-aliases.

Pour plus d’informations, consultez Suppression d’un alias dans le Guide 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 pour trouver les clés KMS dans votre magasin de clés personnalisé, consultez la section Supprimer un magasin de clés AWS CloudHSM (API) dans AWS le guide du développeur du service de gestion des clés.

delete-custom-key-store \
    --custom-key-store-id cks-1234567890abcdef0

Cette commande ne renvoie aucune sortie. Pour vérifier que le magasin de clés personnalisé a bien été supprimée, utilisez la commande describe-custom-key-stores.

Pour plus d'informations sur la suppression d'une AWS banque de clés CloudHSM, consultez la section Suppression d'une banque de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés.AWS

Pour plus d’informations sur la suppression de magasins de clés externes, consultez Deleting an external key store dans le Guide 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 Guide 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étrique recommandée par le NIST (ECC) ou (régions de SM2 Chine uniquement) avec une KeyUsage valeur de to call. KEY_AGREEMENT DeriveSharedSecret

aws kms derive-shared-secret \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --key-agreement-algorithm ECDH \
    --public-key "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvH3Yj0wbkLEpUl95Cv1cJVjsVNSjwGq3tCLnzXfhVwVvmzGN8pYj3U8nKwgouaHbBWNJYjP5VutbbkKS4Kv4GojwZBJyHN17kmxo8yTjRmjR15SKIQ8cqRA2uaERMLnpztIXdZp232PQPbWGxDyXYJ0aJ5EFSag"

Sortie :

{
    "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
    "SharedSecret": "MEYCIQCKZLWyTk5runarx6XiAkU9gv3lbwPO/pHa+DXFehzdDwIhANwpsIV2g/9SPWLLsF6p/hiSskuIXMTRwqrMdVKWTMHG",
    "KeyAgreementAlgorithm": "ECDH",
    "KeyOrigin": "AWS_KMS"
}

Pour plus d'informations, consultez la référence DeriveSharedSecretde l'API du service de gestion des AWS clés.

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

L'describe-custom-key-storeexemple suivant affiche des détails sur le magasin de clés AWS CloudHSM spécifié. La commande est la même pour tous les types de magasins de clés personnalisés, mais le résultat diffère selon le type de magasin de clés et, pour un magasin de clés externe, son option de connectivité.

Par défaut, cette commande affiche des informations sur tous les magasins de clés personnalisés dans le compte et la région. Pour afficher des informations sur un magasin de clés personnalisé en particulier, utilisez le paramètre custom-key-store-name ou custom-key-store-id.

aws kms describe-custom-key-stores \
    --custom-key-store-name ExampleCloudHSMKeyStore

Le résultat de cette commande inclut des informations utiles sur le magasin de clés AWS CloudHSM, notamment son état de connexion (). ConnectionState Si l’état de connexion est FAILED, la sortie contient également un champ ConnectionErrorCode qui décrit le problème.

Sortie :

{
    "CustomKeyStores": [
        {
            "CloudHsmClusterId": "cluster-1a23b4cdefg",
            "ConnectionState": "CONNECTED",
            "CreationDate": "2022-04-05T14:04:55-07:00",
            "CustomKeyStoreId": "cks-1234567890abcdef0",
            "CustomKeyStoreName": "ExampleExternalKeyStore",
            "TrustAnchorCertificate": "<certificate appears here>"
        }
    ]
}

Pour plus d'informations, consultez la section Affichage d'un magasin de clés AWS CloudHSM dans AWS le Guide du développeur du service de gestion des clés.

Exemple 2 : pour obtenir les informations sur un magasin de clés externe avec une connectivité au point de terminaison public

L’exemple describe-custom-key-store suivant affiche des informations sur le magasin de clés externe spécifié. La commande est la même pour tous les types de magasins de clés personnalisés, mais le résultat diffère selon le type de magasin de clés et, pour un magasin de clés externe, son option de connectivité.

Par défaut, cette commande affiche des informations sur tous les magasins de clés personnalisés dans le compte et la région. Pour afficher des informations sur un magasin de clés personnalisé en particulier, utilisez le paramètre custom-key-store-name ou custom-key-store-id.

aws kms describe-custom-key-stores \
    --custom-key-store-id cks-9876543210fedcba9

Le résultat de cette commande inclut des informations utiles sur le magasin de clés externe, notamment son état de connexion (ConnectionState). Si l’état de connexion est FAILED, la sortie contient également un champ ConnectionErrorCode qui décrit le problème.

Sortie :

{
    "CustomKeyStores": [
        {
            "CustomKeyStoreId": "cks-9876543210fedcba9",
            "CustomKeyStoreName": "ExampleXKS",
            "ConnectionState": "CONNECTED",
            "CreationDate": "2022-12-02T07:48:55-07:00",
            "CustomKeyStoreType": "EXTERNAL_KEY_STORE",
            "XksProxyConfiguration": {
                "AccessKeyId": "ABCDE12345670EXAMPLE",
                "Connectivity": "PUBLIC_ENDPOINT",
                "UriEndpoint": "https://myproxy.xks.example.com",
                "UriPath": "/example-prefix/kms/xks/v1"
            }
        }
    ]
}

Pour plus d’informations, consultez Affichage d’un magasin de clés externe dans le Manuel du développeur AWS  Key Management Service.

Exemple 3 : pour obtenir les informations sur un magasin de clés externe avec une connectivité au service du point de terminaison d’un VPC

L’exemple describe-custom-key-store suivant affiche des informations sur le magasin de clés externe spécifié. La commande est la même pour tous les types de magasins de clés personnalisés, mais le résultat diffère selon le type de magasin de clés et, pour un magasin de clés externe, son option de connectivité.

Par défaut, cette commande affiche des informations sur tous les magasins de clés personnalisés dans le compte et la région. Pour afficher des informations sur un magasin de clés personnalisé en particulier, utilisez le paramètre custom-key-store-name ou custom-key-store-id.

aws kms describe-custom-key-stores \
    --custom-key-store-id cks-2234567890abcdef0

Le résultat de cette commande inclut des informations utiles sur le magasin de clés externe, notamment son état de connexion (ConnectionState). Si l’état de connexion est FAILED, la sortie contient également un champ ConnectionErrorCode qui décrit le problème.

Sortie :

{
    "CustomKeyStores": [
        {
            "CustomKeyStoreId": "cks-3234567890abcdef0",
            "CustomKeyStoreName": "ExampleVPCExternalKeyStore",
            "ConnectionState": "CONNECTED",
            "CreationDate": "2022-12-22T07:48:55-07:00",
            "CustomKeyStoreType": "EXTERNAL_KEY_STORE",
            "XksProxyConfiguration": {
                "AccessKeyId": "ABCDE12345670EXAMPLE",
                "Connectivity": "VPC_ENDPOINT_SERVICE",
                "UriEndpoint": "https://myproxy-private.xks.example.com",
                "UriPath": "/kms/xks/v1",
                "VpcEndpointServiceName": "com.amazonaws.vpce.us-east-1.vpce-svc-example1"
            }
        }
    ]
}

Pour plus d’informations, consultez Affichage d’un magasin de clés externe dans le Manuel du développeur AWS  Key Management Service.

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

L'describe-keyexemple suivant fournit des informations détaillées sur la clé AWS gérée pour Amazon S3 dans l'exemple de compte et de région. Vous pouvez utiliser cette commande pour obtenir des informations sur les clés AWS gérées et les clés gérées par le client.

Pour spécifier la clé KMS, utilisez le paramètre key-id. Cet exemple utilise une valeur de nom d’alias, mais vous pouvez utiliser un ID de clé, un ARN de clé, un nom d’alias ou un ARN d’alias dans cette commande.

aws kms describe-key \
    --key-id alias/aws/s3

Sortie :

{
    "KeyMetadata": {
        "AWSAccountId": "846764612917",
        "KeyId": "b8a9477d-836c-491f-857e-07937918959b",
        "Arn": "arn:aws:kms:us-west-2:846764612917:key/b8a9477d-836c-491f-857e-07937918959b",
        "CurrentKeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
        "CreationDate": 2017-06-30T21:44:32.140000+00:00,
        "Enabled": true,
        "Description": "Default KMS key that protects my S3 objects when no other key is defined",
        "KeyUsage": "ENCRYPT_DECRYPT",
        "KeyState": "Enabled",
        "Origin": "AWS_KMS",
        "KeyManager": "AWS",
        "CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
        "EncryptionAlgorithms": [
            "SYMMETRIC_DEFAULT"
        ]
    }
}

Pour plus d’informations, consultez Affichage des clés dans le Guide du développeur AWS  Key Management Service.

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

L’exemple describe-key suivant fournit des informations détaillées sur une clé KMS asymétrique utilisée pour la signature et la vérification.

aws kms describe-key \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Sortie :

{
    "KeyMetadata": {
        "AWSAccountId": "111122223333",
        "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
        "Arn": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
        "CreationDate": "2019-12-02T19:47:14.861000+00:00",
        "CustomerMasterKeySpec": "RSA_2048",
        "Enabled": false,
        "Description": "",
        "KeyState": "Disabled",
        "Origin": "AWS_KMS",
        "MultiRegion": false,
        "KeyManager": "CUSTOMER",
        "KeySpec": "RSA_2048",
        "KeyUsage": "SIGN_VERIFY",
        "SigningAlgorithms": [
            "RSASSA_PKCS1_V1_5_SHA_256",
            "RSASSA_PKCS1_V1_5_SHA_384",
            "RSASSA_PKCS1_V1_5_SHA_512",
            "RSASSA_PSS_SHA_256",
            "RSASSA_PSS_SHA_384",
            "RSASSA_PSS_SHA_512"
        ]
    }
}

Exemple 3 : pour obtenir des informations sur une clé de réplica multi-région

L’exemple describe-key suivant fournit des métadonnées pour une clé de réplica multi-région. Cette clé multi-région est une clé de chiffrement symétrique. La sortie d’une commande describe-key pour une clé multi-région renvoie des informations sur la clé primaire et tous ses réplicas.

aws kms describe-key \
    --key-id arn:aws:kms:ap-northeast-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab

Sortie :

{
    "KeyMetadata": {
        "MultiRegion": true,
        "AWSAccountId": "111122223333",
        "Arn": "arn:aws:kms:ap-northeast-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
        "CreationDate": "2021-06-28T21:09:16.114000+00:00",
        "CurrentKeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
        "Description": "",
        "Enabled": true,
        "KeyId": "mrk-1234abcd12ab34cd56ef1234567890ab",
        "KeyManager": "CUSTOMER",
        "KeyState": "Enabled",
        "KeyUsage": "ENCRYPT_DECRYPT",
        "Origin": "AWS_KMS",
        "CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
        "EncryptionAlgorithms": [
            "SYMMETRIC_DEFAULT"
        ],
        "MultiRegionConfiguration": {
            "MultiRegionKeyType": "PRIMARY",
            "PrimaryKey": {
                "Arn": "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
                "Region": "us-west-2"
            },
            "ReplicaKeys": [
                {
                    "Arn": "arn:aws:kms:eu-west-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
                    "Region": "eu-west-1"
                },
                {
                    "Arn": "arn:aws:kms:ap-northeast-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
                    "Region": "ap-northeast-1"
                },
                {
                    "Arn": "arn:aws:kms:sa-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab",
                    "Region": "sa-east-1"
                }
            ]
        }
    }
}

Exemple 4 : pour obtenir des informations sur une clé KMS HMAC

L’exemple describe-key suivant fournit des informations détaillées sur une clé KMS HMAC.

aws kms describe-key \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Sortie :

{
    "KeyMetadata": {
        "AWSAccountId": "123456789012",
        "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
        "Arn": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab",
        "CreationDate": "2022-04-03T22:23:10.194000+00:00",
        "Enabled": true,
        "Description": "Test key",
        "KeyUsage": "GENERATE_VERIFY_MAC",
        "KeyState": "Enabled",
        "Origin": "AWS_KMS",
        "KeyManager": "CUSTOMER",
        "CustomerMasterKeySpec": "HMAC_256",
        "MacAlgorithms": [
            "HMAC_SHA_256"
        ],
        "MultiRegion": false
    }
}

Pour 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 Guide 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 Guide du développeur AWS  Key Management Service.

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

L'disconnect-custom-key-storeexemple suivant déconnecte un magasin de clés personnalisé de son cluster AWS CloudHSM. Vous pouvez déconnecter un magasin de clés pour résoudre un problème, pour mettre à jour ses paramètres ou pour empêcher l’utilisation des clés KMS du magasin de clés dans des opérations cryptographiques.

Cette commande est identique pour tous les magasins de clés personnalisés, y compris les magasins de clés AWS CloudHSM et les magasins de clés externes.

Avant d’exécuter la commande, remplacez l’exemple d’ID de magasin de clés personnalisé par un ID valide.

$ aws kms disconnect-custom-key-store \
    --custom-key-store-id cks-1234567890abcdef0

Cette commande ne produit aucune sortie. Pour vérifier que la commande est efficace, utilisez la commande describe-custom-key-stores.

Pour plus d'informations sur la déconnexion d'un magasin de clés AWS CloudHSM, consultez la section Connexion et déconnexion d'un magasin de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés.AWS

Pour plus d’informations sur la déconnexion d’un magasin de clés externe, consultez Connecting and disconnecting an external key store dans le Guide 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 Guide 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 Guide du développeur AWS  Key Management Service.

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

La encrypt commande suivante montre la méthode recommandée pour chiffrer les données avec la AWS CLI.

aws kms encrypt \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --plaintext fileb://ExamplePlaintextFile \
    --output text \
    --query CiphertextBlob | base64 \
    --decode > ExampleEncryptedFile

La commande effectue plusieurs opérations :

Utilise le paramètre --plaintext pour indiquer les données à chiffrer. La valeur de ce paramètre doit être codée en base64. La valeur du plaintext paramètre doit être codée en base64, ou vous devez utiliser le préfixefileb://, qui indique à la AWS CLI de lire les données binaires du fichier. Si le fichier ne se trouve pas dans le répertoire actuel, tapez le chemin complet du fichier. Par exemple, fileb:///var/tmp/ExamplePlaintextFile ou fileb://C:\Temp\ExamplePlaintextFile. Pour plus d'informations sur la lecture des valeurs des paramètres de la AWS CLI depuis un fichier, consultez la section AWS Chargement de paramètres depuis un fichierdans le guide de l'utilisateur de l'interface de ligne de AWS commande et les meilleures pratiques pour les paramètres de fichiers locaux sur le --output blog des outils de ligne de commande. Ces --query paramètres extraient les données chiffrées, appelées texte chiffré, de la sortie de la commande.Pour plus d'informations sur le contrôle de la sortie, voir Contrôle de la commande Sortie dans le guide de l'utilisateur de l'interface de ligne de AWS commande. Utilise l'base64utilitaire pour décoder la sortie extraite en données binaires. Le texte chiffré renvoyé par une commande réussie encrypt est du texte codé en base64. Vous devez décoder ce texte avant de pouvoir utiliser la AWS CLI pour le déchiffrer. Enregistre le texte chiffré binaire dans un fichier.La dernière partie de la commande (> ExampleEncryptedFile) enregistre le texte chiffré binaire dans un fichier pour faciliter le déchiffrement. Pour un exemple de commande utilisant la AWS CLI pour déchiffrer des données, consultez les exemples de déchiffrement.

Exemple 2 : utilisation de la AWS CLI pour chiffrer des données sous Windows

Cet exemple est identique au précédent, sauf qu’il utilise l’outil certutil au lieu de base64. Cette procédure requiert deux commandes, comme indiqué dans l’exemple suivant.

aws kms encrypt \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --plaintext fileb://ExamplePlaintextFile \
    --output text \
    --query CiphertextBlob > C:\Temp\ExampleEncryptedFile.base64

certutil -decode C:\Temp\ExampleEncryptedFile.base64 C:\Temp\ExampleEncryptedFile

Exemple 3 : chiffrement avec une clé KMS asymétrique

La commande encrypt suivante montre comment chiffrer du texte brut avec une clé KMS asymétrique. Le paramètre --encryption-algorithm est obligatoire. Comme dans toutes les commandes de la encrypt CLI, le plaintext paramètre doit être codé en base64, ou vous devez utiliser le fileb:// préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.

aws kms encrypt \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --encryption-algorithm RSAES_OAEP_SHA_256 \
    --plaintext fileb://ExamplePlaintextFile \
    --output text \
    --query CiphertextBlob | base64 \
    --decode > ExampleEncryptedFile

Cette commande ne produit aucune sortie.

Pour générer une paire de clés de données asymétriques ECC NIST P384

L'generate-data-key-pair-without-plaintextexemple suivant demande une paire de clés ECC NIST P384 pour une utilisation en dehors de. AWS

La commande renvoie une clé publique en texte brut et une copie de la clé privée chiffrée sous la clé KMS spécifiée. Elle ne renvoie pas de clé privée en texte brut. Vous pouvez stocker en toute sécurité la clé privée chiffrée avec les données chiffrées et appeler AWS KMS pour déchiffrer la clé privée lorsque vous devez l'utiliser.

Pour demander une paire de clés de données asymétriques ECC NIST P384, utilisez le paramètre key-pair-spec avec une valeur ECC_NIST_P384.

La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur KeySpec est SYMMETRIC_DEFAULT.

REMARQUE : les valeurs de la sortie de cet exemple sont tronquées pour être affichées.

aws kms generate-data-key-pair-without-plaintext \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --key-pair-spec ECC_NIST_P384

Sortie :

{
    "PrivateKeyCiphertextBlob": "AQIDAHi6LtupRpdKl2aJTzkK6FbhOtQkMlQJJH3PdtHvS/y+hAFFxmiD134doUDzMGmfCEtcAAAHaTCCB2UGCSqGSIb3DQEHBqCCB1...",
    "PublicKey": "MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA3A3eGMyPrvSn7+LdlJE1oUoQV5HpEuHAVbdOyND+NmYDH/mL1OSIEuLrcdZ5hrMH4pk83r40l...",
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
    "KeyPairSpec": "ECC_NIST_P384"
}

Les clés PublicKey et PrivateKeyCiphertextBlob sont renvoyées au format encodé en base64.

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

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

L'generate-data-key-pairexemple suivant demande une paire de clés de données asymétriques RSA de 2048 bits pour une utilisation en dehors de. AWS La commande renvoie une clé publique et une clé privée en texte brut pour une utilisation et une suppression immédiates, ainsi qu’une copie de la clé privée chiffrée sous la clé KMS spécifiée. Vous pouvez stocker en toute sécurité la clé privée chiffrée avec les données chiffrées.

Pour demander une paire de clés de données asymétriques RSA de 2 048 bits, utilisez le paramètre key-pair-spec avec une valeur RSA_2048.

La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur KeySpec est SYMMETRIC_DEFAULT.

REMARQUE : les valeurs de la sortie de cet exemple sont tronquées pour être affichées.

aws kms generate-data-key-pair \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --key-pair-spec RSA_2048

Sortie :

{
    "PrivateKeyCiphertextBlob": "AQIDAHi6LtupRpdKl2aJTzkK6FbhOtQkMlQJJH3PdtHvS/y+hAFFxmiD134doUDzMGmfCEtcAAAHaTCCB2UGCSqGSIb3DQEHBqCCB1...",
    "PrivateKeyPlaintext": "MIIG/QIBADANBgkqhkiG9w0BAQEFAASCBucwggbjAgEAAoIBgQDcDd4YzI+u9Kfv4t2UkTWhShBXkekS4cBVt07I0P42ZgMf+YvU5IgS4ut...",
    "PublicKey": "MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA3A3eGMyPrvSn7+LdlJE1oUoQV5HpEuHAVbdOyND+NmYDH/mL1OSIEuLrcdZ5hrMH4pk83r40l...",
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
    "KeyPairSpec": "RSA_2048"
}

Les clés PublicKey, PrivateKeyPlaintext et PrivateKeyCiphertextBlob sont renvoyées au format encodé en base64.

Pour plus d’informations, consultez Paires de clés de données dans le Guide 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 une valeur AES_256. Pour demander une clé de données de 128 bits, utilisez le paramètre key-spec avec une valeur AES_128. Pour toutes les autres longueurs de clé de données, utilisez le paramètre number-of-bytes.

La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur de spécification de clé est SYMMETRIC_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"
}

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

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

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

L'generate-data-keyexemple suivant demande une clé de données symétrique de 256 bits à utiliser en dehors de. AWS La commande renvoie une clé de données en texte brut pour une utilisation et une suppression immédiates, ainsi qu’une copie de cette clé de données chiffrée sous la clé KMS spécifiée. Vous pouvez stocker en toute sécurité la clé de données chiffrée avec les données chiffrées.

Pour demander une clé de données de 256 bits, utilisez le paramètre key-spec avec une valeur AES_256. Pour demander une clé de données de 128 bits, utilisez le paramètre key-spec avec une valeur AES_128. Pour toutes les autres longueurs de clé de données, utilisez le paramètre number-of-bytes.

La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur de spécification de clé est SYMMETRIC_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="
}

Le Plaintext (clé de données en texte brut) et le CiphertextBlob (clé de données chiffrée) sont renvoyés au format encodé en base64.

Pour plus d’informations, consultez Clés de données dans le Guide du développeur AWS  Key Management Service. Exemple 2 : pour générer une clé de données symétrique de 512 bits

L’exemple generate-data-key suivant demande une clé de données symétrique de 512 bits pour le chiffrement et le déchiffrement. La commande renvoie une clé de données en texte brut pour une utilisation et une suppression immédiates, ainsi qu’une copie de cette clé de données chiffrée sous la clé KMS spécifiée. Vous pouvez stocker en toute sécurité la clé de données chiffrée avec les données chiffrées.

Pour demander une longueur de clé autre que 128 ou 256 bits, utilisez le paramètre number-of-bytes. Pour demander une clé de données 512 bits, l’exemple suivant utilise le paramètre number-of-bytes avec une valeur de 64 (octets).

La clé KMS que vous spécifiez doit être une clé KMS de chiffrement symétrique, c’est-à-dire une clé KMS dont la valeur de spécification de clé est SYMMETRIC_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 Guide 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 la AWS CLI v2, la valeur du message paramètre doit être codée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le fileb:// préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.

Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS HMAC avec comme utilisation de GENERATE_VERIFY_MAC.

msg=(echo 'Hello World' | base64)

aws kms generate-mac \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --message fileb://Message \
    --mac-algorithm HMAC_SHA_384

Sortie :

{
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "Mac": "<HMAC_TAG>",
    "MacAlgorithm": "HMAC_SHA_384"
}

Pour plus d'informations sur l'utilisation des clés HMAC KMS dans AWS KMS, consultez la section Clés HMAC dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Exemple 2 : pour enregistrer un HMAC dans un fichier (Linux et macOS)

L’exemple generate-mac suivant génère un HMAC pour un message court stocké dans un fichier local. La commande obtient également la Mac propriété à partir de la réponse, la décode en Base64 et l'enregistre dans le fichier. ExampleMac Vous pouvez utiliser le fichier MAC dans une commande verify-mac qui vérifie le MAC.

La commande generate-mac nécessite un message encodé en Base64 et un algorithme MAC pris en charge par votre clé KMS HMAC. Pour obtenir les algorithmes MAC pris en charge par votre clé KMS, utilisez la commande describe-key.

Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est GENERATE_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 HMAC KMS dans AWS KMS, consultez la section Clés HMAC dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

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 --number-of-bytes paramètre requis avec une valeur de 32 pour demander une chaîne de 32 octets (256 bits). Il utilise le --output paramètre avec une valeur de pour demander à la AWS CLI de renvoyer la sortie sous forme de texte, au lieu de JSON. Il utilise le --query parameter pour extraire la valeur de la Plaintext propriété de la réponse. Il envoie (|) la sortie de la commande à l'base64utilitaire, qui décode la sortie extraite. Il utilise l'opérateur de text redirection (>) pour enregistrer la chaîne d'octets décodée dans le fichier .it utilise l'opérateur de redirection (>) ExampleRandom pour enregistrer le texte chiffré binaire dans un fichier.

aws kms generate-random \
    --number-of-bytes 32 \
    --output text \
    --query Plaintext | base64 --decode > ExampleRandom

Cette commande ne produit aucune sortie.

Pour plus d'informations, consultez la référence GenerateRandomde l'API du service de gestion des AWS clés.

Exemple 2 : pour générer un nombre aléatoire de 256 bits (invite de commande Windows)

L’exemple suivant utilise la commande generate-random pour générer une chaîne d’octets aléatoire de 256 bits (32 octets) encodée en base64. L’exemple décode la chaîne d’octets et l’enregistre dans le fichier aléatoire. Cet exemple est identique à l’exemple précédent, sauf qu’il utilise l’utilitaire certutil de Windows pour décoder en base64 la chaîne d’octets aléatoire avant de l’enregistrer dans un fichier.

Tout d’abord, générez une chaîne d’octets aléatoire encodée en base64 et enregistrez-la dans un fichier temporaire, ExampleRandom.base64.

aws kms generate-random \
    --number-of-bytes 32 \
    --output text \
    --query Plaintext > ExampleRandom.base64

La sortie de la commande generate-random étant enregistrée dans un fichier, cet exemple ne produit aucune sortie.

Utilisez maintenant la commande certutil -decode pour décoder la chaîne d’octets encodée en base64 dans le fichier ExampleRandom.base64. Ensuite, il enregistre la chaîne d’octets décodée dans le fichier ExampleRandom.

certutil -decode ExampleRandom.base64 ExampleRandom

Sortie :

Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.

Pour plus d'informations, consultez la référence GenerateRandomde l'API du service de gestion des AWS clés.

Pour copier une stratégie de clé d’une clé KMS vers une autre clé KMS

L’exemple suivant get-key-policy obtient la stratégie de clé d’une clé KMS et l’enregistre dans un fichier texte. Il remplace ensuite la stratégie d’une autre clé KMS en utilisant le fichier texte comme entrée de stratégie.

Comme le paramètre --policy de put-key-policy nécessite une chaîne, vous devez utiliser l’option --output text pour renvoyer la sortie sous forme de chaîne de texte au lieu de JSON.

aws kms get-key-policy \
    --policy-name default \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --query Policy \
    --output text > policy.txt

aws kms put-key-policy \
    --policy-name default \
    --key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
    --policy file://policy.txt

Cette commande ne produit aucune sortie.

Pour plus d'informations, consultez le PutKeyPolicymanuel de référence de l'API AWS KMS.

Pour extraire le statut de rotation d’une clé KMS

L’exemple get-key-rotation-status suivant renvoie des informations sur le statut de rotation de la clé KMS spécifiée, notamment si la rotation automatique est activée, la période de rotation et la prochaine date de rotation planifiée. Vous pouvez utiliser cette commande sur les clés KMS gérées par le client et les clés KMS AWS gérées. Cependant, toutes les clés KMS AWS gérées font l'objet d'une rotation automatique chaque année.

aws kms get-key-rotation-status \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Sortie :

{
    "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
    "KeyRotationEnabled": true,
    "NextRotationDate": "2024-02-14T18:14:33.587000+00:00",
    "RotationPeriodInDays": 365
}

Pour plus d’informations, consultez Rotation des clés dans le Guide 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 Guide 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, le résultat inclut les informations dont vous avez besoin pour utiliser la clé publique en toute sécurité en dehors de AWS KMS, notamment l'utilisation de la clé et les algorithmes de chiffrement pris en charge.

aws kms get-public-key \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Sortie :

{
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "PublicKey": "jANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAl5epvg1/QtJhxSi2g9SDEVg8QV/...",
    "CustomerMasterKeySpec": "RSA_4096",
    "KeyUsage": "ENCRYPT_DECRYPT",
    "EncryptionAlgorithms": [
        "RSAES_OAEP_SHA_1",
        "RSAES_OAEP_SHA_256"
    ]
}

Pour plus d'informations sur l'utilisation de clés KMS asymétriques dans AWS KMS, voir Clés asymétriques dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés. Exemple 2 : pour convertir une clé publique au format DER (Linux et macOS)

L’exemple get-public-key suivant télécharge la clé publique d’une clé KMS asymétrique et l’enregistre dans un fichier DER.

Lorsque vous utilisez la get-public-key commande dans la AWS CLI, elle renvoie une clé publique X.509 codée DER codée en Base64. Cet exemple fournit la valeur de la propriété PublicKey sous forme de texte. Il décode en Base64 la PublicKey et l’enregistre dans le fichier public_key.der. Le paramètre output renvoie la sortie sous forme de texte, au lieu de JSON. Le --query paramètre obtient uniquement la PublicKey propriété, et non les propriétés dont vous avez besoin pour utiliser la clé publique en toute sécurité en dehors de AWS KMS.

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

aws kms get-public-key \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --output text \
    --query PublicKey | base64 --decode > public_key.der

Cette commande ne produit aucune sortie.

Pour plus d'informations sur l'utilisation de clés KMS asymétriques dans AWS KMS, voir Clés asymétriques dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

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

L’exemple import-key-material suivant télécharge des éléments de clé dans une clé KMS créée sans élément de clé. L’état de la clé KMS doit être PendingImport.

Cette commande utilise des éléments de clé que vous avez chiffrés avec la clé publique renvoyée par la commande get-parameters-for-import. Elle utilise également le jeton d’importation issu de la même commande get-parameters-for-import.

Le paramètre expiration-model indique que les éléments de clé expirent automatiquement à la date et à l’heure spécifiées par le paramètre valid-to. Lorsque le contenu clé expire, AWS KMS le supprime, l'état de la clé KMS devient inutilisable. Pending import Pour restaurer la clé KMS, vous devez réimporter les mêmes éléments de clé. Pour utiliser un autre élément de clé, vous devez créer une nouvelle clé KMS.

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

aws kms import-key-material \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --encrypted-key-material fileb://EncryptedKeyMaterial.bin \
    --import-token fileb://ImportToken.bin \
    --expiration-model KEY_MATERIAL_EXPIRES \
    --valid-to 2021-09-21T19:00:00Z

Sortie :

{
    "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
    "KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
}

Pour plus d’informations sur l’importation des éléments de clé, consultez Importation des éléments de clé dans le Guide du développeur AWS Key Management Service.

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

L'exemple suivant utilise la list-aliases commande pour répertorier tous les alias de la région par défaut du AWS compte. La sortie inclut les alias associés aux clés KMS AWS gérées et aux clés KMS gérées par le client.

aws kms list-aliases

Sortie :

{
    "Aliases": [
        {
            "AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/testKey",
            "AliasName": "alias/testKey",
            "TargetKeyId": "1234abcd-12ab-34cd-56ef-1234567890ab"
        },
        {
            "AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/FinanceDept",
            "AliasName": "alias/FinanceDept",
            "TargetKeyId": "0987dcba-09fe-87dc-65ba-ab0987654321"
        },
        {
            "AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/aws/dynamodb",
            "AliasName": "alias/aws/dynamodb",
            "TargetKeyId": "1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d"
        },
        {
            "AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/aws/ebs",
            "AliasName": "alias/aws/ebs",
            "TargetKeyId": "0987ab65-43cd-21ef-09ab-87654321cdef"
        },
        ...
    ]
}

Exemple 2 : pour répertorier tous les alias d’une clé KMS particulière

L’exemple suivant utilise la commande list-aliases et son paramètre key-id pour répertorier tous les alias associés à une clé KMS spécifique.

Chaque alias est associé à une seule clé KMS, mais une clé KMS peut avoir plusieurs alias. Cette commande est très utile car la console AWS KMS ne répertorie qu'un seul alias pour chaque clé KMS. Pour trouver tous les alias d’une clé KMS, vous devez utiliser la commande list-aliases.

Cet exemple utilise l’ID de la clé KMS pour le paramètre --key-id, mais vous pouvez utiliser un ID de clé, un ARN de clé, un nom d’alias ou un ARN d’alias dans cette commande.

aws kms list-aliases --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Sortie :

{
    "Aliases": [
        {
            "TargetKeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
            "AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/oregon-test-key",
            "AliasName": "alias/oregon-test-key"
        },
        {
            "TargetKeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
            "AliasArn": "arn:aws:kms:us-west-2:111122223333:alias/project121-test",
            "AliasName": "alias/project121-test"
        }
    ]
}

Pour plus d’informations, consultez Utilisation des alias dans le Guide du développeur AWS  Key Management Service.

Pour afficher les subventions sur une clé AWS KMS

L'list-grantsexemple suivant affiche toutes les autorisations associées à la clé KMS AWS gérée spécifiée pour Amazon DynamoDB dans votre compte. Cette autorisation permet à DynamoDB d’utiliser la clé KMS en votre nom pour chiffrer une table DynamoDB avant de l’écrire sur le disque. Vous pouvez utiliser une commande comme celle-ci pour afficher les autorisations relatives aux clés KMS AWS gérées et aux clés KMS gérées par le client dans le AWS compte et la région.

Cette commande utilise le paramètre key-id avec un ID de clé pour identifier la clé KMS. Vous pouvez utiliser un ID de clé ou un ARN de clé pour identifier la clé KMS. Pour obtenir l'ID de clé ou l'ARN d'une clé KMS AWS gérée, utilisez la list-aliases commande list-keys or.

aws kms list-grants \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

La sortie indique que l’octroi autorise Amazon DynamoDB à utiliser la clé KMS pour des opérations cryptographiques, à consulter les informations relatives à la clé KMS (DescribeKey) et à mettre les autorisations hors service (RetireGrant). La contrainte EncryptionContextSubset limite ces autorisations aux demandes qui incluent les paires de contextes de chiffrement spécifiées. Par conséquent, les autorisations de l’octroi ne sont effectives que sur le compte spécifié et sur la table DynamoDB.

{
    "Grants": [
        {
            "Constraints": {
                "EncryptionContextSubset": {
                    "aws:dynamodb:subscriberId": "123456789012",
                    "aws:dynamodb:tableName": "Services"
                }
            },
            "IssuingAccount": "arn:aws:iam::123456789012:root",
            "Name": "8276b9a6-6cf0-46f1-b2f0-7993a7f8c89a",
            "Operations": [
                "Decrypt",
                "Encrypt",
                "GenerateDataKey",
                "ReEncryptFrom",
                "ReEncryptTo",
                "RetireGrant",
                "DescribeKey"
            ],
            "GrantId": "1667b97d27cf748cf05b487217dd4179526c949d14fb3903858e25193253fe59",
            "KeyId": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab",
            "RetiringPrincipal": "dynamodb.us-west-2.amazonaws.com",
            "GranteePrincipal": "dynamodb.us-west-2.amazonaws.com",
            "CreationDate": "2021-05-13T18:32:45.144000+00:00"
        }
    ]
}

Pour plus d'informations, consultez la section Subventions dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Pour obtenir les noms des stratégies de clé pour une clé KMS

L’exemple list-key-policies suivant obtient les noms des stratégies de clé pour une clé gérée par le client dans les exemples de compte et de région. Vous pouvez utiliser cette commande pour rechercher les noms des politiques clés relatives aux clés AWS gérées et aux clés gérées par le client.

Comme le seul nom de stratégie de clé valide est default, cette commande n’est pas utile.

Pour spécifier la clé KMS, utilisez le paramètre key-id. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser un ID de clé ou un ARN de clé dans cette commande.

aws kms list-key-policies \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Sortie :

{
    "PolicyNames": [
    "default"
    ]
}

Pour plus d'informations sur les politiques clés AWS KMS, consultez la section Utilisation des politiques clés dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Pour extraire des informations sur toutes les rotations des éléments de clé terminées

L’exemple list-key-rotations suivant répertorie les informations relatives à toutes les rotations des éléments de clé effectuées pour la clé KMS spécifiée.

aws kms list-key-rotations \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Sortie :

{
    "Rotations": [
        {
            "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
            "RotationDate": "2024-03-02T10:11:36.564000+00:00",
            "RotationType": "AUTOMATIC"
        },
        {
            "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
            "RotationDate": "2024-04-05T15:14:47.757000+00:00",
            "RotationType": "ON_DEMAND"
        }
    ],
    "Truncated": false
}

Pour plus d’informations, consultez Rotation des clés dans le Guide 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 les clés AWS gérées et les clés gérées par le client.

aws kms list-keys

Sortie :

{
    "Keys": [
        {
            "KeyArn": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
            "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab"
        },
        {
            "KeyArn": "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321",
            "KeyId": "0987dcba-09fe-87dc-65ba-ab0987654321"
        },
        {
            "KeyArn": "arn:aws:kms:us-east-2:111122223333:key/1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d",
            "KeyId": "1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d"
        }
    ]
}

Pour plus d’informations, consultez Affichage des clés dans le Guide 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 la section Balisage des clés dans le Guide du développeur du service de gestion des AWS clés.

Pour afficher les octrois qu’un principal peut mettre hors service

L'list-retirable-grantsexemple suivant affiche toutes les autorisations que l'ExampleAdminutilisateur peut retirer sur les clés KMS d'un AWS compte et d'une région. Vous pouvez utiliser une commande comme celle-ci pour afficher les autorisations que tout directeur de compte peut retirer sur les clés KMS du AWS compte et de la région.

La valeur du paramètre retiring-principal requis doit être l’Amazon Resource Name (ARN) d’un compte, d’un utilisateur ou d’un rôle.

Vous ne pouvez pas spécifier de service pour la valeur de retiring-principal dans cette commande, même si un service peut être le principal mis hors service. Pour trouver les octrois dans lesquels un service particulier est le principal mis hors service, utilisez la commande list-grants.

Le résultat indique que l’utilisateur ExampleAdmin est autorisé à mettre hors service les octrois sur deux clés KMS différentes dans le compte et dans la région. Outre le principal mis hors service, le compte est autorisé à mettre hors service tout octroi du compte.

aws kms list-retirable-grants \
    --retiring-principal arn:aws:iam::111122223333:user/ExampleAdmin

Sortie :

{
    "Grants": [
        {
            "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
            "GrantId": "156b69c63cb154aa21f59929ff19760717be8d9d82b99df53e18b94a15a5e88e",
            "Name": "",
            "CreationDate": 2021-01-14T20:17:36.419000+00:00,
            "GranteePrincipal": "arn:aws:iam::111122223333:user/ExampleUser",
            "RetiringPrincipal": "arn:aws:iam::111122223333:user/ExampleAdmin",
            "IssuingAccount": "arn:aws:iam::111122223333:root",
            "Operations": [
                "Encrypt"
            ],
            "Constraints": {
                "EncryptionContextSubset": {
                    "Department": "IT"
                }
            }
        },
        {
            "KeyId": "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321",
            "GrantId": "8c94d1f12f5e69f440bae30eaec9570bb1fb7358824f9ddfa1aa5a0dab1a59b2",
            "Name": "",
            "CreationDate": "2021-02-02T19:49:49.638000+00:00",
            "GranteePrincipal": "arn:aws:iam::111122223333:role/ExampleRole",
            "RetiringPrincipal": "arn:aws:iam::111122223333:user/ExampleAdmin",
            "IssuingAccount": "arn:aws:iam::111122223333:root",
            "Operations": [
                "Decrypt"
            ],
            "Constraints": {
                "EncryptionContextSubset": {
                    "Department": "IT"
                }
            }
        }
    ],
    "Truncated": false
}

Pour plus d'informations, consultez la section Subventions dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Pour modifier la stratégie de clé d’une clé KMS

L’exemple put-key-policy suivant modifie la stratégie de clé pour une clé gérée par le client.

Pour commencer, créez une stratégie de clé et enregistrez-la dans un fichier JSON local. Dans cet exemple, le fichier est key_policy.json. Vous pouvez également spécifier la stratégie de clé sous forme de valeur de chaîne du paramètre policy.

La première déclaration de cette politique clé autorise le AWS compte à utiliser les politiques IAM pour contrôler l'accès à la clé KMS. La deuxième instruction autorise l’utilisateur test-user à exécuter les commandes describe-key et list-keys sur la clé KMS.

Contenu de key_policy.json :

{
    "Version":"2012-10-17",		 	 	 
    "Id" : "key-default-1",
    "Statement" : [
        {
            "Sid" : "Enable IAM User Permissions",
            "Effect" : "Allow",
            "Principal" : {
                "AWS" : "arn:aws:iam::111122223333:root"
            },
            "Action" : "kms:*",
            "Resource" : "*"
        },
        {
            "Sid" : "Allow Use of Key",
            "Effect" : "Allow",
            "Principal" : {
                "AWS" : "arn:aws:iam::111122223333:user/test-user"
            },
            "Action" : [
                "kms:DescribeKey",
                "kms:ListKeys"
            ],
            "Resource" : "*"
        }
    ]
}

Pour identifier la clé KMS, cet exemple utilise l’ID de clé, mais vous pouvez également utiliser un ARN de clé. Pour spécifier la stratégie de clé, la commande utilise le paramètre policy. Pour indiquer que la stratégie se trouve dans un fichier, elle utilise le préfixe file:// requis. Ce préfixe est nécessaire pour identifier les fichiers sur tous les systèmes d’exploitation pris en charge. Enfin, la commande utilise le paramètre policy-name avec la valeur default. Si aucune stratégie de nom n’est spécifiée, la valeur par défaut est default. La seule valeur valide est default.

aws kms put-key-policy \
    --policy-name default \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --policy file://key_policy.json

Cette commande ne génère pas de sortie. Pour vérifier que la commande est efficace, utilisez la commande get-key-policy. L’exemple de commande suivant permet d’obtenir la stratégie de clé pour la même clé KMS. Le paramètre output avec la valeur text renvoie un format de texte facile à lire.

aws kms get-key-policy \
    --policy-name default \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --output text

Sortie :

{
    "Version":"2012-10-17",		 	 	 
    "Id" : "key-default-1",
    "Statement" : [
        {
            "Sid" : "Enable IAM User Permissions",
            "Effect" : "Allow",
            "Principal" : {
                "AWS" : "arn:aws:iam::111122223333:root"
            },
            "Action" : "kms:*",
            "Resource" : "*"
            },
            {
            "Sid" : "Allow Use of Key",
            "Effect" : "Allow",
            "Principal" : {
                "AWS" : "arn:aws:iam::111122223333:user/test-user"
            },
            "Action" : [ "kms:Describe", "kms:List" ],
            "Resource" : "*"
        }
    ]
}

Pour plus d’informations, consultez Modification d’une stratégie de clé dans le Guide 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 re-encrypt commande suivant illustre la méthode recommandée pour rechiffrer les données à l'aide de la CLI AWS .

Fournissez le texte chiffré dans un fichier. Dans la valeur du paramètre --ciphertext-blob, utilisez le préfixe fileb://, qui indique à l’interface de ligne de commande (CLI) de lire les données d’un fichier binaire. Si le fichier ne se trouve pas dans le répertoire actuel, saisissez le chemin complet du fichier. Pour plus d'informations sur la lecture des valeurs des paramètres de la AWS CLI à partir d'un fichier, consultez la section Chargement de paramètres AWS CLI depuis un fichier dans le guide de l'utilisateur de l'interface de ligne de AWS commande et les meilleures pratiques relatives aux paramètres de fichiers locaux dans le blog des outils de ligne de AWS commande. Spécifiez la clé KMS source, qui déchiffre le texte chiffré. Le --source-key-id paramètre n'est pas obligatoire lors du déchiffrement à l'aide de clés KMS de chiffrement symétriques. AWS KMS peut obtenir la clé KMS qui a été utilisée pour chiffrer les données à partir des métadonnées du blob de texte chiffré. Toutefois, la spécification de la clé KMS que vous utilisez est une bonne pratique. Cette pratique garantit que vous utilisez la clé KMS que vous avez l’intention d’utiliser et vous empêche de déchiffrer par inadvertance un texte chiffré à l’aide d’une clé KMS non fiable. Spécifiez la clé KMS de destination, qui rechiffre les données. Le paramètre --destination-key-id est toujours obligatoire. Cet exemple utilise un ARN de clé, mais vous pouvez utiliser n’importe quel identifiant de clé valide. Demandez la sortie en texte brut sous forme de valeur de texte. Le paramètre --query indique à l’interface de ligne de commande (CLI) de n’obtenir que la valeur du champ Plaintext à partir de la sortie. Le paramètre --output renvoie la sortie sous forme de texte. Base64 décode le texte brut et l’enregistre dans un fichier. L’exemple suivant conduit (|) la valeur du paramètre Plaintext à l’utilitaire Base64, qui la décode. Ensuite, il redirige (>) la sortie décodée vers le fichier ExamplePlaintext.

Avant d'exécuter cette commande, remplacez l'exemple de clé par IDs des identifiants de clé valides provenant de votre AWS compte.

aws kms re-encrypt \
    --ciphertext-blob fileb://ExampleEncryptedFile \
    --source-key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --destination-key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
    --query CiphertextBlob \
    --output text | base64 --decode > ExampleReEncryptedFile

Cette commande ne produit aucune sortie. La sortie de la commande re-encrypt est décodée en base64 et enregistrée dans un fichier.

Pour plus d'informations, consultez la référence ReEncryptde l'API du service de gestion des AWS clés.

Exemple 2 : pour rechiffrer un message chiffré sous une autre clé KMS symétrique (invite de commande Windows)

L’exemple de commande re-encrypt suivant est identique au précédent, sauf qu’il utilise l’utilitaire certutil pour décoder les données en texte brut en Base64. Cette procédure requiert deux commandes, comme indiqué dans les exemples suivants.

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

aws kms re-encrypt ^
    --ciphertext-blob fileb://ExampleEncryptedFile ^
    --source-key-id 1234abcd-12ab-34cd-56ef-1234567890ab ^
    --destination-key-id 0987dcba-09fe-87dc-65ba-ab0987654321 ^
    --query CiphertextBlob ^
    --output text > ExampleReEncryptedFile.base64

Ensuite, utilisez l’utilitaire certutil

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Sortie :

Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.

Pour plus d'informations, consultez la référence ReEncryptde l'API du service de gestion des AWS clés.

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 Guide 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 Guide 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 How to perform on-demand key rotation dans le Guide 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 de AWS supprimer définitivement la clé KMS 15 jours après la fin de la commande.

aws kms schedule-key-deletion \
    --key-id arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab \
    --pending-window-in-days 15

La réponse inclut l’ARN de la clé, le statut de la clé, la période d’attente (PendingWindowInDays) et la date de suppression en heure Unix. Pour afficher la date de suppression en heure locale, utilisez la console AWS KMS. Il n’est pas possible d’utiliser des clés KMS avec le statut de clé PendingDeletion dans les opérations cryptographiques.

{
    "KeyId": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "DeletionDate": "2022-06-18T23:43:51.272000+00:00",
    "KeyState": "PendingDeletion",
    "PendingWindowInDays": 15
}

Pour plus d’informations, consultez Suppression des clés dans le Guide 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 la AWS CLI v2, la valeur du message paramètre doit être codée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le fileb:// préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.

Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est SIGN_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 de clés KMS asymétriques dans AWS KMS, voir Clés asymétriques dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Exemple 2 : pour enregistrer une signature numérique dans un fichier (Linux et macOS)

L’exemple sign suivant génère une signature cryptographique pour un message court stocké dans un fichier local. La commande obtient également la Signature propriété à partir de la réponse, la décode en Base64 et l'enregistre dans le fichier. ExampleSignature Vous pouvez utiliser le fichier de signature dans une commande verify qui vérifie la signature.

La commande sign nécessite un message encodé en Base64 et un algorithme de signature pris en charge par votre clé KMS asymétrique. Pour obtenir les algorithmes de signature pris en charge par votre clé KMS, utilisez la commande describe-key.

Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est SIGN_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 de clés KMS asymétriques dans AWS KMS, voir Clés asymétriques dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Pour ajouter une balise à une clé KMS

L’exemple tag-resource suivant ajoute des balises "Purpose":"Test" et "Dept":"IT" à une clé KMS gérée par le client. Vous pouvez utiliser de telles balises pour étiqueter les clés KMS et créer des catégories de clés KMS à des fins d’autorisation et d’audit.

Pour spécifier la clé KMS, utilisez le paramètre key-id. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser un ID de clé ou un ARN de clé dans cette commande.

aws kms tag-resource \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --tags TagKey='Purpose',TagValue='Test' TagKey='Dept',TagValue='IT'

Cette commande ne produit aucune sortie. Pour afficher les balises d'une clé AWS KMS KMS, utilisez la list-resource-tags commande.

Pour plus d'informations sur l'utilisation des balises dans AWS KMS, consultez la section Balisage des clés dans le Guide du développeur du service de gestion des AWS clés.

Pour supprimer une balise d’une clé KMS

L’exemple untag-resource suivant supprime la balise contenant la clé "Purpose" d’une clé KMS gérée par le client.

Pour spécifier la clé KMS, utilisez le paramètre key-id. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser un ID de clé ou un ARN de clé dans cette commande. Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.

aws kms untag-resource \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --tag-key 'Purpose'

Cette commande ne produit aucune sortie. Pour afficher les balises d'une clé AWS KMS KMS, utilisez la list-resource-tags commande.

Pour plus d'informations sur l'utilisation des balises dans AWS KMS, consultez la section Balisage des clés dans le Guide du développeur du service de gestion des AWS clés.

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 Guide 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 la section Modification des paramètres du magasin de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés.AWS

Pour plus d’informations sur la mise à jour d’un magasin de clés externe, consultez Editing external key store properties dans le Guide du développeur AWS  Key Management Service .

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

L’exemple update-custom-key-store suivant met à jour la valeur du mot de passe kmsuser par le mot de passe actuel de kmsuser dans le cluster CloudHSM associé au magasin de clés spécifié. Cette commande ne modifie pas le mot de passe kmsuser du cluster. Il indique simplement à AWS KMS le mot de passe actuel. Si KMS ne possède pas le mot de kmsuser passe actuel, il ne peut pas se connecter au magasin de AWS clés CloudHSM.

REMARQUE : Avant de mettre à jour un magasin de clés AWS CloudHSM, vous devez le déconnecter. Utilisez la commande disconnect-custom-key-store. Une fois la commande terminée, vous pouvez reconnecter le magasin de clés AWS CloudHSM. Utilisez la commande connect-custom-key-store.

aws kms update-custom-key-store \
    --custom-key-store-id cks-1234567890abcdef0 \
    --key-store-password ExamplePassword

Cette commande ne renvoie aucune sortie. Pour vérifier que la modification est en vigueur, utilisez la commande describe-custom-key-stores.

Pour plus d'informations sur la mise à jour d'un magasin de clés AWS CloudHSM, consultez la section Modification des paramètres du magasin de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés.AWS

Exemple 3 : pour modifier le cluster AWS CloudHSM d'un AWS magasin de clés CloudHSM

L'exemple suivant remplace le cluster AWS CloudHSM associé à un magasin de clés AWS CloudHSM par un cluster apparenté, tel qu'une sauvegarde différente du même cluster.

REMARQUE : Avant de mettre à jour un magasin de clés AWS CloudHSM, vous devez le déconnecter. Utilisez la commande disconnect-custom-key-store. Une fois la commande terminée, vous pouvez reconnecter le magasin de clés AWS CloudHSM. Utilisez la commande connect-custom-key-store.

aws kms update-custom-key-store \
    --custom-key-store-id cks-1234567890abcdef0 \
    --cloud-hsm-cluster-id cluster-1a23b4cdefg

Cette commande ne renvoie aucune sortie. Pour vérifier que la modification est en vigueur, utilisez la commande describe-custom-key-stores.

Pour plus d'informations sur la mise à jour d'un magasin de clés AWS CloudHSM, consultez la section Modification des paramètres du magasin de clés AWS CloudHSM dans le guide du développeur du service de gestion des clés.AWS

Exemple 4 : pour modifier les informations d’identification pour l’authentification du proxy d’un magasin de clés externe

L’exemple suivant met à jour les informations d’identification pour l’authentification du proxy pour votre magasin de clés externe. Vous devez spécifier à la fois raw-secret-access-key et access-key-id, même si vous ne modifiez qu’une seule des valeurs. Vous pouvez utiliser cette fonctionnalité pour corriger des informations d’identification non valides ou pour les modifier lorsque le proxy du magasin de clés externe les soumet immédiatement à une rotation.

Établissez les informations d'identification d'authentification proxy pour AWS KMS sur votre magasin de clés externe. Utilisez ensuite cette commande pour fournir les informations d'identification à AWS KMS. AWS KMS utilise ces informations d'identification pour signer ses demandes à votre proxy de stockage de clés externe.

Vous pouvez mettre à jour les informations d’identification pour l’authentification du proxy lorsque le magasin de clés externe est connecté ou déconnecté. Pour déterminer l’état de connexion de votre magasin de clés personnalisé, utilisez la commande describe-custom-key-store.

aws kms update-custom-key-store \
    --custom-key-store-id cks-1234567890abcdef0 \
    --xks-proxy-authentication-credential "AccessKeyId=ABCDE12345670EXAMPLE, RawSecretAccessKey=DXjSUawnel2fr6SKC7G25CNxTyWKE5PF9XX6H/u9pSo="

Cette commande ne renvoie aucune sortie. Pour vérifier que la modification est en vigueur, utilisez la commande describe-custom-key-stores.

Pour plus d’informations sur la mise à jour d’un magasin de clés externe, consultez Editing external key store properties dans le Guide du développeur AWS  Key Management Service .

Exemple 5 : pour modifier la connectivité du proxy d’un magasin de clés externe

L’exemple suivant modifie l’option de connectivité du proxy du magasin de clés externe, qui passe d’une connectivité au point de terminaison public à une connectivité au service de point de terminaison d’un VPC. Outre la modification de la valeur xks-proxy-connectivity, vous devez modifier la valeur xks-proxy-uri-endpoint afin de refléter le nom DNS privé associé au service de point de terminaison d’un VPC. Vous devez également ajouter une valeur xks-proxy-vpc-endpoint-service-name.

REMARQUE : avant de mettre à jour la connectivité du proxy d’un magasin externe, vous devez le déconnecter. Utilisez la commande disconnect-custom-key-store. Une fois la commande terminée, vous pouvez reconnecter le magasin de clés externe à l’aide de la commande connect-custom-key-store.

aws kms update-custom-key-store \
    --custom-key-store-id cks-1234567890abcdef0 \
    --xks-proxy-connectivity VPC_ENDPOINT_SERVICE \
    --xks-proxy-uri-endpoint "https://myproxy-private.xks.example.com" \
    --xks-proxy-vpc-endpoint-service-name "com.amazonaws.vpce.us-east-1.vpce-svc-example"

Cette commande ne renvoie aucune sortie. Pour vérifier que la modification est en vigueur, utilisez la commande describe-custom-key-stores.

Pour plus d’informations sur la mise à jour d’un magasin de clés externe, consultez Editing external key store properties dans le Guide 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 la référence UpdateKeyDescriptionde l'API du service de gestion des AWS clés.

Exemple 2 : pour supprimer la description d’une clé KMS gérée par le client

L’exemple update-key-description suivant supprime la description d’une clé KMS gérée par le client.

Le paramètre --key-id identifie la clé KMS dans la commande. Cet exemple utilise une valeur d’ID de clé, mais vous pouvez utiliser l’ID de clé ou l’ARN de la clé KMS. Le paramètre --description avec une valeur de chaîne vide (’’) supprime la description existante.

aws kms update-key-description \
    --key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
    --description ''

Cette commande ne produit aucune sortie. Pour afficher la description d’une clé KMS, utilisez la commande describe-key.

Pour plus d'informations, consultez la référence UpdateKeyDescriptionde l'API du service de gestion des AWS clés.

Exemple 1 : pour vérifier un HMAC

La commande verify-mac suivante vérifie un HMAC pour un message particulier, des clés KMS HMAC et un algorithme MAC. La valeur « true » dans la MacValid réponse indique que le HMAC est valide.

Dans la AWS CLI v2, la valeur du message paramètre doit être codée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le fileb:// préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.

Le MAC que vous spécifiez ne peut pas être encodé en base64. Pour obtenir de l’aide pour décoder le MAC renvoyé par la commande generate-mac, consultez les exemples de commandes generate-mac.

Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte. L’ID de clé doit représenter une clé KMS HMAC avec comme utilisation de GENERATE_VERIFY_MAC.

msg=(echo 'Hello World' | base64)

aws kms verify-mac \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --message fileb://Message \
    --mac-algorithm HMAC_SHA_384 \
    --mac fileb://ExampleMac

Sortie :

{
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "MacValid": true,
    "MacAlgorithm": "HMAC_SHA_384"
}

Pour plus d'informations sur l'utilisation des clés HMAC KMS dans AWS KMS, consultez la section Clés HMAC dans AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

Pour vérifier une signature numérique

La commande verify suivante vérifie la signature cryptographique d’un court message encodé en Base64. L’ID de clé, le message, le type de message et l’algorithme de signature doivent être identiques à ceux utilisés pour signer le message.

Dans la AWS CLI v2, la valeur du message paramètre doit être codée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le fileb:// préfixe, qui indique à la AWS CLI de lire les données binaires du fichier.

La signature que vous spécifiez ne peut pas être encodée en base64. Pour obtenir de l’aide pour décoder la signature renvoyée par la commande sign, consultez les exemples de commandes sign.

La sortie de la commande inclut un champ SignatureValid booléen qui indique que la signature a été vérifiée. Si la validation de la signature échoue, la commande verify échoue également.

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

aws kms verify \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --message fileb://EncodedMessage \
    --message-type RAW \
    --signing-algorithm RSASSA_PKCS1_V1_5_SHA_256 \
    --signature fileb://ExampleSignature

Sortie :

{
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "SignatureValid": true,
    "SigningAlgorithm": "RSASSA_PKCS1_V1_5_SHA_256"
}

Pour plus d'informations sur l'utilisation de clés KMS asymétriques dans AWS KMS, consultez la section Utilisation de clés asymétriques dans le Guide du développeur du service de gestion des AWS clés.