AWS KMS exemples utilisant AWS CLI

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

L'cancel-key-deletionexemple 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 cancel-key-deletion commande aboutit, la suppression planifiée est annulée. Cependant, l'état de la clé KMS est Disabled tel que vous ne pouvez pas utiliser la clé KMS dans des opérations cryptographiques. Pour restaurer ses fonctionnalités, utilisez la enable-key commande.

Pour plus d'informations, consultez la section Planification et annulation de la suppression de clés dans le Guide du développeur du service de gestion des AWS clés.

Pour connecter un magasin de clés personnalisé

L'connect-custom-key-storeexemple 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, describe-custom-key-stores utilisez-la.

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 la section Connexion et déconnexion d'un magasin de clés externe dans le Guide du développeur du service de gestion des AWS clés.

Pour créer un alias pour une clé KMS

La create-alias commande 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 paralias/. 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 list-aliases commande.

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

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 lecustom-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é de 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, le préfixe facultatif est XksProxyUriPath utilisé pour. 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 la section Création d'un magasin de clés externe dans le Guide du développeur du service de gestion des AWS clés.

Exemple 3 : pour créer un magasin de clés externe avec connectivité au service de point de terminaison 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 la section Création d'un magasin de clés externe dans le Guide du développeur du service de gestion des AWS clés.

Pour créer une subvention

L'create-grantexemple suivant crée une autorisation qui permet à l'exampleUserutilisateur d'utiliser la decrypt commande sur l'1234abcd-12ab-34cd-56ef-1234567890abexemple de clé KMS. Le principal partant à la retraite est le adminRole rôle. L'autorisation utilise la EncryptionContextSubset contrainte d'autorisation pour autoriser cette autorisation uniquement lorsque le contexte de chiffrement de la decrypt demande inclut la paire "Department": "IT" clé-valeur.

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 la subvention, utilisez la list-grants commande.

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'create-keyexemple 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 politique de clé, la clé KMS obtient la politique de clé par défaut pour les clés KMS créées par programmation. Pour afficher la politique clé, utilisez la get-key-policy commande. Pour modifier la politique clé, utilisez la put-key-policy commande.

aws kms create-key

La create-key commande renvoie les métadonnées clés, 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 lelist-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 create-key commande ne vous permet pas de spécifier un alias. Pour créer un alias pour la nouvelle clé KMS, utilisez la create-alias commande.

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

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

L'create-keyexemple suivant crée une clé KMS contenant une paire de clés RSA asymétrique pour le chiffrement et le déchiffrement. Les spécifications et l'utilisation de la clé ne peuvent pas être modifiées une fois la clé 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 à 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 à courbe elliptique asymétrique (ECC) pour la signature et la vérification. Le --key-usage paramètre est obligatoire même s'il s'SIGN_VERIFYagit de la seule valeur valide pour les clés ECC KMS. Les spécifications et l'utilisation de la clé ne peuvent pas être modifiées une fois la clé 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 d'utilisation des clés est obligatoire même s'il s'SIGN_VERIFYagit de 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é HMAC KMS

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

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 multirégionale

L'create-keyexemple suivant crée une clé de chiffrement symétrique principale multirégionale. Étant donné que les valeurs par défaut de tous les paramètres créent une clé de chiffrement symétrique, seul le --multi-region paramètre 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 le matériel clé importé

L'create-keyexemple suivant crée une clé KMS sans aucun élément clé. Lorsque l'opération est terminée, vous pouvez importer votre propre matériel clé dans la clé KMS. Pour créer cette clé KMS, définissez le --origin paramètre surEXTERNAL.

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 les magasins de clés AWS CloudHSM dans AWS le Guide du développeur du service de gestion des clés.

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

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

Le --xks-key-id paramètre indique l'ID d'une clé de chiffrement symétrique existante dans votre gestionnaire de clés externe. Cette clé sert de matériau de clé externe pour la clé KMS. La valeur du --origin paramètre doit être EXTERNAL_KEY_STORE .Le custom-key-store-id paramètre 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 la section Stockages de clés externes dans le Guide du développeur du service de gestion des AWS clés.

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 --ciphertext-blob paramètre, utilisez le fileb:// préfixe, qui indique à la 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 des 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 comme vous le souhaitez et vous empêche de déchiffrer par inadvertance un texte chiffré à l'aide d'une clé KMS non fiable.Demandez la sortie en texte brut sous forme de valeur de texte.Le paramètre --query indique à la CLI de n'obtenir que la valeur du champ à partir de la sortie. Plaintext Le --output paramètre renvoie la sortie sous forme de texte.Base64 décodez le texte en clair et enregistrez-le dans un fichier. L'exemple suivant montre comment rediriger (|) la valeur du Plaintext paramètre vers l'utilitaire Base64, qui le décode. Ensuite, il redirige (>) la sortie décodée vers le ExamplePlaintext 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.

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 aucun résultat. La sortie de la decrypt commande est décodée en base64 et enregistrée dans un fichier.

Pour plus d'informations, voir Déchiffrer dans le manuel de référence de l'API du service de gestion des AWS clés.

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'certutilutilitaire pour décoder les données en texte brut en Base64. Cette procédure nécessite 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, voir Déchiffrer dans le manuel de référence de l'API du service de gestion des AWS clés.

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

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

Lors de l'utilisation d'une clé KMS asymétrique, le encryption-algorithm paramètre, qui spécifie l'algorithme utilisé pour chiffrer le texte en clair, 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 aucun résultat. La sortie de la decrypt commande 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'delete-aliasexemple suivant supprime l'aliasalias/example-alias. Le nom de l'alias doit commencer par alias/.

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

Cette commande ne produit aucun résultat. Pour trouver l'alias, utilisez la list-aliases commande.

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

Pour supprimer un magasin de clés personnalisé

L'delete-custom-key-storeexemple 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'une banque de clés externe n'a aucun effet sur le proxy de banque de clés externe, le gestionnaire de clés externe ou les clés externes associés.

REMARQUE : Avant de 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é est supprimé, utilisez la describe-custom-key-stores commande.

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 banques de clés externes, consultez la section Suppression d'une banque de clés externe dans le Guide du développeur du service de gestion des AWS clés.

Pour supprimer le contenu clé importé d'une clé KMS

L'delete-imported-key-materialexemple suivant supprime le matériel clé qui a été importé 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 la section Suppression d'éléments clés importés dans le Guide du développeur du service de gestion des AWS clés.

Pour obtenir un secret partagé

L'derive-shared-secretexemple suivant déduit un secret partagé à l'aide d'un algorithme d'accord de clés.

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 du compte et de la région. Pour afficher des informations sur un magasin de clés personnalisé en particulier, utilisez le custom-key-store-id paramètre custom-key-store-name or.

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 défini comme tel, la sortie inclut un ConnectionErrorCode champ 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 des informations sur un magasin de clés externe connecté à un point de terminaison public

L'describe-custom-key-storeexemple suivant affiche des détails 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 du compte et de la région. Pour afficher des informations sur un magasin de clés personnalisé en particulier, utilisez le custom-key-store-id paramètre custom-key-store-name or.

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

Le résultat de cette commande inclut des détails utiles sur le magasin de clés externe, notamment son état de connexion (ConnectionState). Si l'état de connexion est FAILED défini comme tel, la sortie inclut un ConnectionErrorCode champ 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 la section Affichage d'un magasin de clés externe dans le Guide du développeur du service de gestion des AWS clés.

Exemple 3 : pour obtenir des informations sur un magasin de clés externe doté d'une connectivité au service de point de terminaison VPC

L'describe-custom-key-storeexemple suivant affiche des détails 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, dans le cas d'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 du compte et de la région. Pour afficher des informations sur un magasin de clés personnalisé en particulier, utilisez le custom-key-store-id paramètre custom-key-store-name or.

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

Le résultat de cette commande inclut des détails utiles sur le magasin de clés externe, notamment son état de connexion (ConnectionState). Si l'état de connexion est FAILED défini comme tel, la sortie inclut un ConnectionErrorCode champ 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 la section Affichage d'un magasin de clés externe dans le Guide du développeur du service de gestion des AWS clés.

Exemple 1 : pour trouver 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 key-id paramètre. 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 la section Affichage des clés dans le Guide du développeur du service de gestion des AWS clés.

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

L'describe-keyexemple suivant fournit des informations détaillées sur une clé RSA 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éplique multirégionale

L'describe-keyexemple suivant permet d'obtenir les métadonnées d'une clé de réplique multirégionale. Cette clé multirégionale est une clé de chiffrement symétrique. La sortie d'une describe-key commande pour une clé multirégionale renvoie des informations sur la clé primaire et toutes ses répliques.

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é HMAC KMS

L'describe-keyexemple suivant permet d'obtenir des informations détaillées sur une clé HMAC KMS.

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'disable-key-rotationexemple suivant désactive la rotation automatique d'une clé KMS gérée par le client. Pour réactiver la rotation automatique, utilisez la enable-key-rotation commande.

aws kms disable-key-rotation \
    --key-id arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab

Cette commande ne produit aucun résultat. Pour vérifier que la rotation automatique est désactivée pour la clé KMS, utilisez la get-key-rotation-status commande.

Pour plus d'informations, voir Rotation des clés dans le Guide du développeur du service de gestion des AWS clés.

Pour désactiver temporairement une clé KMS

La disable-key commande suivante désactive une clé KMS gérée par le client. Pour réactiver la clé KMS, utilisez la enable-key commande.

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

Cette commande ne produit aucun résultat.

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

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. Vérifiez que la commande est efficace, utilisez-la. 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 la section Connexion et déconnexion d'un magasin de clés externe dans le Guide du développeur du service de gestion des AWS clés.

Pour activer la rotation automatique d'une clé KMS

L'enable-key-rotationexemple 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 --key-id paramètre identifie la clé KMS. Cet exemple utilise une valeur ARN clé, mais vous pouvez utiliser l'ID de clé ou l'ARN de la clé KMS. Le --rotation-period-in-days paramètre indique le nombre de jours entre chaque date de rotation. Spécifiez une valeur comprise entre 90 et 2560 jours. Si aucune valeur n'est spécifiée, la valeur par défaut est de 365 jours.

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 aucun résultat. Pour vérifier que la clé KMS est activée, utilisez la get-key-rotation-status commande.

Pour plus d'informations, voir Rotation des clés dans le Guide du développeur du service de gestion des AWS clés.

Pour activer une clé KMS

L'enable-keyexemple 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 disable-key commande. Vous pouvez également l'utiliser pour activer une clé KMS qui est désactivée car sa suppression a été planifiée et la suppression a été annulée.

Pour spécifier la clé KMS, utilisez le key-id paramètre. 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 identifiant valide.

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

Cette commande ne produit aucun résultat. Pour vérifier que la clé KMS est activée, utilisez la describe-key commande. Consultez les valeurs des Enabled champs KeyState et dans la describe-key sortie.

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

Exemple 1 : 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 --plaintext paramètre 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 le même que le précédent, sauf qu'il utilise l'certutiloutil au lieu debase64. Cette procédure nécessite 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 encrypt commande suivante montre comment chiffrer du texte en clair 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 aucun résultat.

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. Il 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 key-pair-spec paramètre avec une valeur de. 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 KeySpec la valeur est deSYMMETRIC_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 PublicKey et PrivateKeyCiphertextBlob sont renvoyés au format codé en base64.

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

Pour générer une paire de clés de données asymétriques RSA de 2048 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 en clair et une clé privée en texte clair 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 cryptée avec les données cryptées.

Pour demander une paire de clés de données asymétriques RSA de 2048 bits, utilisez le key-pair-spec paramètre avec une valeur de. 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 KeySpec la valeur est deSYMMETRIC_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 PublicKeyPrivateKeyPlaintext, et PrivateKeyCiphertextBlob sont renvoyés au format codé en base64.

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

Pour générer une clé de données symétrique de 256 bits sans clé en texte brut

L'generate-data-key-without-plaintextexemple suivant demande une copie cryptée d'une clé de données symétrique de 256 bits pour une utilisation en dehors de. 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 key-spec paramètre avec une valeur de. AES_256 Pour demander une clé de données de 128 bits, utilisez le key-spec paramètre avec une valeur de. AES_128 Pour toutes les autres longueurs de clé de données, utilisez le number-of-bytes paramètre.

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

aws kms generate-data-key-without-plaintext \
    --key-id "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab" \
    --key-spec AES_256

Sortie :

{
    "CiphertextBlob": "AQEDAHjRYf5WytIc0C857tFSnBaPn2F8DgfmThbJlGfR8P3WlwAAAH4wfAYJKoZIhvcNAQcGoG8wbQIBADBoBgkqhkiG9w0BBwEwHgYJYIZIAWUDBAEuMBEEDEFogL",
    "KeyId": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
}

La CiphertextBlob (clé de données cryptée) est renvoyée au format codé en base64.

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

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

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

aws kms generate-data-key \
    --key-id alias/ExampleAlias \
    --key-spec AES_256

Sortie :

{
    "Plaintext": "VdzKNHGzUAzJeRBVY+uUmofUGGiDzyB3+i9fVkh3piw=",
    "KeyId": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6",
    "CiphertextBlob": "AQEDAHjRYf5WytIc0C857tFSnBaPn2F8DgfmThbJlGfR8P3WlwAAAH4wfAYJKoZIhvcNAQcGoG8wbQIBADBoBgkqhkiG9w0BBwEwHgYJYIZIAWUDBAEuMBEEDEFogLqPWZconQhwHAIBEIA7d9AC7GeJJM34njQvg4Wf1d5sw0NIo1MrBqZa+YdhV8MrkBQPeac0ReRVNDt9qleAt+SHgIRF8P0H+7U="
}

La Plaintext (clé de données en texte brut) et la CiphertextBlob (clé de données cryptée) sont renvoyées au format codé en base64.

Pour plus d'informations, consultez la section Clés de données dans le Guide du développeur du service de gestion des AWS clés. Exemple 2 : pour générer une clé de données symétrique 512 bits

L'generate-data-keyexemple 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 number-of-bytes paramètre. Pour demander une clé de données 512 bits, l'exemple suivant utilise le number-of-bytes paramètre 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"
}

Les Plaintext (clé de données en texte brut) et CiphertextBlob (clé de données cryptée) sont renvoyées au format codé en base64.

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

Exemple 1 : Pour générer un HMAC pour un message

La generate-mac commande suivante génère un HMAC pour un message, une clé HMAC KMS et un algorithme MAC. L'algorithme doit être pris en charge par la clé HMAC KMS 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é HMAC KMS dont l'utilisation de la clé est deGENERATE_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'generate-macexemple suivant génère un HMAC pour un message court stocké dans un fichier local. La commande extrait également la Mac propriété de la réponse, la décode en Base64 et l'enregistre dans le fichier. ExampleMac Vous pouvez utiliser le fichier MAC dans une verify-mac commande qui vérifie le MAC.

La generate-mac commande nécessite un message codé en Base64 et un algorithme MAC pris en charge par votre clé HMAC KMS. Pour obtenir les algorithmes MAC pris en charge par votre clé KMS, utilisez la describe-key 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. L'ID de clé doit représenter une clé KMS asymétrique avec une utilisation de la clé 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 aucun résultat. Cet exemple extrait la Mac propriété 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'generate-randomexemple suivant génère une chaîne d'octets aléatoire de 256 bits (32 octets) codé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 number-of-bytes paramètre 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 aucun résultat.

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 generate-random commande pour générer une chaîne d'octets aléatoire de 256 bits (32 octets) codé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'certutilutilitaire 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 codé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 generate-random commande étant enregistrée dans un fichier, cet exemple ne produit aucune sortie.

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

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 politique clé d'une clé KMS vers une autre clé KMS

L'get-key-policyexemple suivant extrait la politique clé d'une clé KMS et l'enregistre dans un fichier texte. Il remplace ensuite la politique d'une autre clé KMS en utilisant le fichier texte comme entrée de politique.

Comme le --policy paramètre de put-key-policy nécessite une chaîne, vous devez utiliser l'--output textoption 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 aucun résultat.

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

Pour récupérer l'état de rotation d'une clé KMS.

L'get-key-rotation-statusexemple suivant renvoie des informations sur l'état 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, voir Rotation des clés dans le Guide du développeur du service de gestion des AWS clés.

Pour obtenir les éléments nécessaires à l'importation de matériel clé dans une clé KMS

L'get-parameters-for-importexemple suivant permet d'obtenir la clé publique et le jeton d'importation dont vous avez besoin pour importer le matériel clé dans une clé KMS. Lorsque vous utilisez la import-key-material commande, veillez à utiliser le jeton d'importation et le contenu clé chiffrés par la clé publique renvoyés dans la même get-parameters-for-import commande. En outre, l'algorithme d'encapsulage que vous spécifiez dans cette commande doit être celui que vous utilisez pour chiffrer le contenu clé avec la clé publique.

Pour spécifier la clé KMS, utilisez le key-id paramètre. 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, voir Télécharger la clé publique et le jeton d'importation dans le Guide du développeur du service de gestion des AWS clés.

Exemple 1 : pour télécharger la clé publique d'une clé KMS asymétrique

L'get-public-keyexemple 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, 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 2 : pour convertir une clé publique au format DER (Linux et macOS)

L'get-public-keyexemple 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 obtient la valeur de la PublicKey propriété sous forme de texte. Il les décode en Base64 PublicKey et les enregistre dans le fichier. public_key.der Le output paramètre 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 aucun résultat.

Pour plus d'informations sur l'utilisation de clés KMS asymétriques dans AWS KMS, 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 importer du matériel clé dans une clé KMS

L'import-key-materialexemple suivant télécharge le contenu clé dans une clé KMS créée sans élément clé. L'état de la clé KMS doit êtrePendingImport.

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

Le expiration-model paramètre indique que le matériel clé expire automatiquement à la date et à l'heure spécifiées par le valid-to paramètre. 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 le même contenu clé. Pour utiliser un autre matériel 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 de matériel clé, voir Importation de matériel clé dans le Guide du développeur du service de gestion des AWS clés.

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 list-aliases commande et son key-id paramètre pour répertorier tous les alias associés à une clé KMS particulière.

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 list-aliases commande.

Cet exemple utilise l'ID de clé KMS pour le --key-id paramètre, 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 la section Travailler avec des alias dans le Guide du développeur du service de gestion des AWS clés.

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 key-id paramètre 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

Le résultat indique que l'autorisation autorise Amazon DynamoDB à utiliser la clé KMS pour des opérations cryptographiques, à consulter les informations relatives à la clé KMS DescribeKey () et à retirer les autorisations (). RetireGrant La EncryptionContextSubset contrainte limite ces autorisations aux demandes qui incluent les paires de contextes de chiffrement spécifiées. Par conséquent, les autorisations de la subvention 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 politiques clés pour une clé KMS

L'list-key-policiesexemple suivant obtient les noms des politiques clés 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 politique clé valide estdefault, cette commande n'est pas utile.

Pour spécifier la clé KMS, utilisez le key-id paramètre. 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 récupérer des informations sur toutes les rotations de matériaux clés terminées

L'list-key-rotationsexemple suivant répertorie les informations relatives à toutes les rotations de matériaux clés 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, voir Rotation des clés dans le Guide du développeur du service de gestion des AWS clés.

Pour obtenir les clés KMS dans un compte et une région

L'list-keysexemple suivant permet d'obtenir 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 la section Visualisation des clés dans le guide du développeur du service de gestion des AWS clés.

Pour obtenir les balises d'une clé KMS

L'list-resource-tagsexemple suivant permet d'obtenir les balises d'une clé KMS. Pour ajouter ou remplacer des balises de ressources sur les clés KMS, utilisez la tag-resource commande. 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 key-id paramètre. 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 consulter les subventions qu'un directeur peut retirer

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 retiring-principal paramètre requis doit être le nom de ressource Amazon (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 sortant. Pour trouver les subventions dans lesquelles un service particulier est le principal partant à la retraite, utilisez la list-grants commande.

Le résultat indique que ExampleAdmin l'utilisateur est autorisé à retirer les autorisations sur deux clés KMS différentes dans le compte et dans la région. Outre le capital retraité, le compte est autorisé à retirer toute subvention 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 politique de clé d'une clé KMS

L'put-key-policyexemple suivant modifie la politique de clé pour une clé gérée par le client.

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

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'test-userutilisateur à exécuter les list-keys commandes describe-key et 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 la clé, mais vous pouvez également utiliser un ARN de clé. Pour spécifier la politique clé, la commande utilise le policy paramètre. Pour indiquer que la politique se trouve dans un fichier, elle utilise le file:// préfixe 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 policy-name paramètre avec une valeur dedefault. Si aucun nom de politique n'est spécifié, la valeur par défaut estdefault. 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, get-key-policy utilisez-la. L'exemple de commande suivant permet d'obtenir la politique de clé pour la même clé KMS. Le output paramètre avec une valeur de 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 la section Modification d'une politique clé dans le guide du développeur du service de gestion des AWS clés.

Exemple 1 : 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 --ciphertext-blob paramètre, utilisez le fileb:// préfixe, qui indique à la 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 comme vous le souhaitez 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 chiffre à nouveau les données. Le paramètre est toujours obligatoire. --destination-key-id 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 --query paramètre indique à la CLI de n'obtenir que la valeur du champ à partir de Plaintext la sortie. Le --output paramètre renvoie la sortie sous forme de texte.Base64 décodez le texte en clair et enregistrez-le dans un fichier. L'exemple suivant montre comment rediriger (|) la valeur du Plaintext paramètre vers l'utilitaire Base64, qui le décode. Ensuite, il redirige (>) la sortie décodée vers le ExamplePlaintext fichier.

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 aucun résultat. La sortie de la re-encrypt commande 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 re-encrypt commande suivant est identique au précédent, sauf qu'il utilise l'certutilutilitaire pour décoder les données en texte brut en Base64. Cette procédure nécessite 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'certutilutilitaire

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 annuler une subvention sur la clé principale d'un client

L'retire-grantexemple suivant supprime une autorisation d'une clé KMS.

L'exemple de commande suivant spécifie les key-id paramètres grant-id et. La valeur du key-id paramètre doit être la clé ARN 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 aucun résultat. Pour confirmer que la subvention a été retirée, utilisez la list-grants commande.

Pour plus d'informations, consultez la section Retrait et révocation des subventions dans le Guide du développeur du service de gestion des AWS clés.

Pour révoquer une autorisation sur la clé principale d'un client

L'revoke-grantexemple suivant supprime une autorisation d'une clé KMS. L'exemple de commande suivant spécifie les key-id paramètres grant-id et. La valeur du key-id paramètre peut être l'ID de clé ou l'ARN de la clé KMS.

aws kms revoke-grant \
    --grant-id 1234a2345b8a4e350500d432bccf8ecd6506710e1391880c4f7f7140160c9af3 \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Cette commande ne produit aucun résultat. Pour confirmer que l'autorisation a été révoquée, utilisez la list-grants commande.

Pour plus d'informations, consultez la section Retrait et révocation des subventions dans le Guide du développeur du service de gestion des AWS clés.

Pour effectuer la rotation à la demande d'une clé KMS

L'rotate-key-on-demandexemple suivant lance immédiatement la rotation du matériau 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 la section Comment effectuer une rotation des clés à la demande dans le Guide du développeur du service de gestion des AWS clés.

Pour planifier la suppression d'une clé KMS gérée par le client.

L'schedule-key-deletionexemple suivant planifie la suppression de la clé KMS gérée par le client spécifiée dans les 15 jours.

Le --key-id paramètre identifie la clé KMS. Cet exemple utilise une valeur ARN clé, mais vous pouvez utiliser l'ID de clé ou l'ARN de la clé KMS. Le --pending-window-in-days paramètre indique la durée de la période d'attente de 7 à 30 jours. Par défaut, le délai d'attente 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é, l'état de la clé, le délai 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. Les clés KMS à l'état PendingDeletion clé ne peuvent pas être utilisées dans des 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 la section Suppression de clés dans le guide du développeur du service de gestion des AWS clés.

Exemple 1 : pour générer une signature numérique pour un message

L'signexemple suivant génère une signature cryptographique pour un message court. La sortie de la commande inclut un Signature champ codé en base 64 que vous pouvez vérifier à l'aide de la verify commande.

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 de signature de votre clé KMS, utilisez la describe-key commande.

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 avec une clé d'utilisation de 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, 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 2 : pour enregistrer une signature numérique dans un fichier (Linux et macOS)

L'signexemple 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 verify commande qui vérifie la signature.

La sign commande nécessite un message codé 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 describe-key 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. L'ID de clé doit représenter une clé KMS asymétrique avec une clé d'utilisation de 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 aucun résultat. Cet exemple extrait la Signature propriété 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, 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 ajouter une étiquette à une clé KMS

L'tag-resourceexemple suivant ajoute "Purpose":"Test" des "Dept":"IT" balises à 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 key-id paramètre. 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 aucun résultat. 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 étiquette d'une clé KMS

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

Pour spécifier la clé KMS, utilisez le key-id paramètre. 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 aucun résultat. 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'update-aliasexemple suivant associe l'alias alias/test-key à une autre clé KMS.

Le --alias-name paramètre spécifie l'alias. La valeur du nom d'alias doit commencer par alias/ .Le --target-key-id paramètre spécifie la clé KMS à associer à l'alias. Il n'est pas nécessaire 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 aucun résultat. Pour trouver l'alias, utilisez la list-aliases commande.

Pour plus d'informations, consultez la section Mise à jour des alias dans le Guide du développeur du service de gestion des AWS clés.

Exemple 1 : pour modifier le nom convivial d'un magasin de clés personnalisé

L'update-custom-key-storeexemple 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 le custom-key-store-id pour identifier le magasin de clés. Utilisez le new-custom-key-store-name paramètre 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 mettre à jour le nom convivial d'un magasin de clés externe lorsqu'il est connecté ou déconnecté. Pour connaître l'état de connexion de votre magasin de clés personnalisé, utilisez la describe-custom-key-store commande.

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 describe-custom-key-stores commande.

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 la section Modification des propriétés du magasin de clés externe dans le Guide du développeur du service de gestion des AWS clés.

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

L'update-custom-key-storeexemple suivant met à jour la valeur du kmsuser mot de passe par le mot de passe actuel du cluster CloudHSM associé au magasin de clés spécifié. kmsuser Cette commande ne modifie pas le kmsuser mot de passe 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 a été effective, utilisez une describe-custom-key-stores commande.

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 a été effective, utilisez une describe-custom-key-stores commande.

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'authentification du proxy d'un magasin de clés externe

L'exemple suivant met à jour les informations d'identification d'authentification du proxy pour votre banque de clés externe. Vous devez spécifier à la fois le raw-secret-access-key et leaccess-key-id, même si vous ne modifiez qu'une seule des valeurs. Vous pouvez utiliser cette fonctionnalité pour corriger un identifiant non valide ou pour le modifier lorsque le proxy externe du magasin de clés le fait pivoter.

É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'authentification du proxy lorsque le magasin de clés externe est connecté ou déconnecté. Pour connaître l'état de connexion de votre magasin de clés personnalisé, utilisez la describe-custom-key-store commande.

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 a été effective, utilisez une describe-custom-key-stores commande.

Pour plus d'informations sur la mise à jour d'un magasin de clés externe, consultez la section Modification des propriétés du magasin de clés externe dans le Guide du développeur du service de gestion des AWS clés.

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

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

REMARQUE : Avant de mettre à jour la connectivité 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 connect-custom-key-store commande.

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 a été effective, utilisez une describe-custom-key-stores commande.

Pour plus d'informations sur la mise à jour d'un magasin de clés externe, consultez la section Modification des propriétés du magasin de clés externe dans le Guide du développeur du service de gestion des AWS clés.

Exemple 1 : pour ajouter ou modifier une description à une clé KMS gérée par le client

L'update-key-descriptionexemple 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 --key-id paramètre identifie la clé KMS dans la commande. Cet exemple utilise une valeur d'ARN clé, mais vous pouvez utiliser l'ID de clé ou l'ARN clé de la clé KMS. Le --description paramètre 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 aucun résultat. Pour afficher la description d'une clé KMS, utilisez la describe-key commande.

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'update-key-descriptionexemple suivant supprime la description d'une clé KMS gérée par le client.

Le --key-id paramètre identifie la clé KMS dans la commande. Cet exemple utilise une valeur d'ID de clé, mais vous pouvez utiliser soit l'ID de clé, soit l'ARN de la clé KMS. Le --description paramètre 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 aucun résultat. 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 verify-mac commande suivante vérifie un HMAC pour un message spécifique, des clés HMAC KMS 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 codé en base64. Pour obtenir de l'aide pour décoder le MAC renvoyé par la generate-mac commande, consultez les exemples de generate-mac commandes.

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é HMAC KMS dont l'utilisation de la clé est deGENERATE_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 verify commande suivante vérifie la signature cryptographique d'un court message codé en Base64. L'identifiant 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 codée en base64. Pour obtenir de l'aide pour décoder la signature renvoyée par la sign commande, consultez les exemples de sign commandes.

La sortie de la commande inclut un SignatureValid champ booléen qui indique que la signature a été vérifiée. Si la validation de signature échoue, la verify commande é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.