AWS KMS exemplos usando AWS CLI

Para cancelar a exclusão programada de uma chave gerenciada pelo KMS cliente

O cancel-key-deletion exemplo a seguir cancela a exclusão programada de uma chave gerenciada pelo KMS cliente.

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

Saída:

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

Quando o cancel-key-deletion comando for bem-sucedido, a exclusão programada será cancelada. No entanto, o estado chave da KMS chave é Disabled que você não pode usar a KMS chave em operações criptográficas. Para restaurar sua funcionalidade, use o enable-key comando.

Para obter mais informações, consulte Agendamento e cancelamento da exclusão de chaves no Guia do desenvolvedor do AWS Key Management Service.

Para conectar um armazenamento de chaves personalizado

O connect-custom-key-store exemplo a seguir reconecta o armazenamento de chaves personalizadas especificado. Você pode usar um comando como esse para conectar um armazenamento de chaves personalizado pela primeira vez ou para reconectar um armazenamento de chaves que foi desconectado.

Você pode usar esse comando para conectar um armazenamento de HSM chaves do AWS Cloud ou um armazenamento de chaves externo.

aws kms connect-custom-key-store \
    --custom-key-store-id cks-1234567890abcdef0

Esse comando não retorna nenhuma saída. Use o comando describe-custom-key-stores para verificar se o comando está em vigor.

Para obter informações sobre como conectar um armazenamento de HSM chaves do AWS Cloud, consulte Como conectar e desconectar um armazenamento de HSM chaves do AWS Cloud no Guia do desenvolvedor do AWS Key Management Service.

Para obter informações sobre como conectar um armazenamento de chaves externo, consulte Conectando e desconectando um armazenamento de chaves externo no Guia do desenvolvedor do AWS Key Management Service.

Para criar um alias para uma chave KMS

O create-alias comando a seguir cria um alias com o nome example-alias da KMS chave identificada pelo ID 1234abcd-12ab-34cd-56ef-1234567890ab da chave.

Os nomes de alias devem começar com alias/. Não use nomes de alias que comecem comalias/aws; eles são reservados para uso por AWS.

aws kms create-alias \
    --alias-name alias/example-alias \
    --target-key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Esse comando não retorna resultados. Use o list-aliases comando para visualizar o novo alias.

Para obter mais informações, consulte Using aliases no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para criar um armazenamento de HSM chaves AWS na nuvem

O create-custom-key-store exemplo a seguir cria um armazenamento de HSM chaves do AWS Cloud apoiado por um HSM cluster do AWS Cloud usando os parâmetros necessários. Você também pode adicionar custom-key-store-type``parameter with the default value: ``AWS_CLOUDHSM o.

Para especificar a entrada do arquivo para o trust-anchor-certificate comando no AWS CLI, o file:// prefixo é necessário.

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

Saída:

{
    "CustomKeyStoreId": cks-1234567890abcdef0
}

Para obter mais informações, consulte Como criar um armazenamento de HSM chaves na AWS nuvem no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 2: Para criar um armazenamento de chaves externo com conectividade de endpoint público

O create-custom-key-store exemplo a seguir cria um armazenamento de chaves externo (XKS) que se comunica pela AWS KMS Internet.

Neste exemplo, o XksProxyUriPath usa um prefixo opcional deexample-prefix.

NOTE: se você usa a AWS CLI versão 1.0, execute o comando a seguir antes de especificar um parâmetro com um HTTPS valor HTTP ou, como o XksProxyUriEndpoint parâmetro.

aws configure set cli_follow_urlparam false

Caso contrário, a AWS CLI versão 1.0 substitui o valor do parâmetro pelo conteúdo encontrado nesse URI endereço.

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

Saída:

{
    "CustomKeyStoreId": cks-2234567890abcdef0
}

Para obter mais informações, consulte Criação de um armazenamento de chaves externo no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 3: Para criar um armazenamento de chaves externo com conectividade de serviço de VPC endpoint

O create-custom-key-store exemplo a seguir cria um armazenamento de chaves externo (XKS) que usa um serviço de VPC endpoint da Amazon para se comunicar AWS KMS.

NOTE: se você usa a AWS CLI versão 1.0, execute o comando a seguir antes de especificar um parâmetro com um HTTPS valor HTTP ou, como o XksProxyUriEndpoint parâmetro.

aws configure set cli_follow_urlparam false

Caso contrário, a AWS CLI versão 1.0 substitui o valor do parâmetro pelo conteúdo encontrado nesse URI endereço.

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

Saída:

{
    "CustomKeyStoreId": cks-3234567890abcdef0
}

Para obter mais informações, consulte Criação de um armazenamento de chaves externo no Guia do desenvolvedor do AWS Key Management Service.

Como criar uma concessão

O create-grant exemplo a seguir cria uma concessão que permite ao exampleUser usuário usar o decrypt comando na KMS chave de 1234abcd-12ab-34cd-56ef-1234567890ab exemplo. A entidade principal descontinuada é o perfil adminRole. A concessão usa a restrição de concessão EncryptionContextSubset para conceder essa permissão apenas quando o contexto de criptografia na solicitação decrypt incluir o par de chave/valor "Department": "IT".

aws kms create-grant \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --grantee-principal arn:aws:iam::123456789012:user/exampleUser \
    --operations Decrypt \
    --constraints EncryptionContextSubset={Department=IT} \
    --retiring-principal arn:aws:iam::123456789012:role/adminRole

Saída:

{
    "GrantId": "1a2b3c4d2f5e69f440bae30eaec9570bb1fb7358824f9ddfa1aa5a0dab1a59b2",
    "GrantToken": "<grant token here>"
}

Use o list-grants comando para visualizar informações detalhadas sobre a concessão.

Para obter mais informações, consulte Concessões AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para criar uma KMS chave gerenciada pelo cliente no AWS KMS

O create-key exemplo a seguir cria uma KMS chave de criptografia simétrica.

Para criar a KMS chave básica, uma chave de criptografia simétrica, você não precisa especificar nenhum parâmetro. Os valores padrão desses parâmetros criam uma chave de criptografia simétrica.

Como esse comando não especifica uma política de chaves, a KMS chave obtém a política de chaves padrão para chaves criadas KMS programaticamente. Use o comando get-key-policy para visualizar a política de chave. Use o comando put-key-policy para alterar a política de chave.

aws kms create-key

O create-key comando retorna os metadados da chave, incluindo o ID da chave e ARN da nova KMS chave. Você pode usar esses valores para identificar a KMS chave em outras AWS KMS operações. A saída não inclui as tags. Para ver as tags de uma KMS chave, use list-resource-tags command o.

Saída:

{
    "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",
        "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"
        ]
    }
}

Nota: O create-key comando não permite que você especifique um alias. Para criar um alias para a nova KMS chave, use o create-alias comando.

Para obter mais informações, consulte Creating keys no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 2: Para criar uma RSA KMS chave assimétrica para criptografia e decodificação

O create-key exemplo a seguir cria uma KMS chave que contém um par de RSA chaves assimétrico para criptografia e decodificação.

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

Saída:

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

Para obter mais informações, consulte Chaves assimétricas AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 3: Para criar uma KMS chave de curva elíptica assimétrica para assinatura e verificação

Para criar uma KMS chave assimétrica que contenha um ECC par de chaves curva elíptica assimétrica () para assinatura e verificação. O --key-usage parâmetro é obrigatório, embora SIGN_VERIFY seja o único valor válido para ECC KMS chaves.

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

Saída:

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

Para obter mais informações, consulte Chaves assimétricas AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 4: Para criar uma HMAC KMS chave

O create-key exemplo a seguir cria uma chave de 384 bits HMACKMS. O GENERATE_VERIFY_MAC valor do --key-usage parâmetro é obrigatório, embora seja o único valor válido para HMAC KMS chaves.

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

Saída:

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

Para obter mais informações, consulte HMACas chaves AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 4: Para criar uma chave primária KMS multirregional

O exemplo de create-key a seguir cria uma chave primária de criptografia simétrica multirregional. Como os valores padrão para todos os parâmetros criam uma chave de criptografia simétrica, somente o --multi-region parâmetro é necessário para essa KMS chave. No AWS CLI, para indicar que um parâmetro booleano é verdadeiro, basta especificar o nome do parâmetro.

aws kms create-key \
    --multi-region

Saída:

{
    "KeyMetadata": {
        "Arn": "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef12345678990ab",
        "AWSAccountId": "111122223333",
        "CreationDate": "2021-09-02T016:15:21-09:00",
        "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"
    }
}

Para obter mais informações, consulte Chaves assimétricas AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 5: Para criar uma KMS chave para material de chave importado

O create-key exemplo a seguir cria uma KMS chave sem material de chave. Quando a operação estiver concluída, você poderá importar seu próprio material de chave para a KMS chave. Para criar essa KMS chave, defina o --origin parâmetro comoEXTERNAL.

aws kms create-key \
    --origin EXTERNAL

Saída:

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

Para obter mais informações, consulte Importação de material chave em AWS KMS chaves no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 6: Para criar uma KMS chave em um armazenamento de HSM chaves do AWS Cloud

O create-key exemplo a seguir cria uma KMS chave no armazenamento de HSM chaves do AWS Cloud especificado. A operação cria a KMS chave e seus metadados AWS KMS e cria o material da chave no HSM cluster AWS Cloud associado ao armazenamento de chaves personalizadas. Os parâmetros --custom-key-store-id e --origin são obrigatórios.

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

Saída:

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

Para obter mais informações, consulte Armazenamentos de HSM chaves na AWS nuvem no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 7: Para criar uma KMS chave em um armazenamento de chaves externo

O create-key exemplo a seguir cria uma KMS chave no armazenamento de chaves externo especificado. Os parâmetros --custom-key-store-id, --origin e --xks-key-id são obrigatórios neste comando.

O parâmetro --xks-key-id especifica o ID de uma chave de criptografia simétrica existente no gerenciador de chaves externo. Essa chave serve como material de chave externa para a KMS chave.O valor do --origin parâmetro deve ser EXTERNAL_KEY_STORE .O custom-key-store-id parâmetro deve identificar um armazenamento de chaves externo conectado ao proxy externo do armazenamento de chaves.

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

Saída:

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

Para obter mais informações, consulte External key stores no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para descriptografar uma mensagem criptografada com uma chave simétrica (Linux e KMS macOS)

O exemplo de decrypt comando a seguir demonstra a forma recomendada de descriptografar dados com o. AWS CLI Esta versão mostra como descriptografar dados com uma chave simétrica. KMS

Forneça o texto cifrado em um arquivo. No valor do --ciphertext-blob parâmetro, use o fileb:// prefixo, que instrui o CLI a ler os dados de um arquivo binário. Se o arquivo não estiver no diretório atual, digite o caminho completo para o arquivo. Para obter mais informações sobre a leitura de valores de AWS CLI parâmetros de um arquivo, consulte Carregando AWS CLI parâmetros de um arquivo < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> no Guia do usuário da interface de linha de AWS comando e práticas recomendadas para parâmetros de arquivos locais< https://aws.amazon.com/blogs/ developer/ best-practices-for-local -file-parameters/> no blog da ferramenta de linha de AWS comando .Especifique a chave para descriptografar o texto cifrado.O parâmetro não é necessário ao descriptografar com uma KMS chave simétrica. --key-id KMS AWS KMSpode obter o ID da KMS chave que foi usada para criptografar os dados dos metadados no texto cifrado. Mas é sempre uma boa prática especificar a KMS chave que você está usando. Essa prática garante que você use a KMS chave desejada e evita que você decodifique inadvertidamente um texto cifrado usando uma KMS chave na qual você não confia.Solicite a saída de texto sem formatação como um valor de texto.O parâmetro solicita que o obtenha somente o valor do campo da saída. --query CLI Plaintext O parâmetro --output retorna a saída como texto. Decodifique o texto simples em Base64 e salve-o em um arquivo. O seguinte exemplo canaliza ( | ) o valor do parâmetro Plaintext para o utilitário Base64, que o decodifica. Em seguida, ele redireciona ( > ) a saída decodificada para o arquivo ExamplePlaintext.

Antes de executar esse comando, substitua o ID de chave de exemplo por um ID de chave válido da sua AWS conta.

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

Este comando não produz saída. A saída do comando decrypt é decodificada em base64 e salva em um arquivo.

Para obter mais informações, consulte Decrypt na Referência do Serviço de Gerenciamento de AWS Chaves. API

Exemplo 2: Para descriptografar uma mensagem criptografada com uma KMS chave simétrica (prompt de comando do Windows)

O exemplo a seguir é igual ao anterior, mas ele usa o utilitário certutil para decodificar em Base64 os dados em texto simples. Esse procedimento requer dois comandos, conforme mostrado nos exemplos a seguir.

Antes de executar esse comando, substitua o ID de chave de exemplo por um ID de chave válido da sua AWS conta.

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

Execute o comando certutil.

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Saída:

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

Para obter mais informações, consulte Decrypt na Referência do Serviço de Gerenciamento de AWS Chaves. API

Exemplo 3: Para descriptografar uma mensagem criptografada com uma chave assimétrica KMS (Linux e macOS)

O exemplo de decrypt comando a seguir mostra como descriptografar dados criptografados sob uma RSA chave assimétrica. KMS

Ao usar uma KMS chave assimétrica, o encryption-algorithm parâmetro, que especifica o algoritmo usado para criptografar o texto sem formatação, é obrigatório.

Antes de executar esse comando, substitua o ID de chave de exemplo por um ID de chave válido da sua AWS conta.

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

Este comando não produz saída. A saída do comando decrypt é decodificada em base64 e salva em um arquivo.

Para obter mais informações, consulte Chaves assimétricas AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Para excluir um AWS KMS alias

O exemplo de delete-alias a seguir exclui o alias alias/example-alias. O nome de alias deve começar com alias/.

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

Este comando não produz saída. Use o list-aliases comando para localizar o alias.

Para obter mais informações, consulte Deleting an alias no Guia do desenvolvedor do AWS Key Management Service.

Para excluir um armazenamento de chaves personalizado

O delete-custom-key-store exemplo a seguir exclui o armazenamento de chaves personalizadas especificado.

A exclusão de um armazenamento de HSM chaves do AWS Cloud não tem efeito no HSM cluster do Cloud associado. A exclusão de um armazenamento de chaves externo não afeta o proxy do armazenamento de chaves externo associado, o gerenciador de chaves externo ou as chaves externas.

NOTE: antes de excluir um armazenamento de chaves personalizado, você deve agendar a exclusão de todas KMS as chaves no armazenamento de chaves personalizadas e esperar que essas KMS chaves sejam excluídas. Em seguida, você deve desconectar o armazenamento de chaves personalizadas. Para obter ajuda para encontrar as KMS chaves em seu armazenamento de chaves personalizado, consulte Excluir um armazenamento de HSM chaves na AWS nuvem (API) no Guia do desenvolvedor do AWS Key Management Service.

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

Esse comando não retorna nenhuma saída. Para verificar se o armazenamento de chaves personalizadas foi excluído, use o describe-custom-key-stores comando.

Para obter informações sobre como excluir um AWS armazenamento de HSM chaves do Cloud, consulte Excluindo um armazenamento de HSM chaves do AWS Cloud no Guia do desenvolvedor do AWS Key Management Service.

Para obter informações sobre como excluir armazenamentos de chaves externos, consulte Excluindo um armazenamento de chaves externo no Guia do desenvolvedor do AWS Key Management Service.

Para excluir material de chave importado de uma KMS chave

O delete-imported-key-material exemplo a seguir exclui o material de chave que foi importado para uma KMS chave.

aws kms delete-imported-key-material \
   --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Este comando não produz saída. Para verificar se o material da chave foi excluído, use o describe-key comando para procurar um estado de chave de PendingImport ouPendingDeletion.

Para obter mais informações, consulte Excluindo o material da chave importada< https://docs.aws.amazon.com/kms/ latest/developerguide/importing - keys-delete-key-material .html> no Guia do desenvolvedor do AWS Key Management Service.

Para derivar um segredo compartilhado

O derive-shared-secret exemplo a seguir deriva um segredo compartilhado usando um algoritmo de acordo de chave.

Você deve usar uma curva elíptica assimétrica NIST recomendada (ECC) ou um par de chaves (somente para SM2 regiões da China) com um KMS KeyUsage valor de para chamar. KEY_AGREEMENT DeriveSharedSecret

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

Saída:

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

Para obter mais informações, consulte DeriveSharedSecretna APIReferência do Serviço de Gerenciamento de AWS Chaves.

Exemplo 1: Para obter detalhes sobre um armazenamento de HSM chaves do AWS Cloud

O describe-custom-key-store exemplo a seguir exibe detalhes sobre o armazenamento de HSM chaves do AWS Cloud especificado. O comando é o mesmo para todos os tipos de armazenamento de chaves personalizadas, mas a saída difere com o tipo de armazenamento de chaves e, para um armazenamento de chaves externo, com sua opção de conectividade.

Por padrão, esse comando exibe informações sobre todos os armazenamentos de chaves personalizadas na conta e na região. Para exibir informações sobre um determinado armazenamento de chaves personalizadas, use o custom-key-store-id parâmetro custom-key-store-name ou.

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

A saída desse comando inclui detalhes úteis sobre o armazenamento de HSM chaves do AWS Cloud, incluindo seu estado de conexão (ConnectionState). Se o estado da conexão forFAILED, a saída incluirá um ConnectionErrorCode campo que descreve o problema.

Saída:

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

Para obter mais informações, consulte Como visualizar um armazenamento de HSM chaves na AWS nuvem no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 2: Para obter detalhes sobre um armazenamento de chaves externo com conectividade de endpoint público

O describe-custom-key-store exemplo a seguir exibe detalhes sobre o armazenamento de chaves externo especificado. O comando é o mesmo para todos os tipos de armazenamento de chaves personalizadas, mas a saída difere com o tipo de armazenamento de chaves e, para um armazenamento de chaves externo, com sua opção de conectividade.

Por padrão, esse comando exibe informações sobre todos os armazenamentos de chaves personalizadas na conta e na região. Para exibir informações sobre um determinado armazenamento de chaves personalizadas, use o custom-key-store-id parâmetro custom-key-store-name ou.

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

A saída desse comando inclui detalhes úteis sobre o armazenamento externo de chaves, incluindo seu estado de conexão (ConnectionState). Se o estado da conexão forFAILED, a saída incluirá um ConnectionErrorCode campo que descreve o problema.

Saída:

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

Para obter mais informações, consulte Visualização de um armazenamento externo de chaves no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 3: Para obter detalhes sobre um armazenamento de chaves externo com conectividade de serviço de VPC endpoint

O describe-custom-key-store exemplo a seguir exibe detalhes sobre o armazenamento de chaves externo especificado. O comando é o mesmo para todos os tipos de armazenamento de chaves personalizadas, mas a saída difere com o tipo de armazenamento de chaves e, para um armazenamento de chaves externo, com sua opção de conectividade.

Por padrão, esse comando exibe informações sobre todos os armazenamentos de chaves personalizadas na conta e na região. Para exibir informações sobre um determinado armazenamento de chaves personalizadas, use o custom-key-store-id parâmetro custom-key-store-name ou.

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

A saída desse comando inclui detalhes úteis sobre o armazenamento externo de chaves, incluindo seu estado de conexão (ConnectionState). Se o estado da conexão forFAILED, a saída incluirá um ConnectionErrorCode campo que descreve o problema.

Saída:

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

Para obter mais informações, consulte Visualização de um armazenamento externo de chaves no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para encontrar informações detalhadas sobre uma KMS chave

O describe-key exemplo a seguir obtém informações detalhadas sobre a chave AWS gerenciada para o Amazon S3 na conta e região do exemplo. Você pode usar esse comando para encontrar detalhes sobre chaves AWS gerenciadas e chaves gerenciadas pelo cliente.

Para especificar a KMS chave, use o key-id parâmetro. Este exemplo usa um valor de nome de alias, mas você pode usar um ID de chave, chaveARN, nome de alias ou alias ARN nesse comando.

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

Saída:

{
    "KeyMetadata": {
        "AWSAccountId": "846764612917",
        "KeyId": "b8a9477d-836c-491f-857e-07937918959b",
        "Arn": "arn:aws:kms:us-west-2:846764612917:key/b8a9477d-836c-491f-857e-07937918959b",
        "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"
        ]
    }
}

Para obter mais informações, consulte Viewing keys no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 2: Para obter detalhes sobre uma chave RSA assimétrica KMS

O describe-key exemplo a seguir obtém informações detalhadas sobre uma RSA KMS chave assimétrica usada para assinatura e verificação.

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

Saída:

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

Exemplo 3: como obter detalhes sobre uma chave de réplica multirregional

O exemplo de describe-key a seguir os obtém metadados de uma chave de réplica multirregional. Essa chave multirregional é uma chave de criptografia simétrica. A saída de um comando describe-key para qualquer chave multirregional retorna informações sobre a chave primária e todas as suas réplicas.

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

Saída:

{
    "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",
        "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"
                }
            ]
        }
    }
}

Exemplo 4: Para obter detalhes sobre uma HMAC KMS chave

O describe-key exemplo a seguir obtém informações detalhadas sobre uma HMAC KMS chave.

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

Saída:

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

Para desativar a rotação automática de uma KMS chave

O disable-key-rotation exemplo a seguir desativa a rotação automática de uma KMS chave gerenciada pelo cliente. Para reativar a rotação automática, use o enable-key-rotation comando.

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

Este comando não produz saída. Para verificar se a rotação automática está desativada para a KMS chave, use o get-key-rotation-status comando.

Para obter mais informações, consulte Rotating keys no Guia do desenvolvedor do AWS Key Management Service.

Para desativar temporariamente uma KMS chave

O exemplo a seguir usa o disable-key comando para desativar uma KMS chave gerenciada pelo cliente. Para reativar a KMS chave, use o enable-key comando.

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

Este comando não produz saída.

Para obter mais informações, consulte Enabling and Disabling Keys no Guia do desenvolvedor do AWS Key Management Service.

Para desconectar um armazenamento de chaves personalizadas

O disconnect-custom-key-store exemplo a seguir desconecta um armazenamento de chaves personalizadas do HSM cluster AWS Cloud. Você pode desconectar um armazenamento de chaves para solucionar um problema, atualizar suas configurações ou impedir que as chaves do repositório de KMS chaves sejam usadas em operações criptográficas.

Esse comando é o mesmo para todos os armazenamentos de chaves personalizados, incluindo armazenamentos de HSM chaves AWS na nuvem e armazenamentos de chaves externos.

Antes de executar um comando como esse, substitua o ID de exemplo do armazenamento de chaves personalizado por um válido.

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

Esse comando não produz nenhuma saída. Verifique se o comando foi efetivo, use o describe-custom-key-stores comando.

Para obter mais informações sobre como desconectar um armazenamento de HSM chaves do AWS Cloud, consulte Como conectar e desconectar um armazenamento de HSM chaves do AWS Cloud no Guia do desenvolvedor do AWS Key Management Service.

Para obter mais informações sobre como desconectar um armazenamento de chaves externo, consulte Conectando e desconectando um armazenamento de chaves externo no AWS Key Management Service Developer Guide.

Para ativar a rotação automática de uma KMS chave

O enable-key-rotation exemplo a seguir permite a rotação automática de uma KMS chave gerenciada pelo cliente com um período de rotação de 180 dias. A KMS chave será rotacionada um ano (aproximadamente 365 dias) a partir da data em que esse comando for concluído e todos os anos a partir de então.

O --key-id parâmetro identifica a KMS chave. Este exemplo usa um ARN valor de chave, mas você pode usar o ID da chave ou o ARN da KMS chave. O --rotation-period-in-days parâmetro especifica o número de dias entre cada data de rotação. Especifique um valor entre 90 e 2.560 dias. Se nenhum valor for especificado, o valor padrão será de 365 dias.

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

Este comando não produz saída. Para verificar se a KMS chave está ativada, use o get-key-rotation-status comando.

Para obter mais informações, consulte Rotating keys no Guia do desenvolvedor do AWS Key Management Service.

Para habilitar uma KMS chave

O exemplo de enable-key a seguir habilita uma chave gerenciada pelo cliente. Você pode usar um comando como esse para ativar uma KMS chave que você desativou temporariamente usando o disable-key comando. Você também pode usá-lo para ativar uma KMS chave que está desativada porque foi programada para exclusão e a exclusão foi cancelada.

Para especificar a KMS chave, use o key-id parâmetro. Este exemplo usa um valor de ID de chave, mas você pode usar um ID de chave ou ARN valor de chave neste comando.

Antes de executar esse comando, substitua o ID da chave de exemplo por um ID válido.

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

Este comando não produz saída. Para verificar se a KMS chave está ativada, use o describe-key comando. Consulte os valores dos campos KeyState e Enabled na saída describe-key.

Para obter mais informações, consulte Enabling and Disabling Keys no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: como criptografar o conteúdo de um arquivo no Linux ou no macOS

O encrypt comando a seguir demonstra a forma recomendada de criptografar dados com o. AWS CLI

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

O comando realiza diversas ações:

Usa o parâmetro --plaintext para indicar os dados a serem criptografados. Esse valor de parâmetro deve ser codificado em Base64. O valor do plaintext parâmetro deve ser codificado em base64 ou você deve usar o fileb:// prefixo, que diz AWS CLI ao para ler dados binários do arquivo. Se o arquivo não estiver no diretório atual, digite o caminho completo para o arquivo. Por exemplo: fileb:///var/tmp/ExamplePlaintextFile ou fileb://C:\Temp\ExamplePlaintextFile. Para obter mais informações sobre a leitura de valores de AWS CLI parâmetros de um arquivo, consulte Carregando parâmetros de um arquivo no Guia do usuário da interface de linha de AWS comando e práticas recomendadas para parâmetros de arquivos locais no blog da ferramenta de linha de AWS comando. Usa os --query parâmetros --output e para controlar a saída do comando.Esses parâmetros extraem os dados criptografados, chamados de texto cifrado, da saída do comando.Para obter mais informações sobre como controlar a saída, consulte Controlando a saída Saída de comando no Guia do usuário da interface de linha de AWS comando. Usa o base64 utilitário para decodificar a saída extraída em dados binários.O texto cifrado retornado por um comando bem-sucedido é um texto codificado em base64. encrypt Você deve decodificar esse texto antes de poder usá-lo AWS CLI para descriptografá-lo.Salva o texto cifrado binário em um arquivo.A parte final do comando (> ExampleEncryptedFile) salva o texto cifrado binário em um arquivo para facilitar a decodificação. Para ver um exemplo de comando que usa o AWS CLI para descriptografar dados, consulte os exemplos de descriptografia.

Exemplo 2: Usando o AWS CLI para criptografar dados no Windows

Esse exemplo é igual ao exemplo anterior, mas usa a ferramenta certutil em vez do base64. Esse procedimento requer dois comandos, conforme mostrado no exemplo a seguir.

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

Exemplo 3: Criptografia com uma chave assimétrica KMS

O encrypt comando a seguir mostra como criptografar texto sem formatação com uma chave assimétrica. KMS O parâmetro --encryption-algorithm é obrigatório. Como em todos os encrypt CLI comandos, o plaintext parâmetro deve ser codificado em base64 ou você deve usar o fileb:// prefixo, que instrui o AWS CLI a ler dados binários do arquivo.

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

Este comando não produz saída.

Para gerar um par de chaves ECC NIST de dados assimétricos P384

O generate-data-key-pair-without-plaintext exemplo a seguir solicita um par de chaves ECC NIST P384 para uso fora do. AWS

O comando retorna uma chave pública em texto simples e uma cópia da chave privada criptografada sob a chave especificadaKMS. Ela não retorna uma chave privada de texto sem formatação. Você pode armazenar com segurança a chave privada criptografada com os dados criptografados e ligar AWS KMS para descriptografar a chave privada quando precisar usá-la.

Para solicitar um par de chaves de ECC NIST dados assimétricos P384, use o key-pair-spec parâmetro com um valor de. ECC_NIST_P384

A KMS chave especificada deve ser uma KMS chave de criptografia simétrica, ou seja, uma KMS chave com um KeySpec valor deSYMMETRIC_DEFAULT.

NOTE: os valores na saída deste exemplo são truncados para exibição.

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

Saída:

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

Os PublicKey e PrivateKeyCiphertextBlob são retornados no formato codificado em base64.

Para obter mais informações, consulte Pares de chaves de dados no Guia do desenvolvedor do AWS Key Management Service.

Para gerar um par de chaves de dados RSA assimétricos de 2048 bits

O generate-data-key-pair exemplo a seguir solicita um par de chaves de RSA dados assimétricos de 2048 bits para uso fora do. AWS O comando retorna uma chave pública em texto simples e uma chave privada em texto sem formatação para uso e exclusão imediatos, além de uma cópia da chave privada criptografada sob a chave especificada. KMS Você pode armazenar com segurança a chave privada criptografada com os dados criptografados.

Para solicitar um par de chaves de RSA dados assimétricos de 2048 bits, use key-pair-spec o parâmetro com um valor de. RSA_2048

A KMS chave especificada deve ser uma KMS chave de criptografia simétrica, ou seja, uma KMS chave com um KeySpec valor deSYMMETRIC_DEFAULT.

NOTE: os valores na saída deste exemplo são truncados para exibição.

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

Saída:

{
    "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",
    "KeyPairSpec": "RSA_2048"
}

Os PublicKeyPrivateKeyPlaintext, e PrivateKeyCiphertextBlob são retornados no formato codificado em base64.

Para obter mais informações, consulte Pares de chaves de dados no Guia do desenvolvedor do AWS Key Management Service.

Como gerar uma chave de dados simétrica de 256 bits sem uma chave de texto simples

O exemplo de generate-data-key-without-plaintext a seguir solicita uma cópia criptografada de uma chave de dados simétrica de 256 bits para uso externo à AWS. Você pode ligar AWS KMS para descriptografar a chave de dados quando estiver pronto para usá-la.

Use o parâmetro key-spec com um valor de AES_256 para solicitar uma chave de dados de 256 bits. Use o parâmetro key-spec com um valor de AES_128 para solicitar uma chave de dados de 128 bits. Para todos os outros comprimentos de chave de dados, use o parâmetro number-of-bytes.

A KMS chave especificada deve ser uma chave de criptografia KMS simétrica, ou seja, uma KMS chave com um valor de especificação de chave de 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

Saída:

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

A CiphertextBlob (chave de dados criptografada) é retornada em um formato codificado em base64.

Para obter mais informações, consulte Data keys no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: como gerar uma chave de dados simétrica de 256 bits

O generate-data-key exemplo a seguir solicita uma chave de dados simétrica de 256 bits para uso fora do. AWS O comando retorna uma chave de dados em texto simples para uso e exclusão imediatos e uma cópia dessa chave de dados criptografada sob a chave especificada. KMS A chave de dados criptografada pode ser armazenada com segurança junto com os dados criptografados.

Use o parâmetro key-spec com um valor de AES_256 para solicitar uma chave de dados de 256 bits. Use o parâmetro key-spec com um valor de AES_128 para solicitar uma chave de dados de 128 bits. Para todos os outros comprimentos de chave de dados, use o parâmetro number-of-bytes.

A KMS chave especificada deve ser uma chave de criptografia KMS simétrica, ou seja, uma KMS chave com um valor de especificação de chave de SYMMETRIC _. DEFAULT

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

Saída:

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

A Plaintext (chave de dados em texto simples) e a CiphertextBlob (chave de dados criptografada) são retornadas no formato codificado em base64.

Para obter mais informações, consulte Teclas de dados < https://docs.aws.amazon.com/kms/ latest/developerguide/concepts .html #data -keys no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 2: como gerar uma chave de dados simétrica de 512 bits

O exemplo de generate-data-key a seguir solicita uma chave de dados simétrica de 512 bits para criptografia e descriptografia. O comando retorna uma chave de dados em texto simples para uso e exclusão imediatos e uma cópia dessa chave de dados criptografada sob a chave especificada. KMS A chave de dados criptografada pode ser armazenada com segurança junto com os dados criptografados.

Use o parâmetro number-of-bytes para solicitar um comprimento de chave diferente de 128 ou 256 bits. Para solicitar uma chave de dados de 512 bits, o exemplo a seguir usa o parâmetro number-of-bytes com um valor de 64 (bytes).

A KMS chave especificada deve ser uma chave de criptografia KMS simétrica, ou seja, uma KMS chave com um valor de especificação de chave de SYMMETRIC _. DEFAULT

NOTE: os valores na saída deste exemplo são truncados para exibição.

aws kms generate-data-key \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --number-of-bytes 64

Saída:

{
    "CiphertextBlob": "AQIBAHi6LtupRpdKl2aJTzkK6FbhOtQkMlQJJH3PdtHvS/y+hAEnX/QQNmMwDfg2korNMEc8AAACaDCCAmQGCSqGSIb3DQEHBqCCAlUwggJRAgEAMIICSgYJKoZ...",
    "Plaintext": "ty8Lr0Bk6OF07M2BWt6qbFdNB+G00ZLtf5MSEb4al3R2UKWGOp06njAwy2n72VRm2m7z/Pm9Wpbvttz6a4lSo9hgPvKhZ5y6RTm4OovEXiVfBveyX3DQxDzRSwbKDPk/...",
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}

Plaintext (chave de dados em texto simples) e CiphertextBlob (chave de dados criptografada) são retornadas no formato codificado em base64.

Para obter mais informações, consulte Teclas de dados < https://docs.aws.amazon.com/kms/ latest/developerguide/concepts .html #data -keys no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para gerar uma string de bytes aleatória de 256 bits (Linux ou) macOs

O exemplo de generate-random a seguir gera uma string de bytes aleatórios de 256 bits (32 bytes) codificada em base64. O exemplo decodifica a string de bytes e a salva no arquivo aleatório.

Ao executar esse comando, use o parâmetro number-of-bytes para especificar o tamanho do valor aleatório em bytes.

Você não especifica uma KMS chave ao executar esse comando. A sequência de bytes aleatória não está relacionada a nenhuma KMS chave.

Por padrão, AWS KMS gera o número aleatório. No entanto, se você especificar um armazenamento de chaves personalizadas< https://docs.aws.amazon.com/kms/ latest/developerguide/custom - key-store-overview .html>, a string de bytes aleatória será gerada no HSM cluster do AWS Cloud associado ao armazenamento de chaves personalizadas.

Este exemplo usa os seguintes parâmetros e valores:

Ele usa o --number-of-bytes parâmetro necessário com um valor de 32 para solicitar uma string de 32 bytes (256 bits). Ele usa o --output parâmetro com um valor de text para direcionar o para retornar a saída como texto, em vez de JSON .Ele usa o AWS CLI para extrair o valor da Plaintext propriedade da resposta.Ele canaliza (|) a saída do comando --query parameter para o base64 utilitário, que decodifica a saída extraída. Ele usa o operador de redirecionamento (>) para salvar a decodificação string de bytes para o arquivo. Ele usa o ExampleRandom operador de redirecionamento (>) para salvar o texto cifrado binário em um arquivo.

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

Este comando não produz saída.

Para obter mais informações, consulte GenerateRandomna APIReferência do Serviço de Gerenciamento de AWS Chaves.

Exemplo 2: como gerar um número aleatório de 256 bits (prompt de comando do Windows)

O exemplo a seguir usa o comando generate-random para gerar uma string aleatória de 256 bits (32 bytes) codificada em base64. O exemplo decodifica a string de bytes e a salva no arquivo aleatório. Esse exemplo é igual ao exemplo anterior, mas usa o utilitário certutil no Windows para decodificar em base64 a string de bytes aleatória antes de salvá-la em um arquivo.

Primeiro, gere uma string de bytes aleatória codificada em base64 e salve-a em um arquivo temporário (ExampleRandom.base64).

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

Como a saída do comando generate-random é salva em um arquivo, esse exemplo não produz nenhuma saída.

Use o comando certutil -decode para decodificar a string de bytes codificada em base64 no arquivo ExampleRandom.base64. Em seguida, ele salva a string de bytes decodificada no arquivo ExampleRandom.

certutil -decode ExampleRandom.base64 ExampleRandom

Saída:

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

Para obter mais informações, consulte GenerateRandomna APIReferência do Serviço de Gerenciamento de AWS Chaves.

Para copiar uma política de chaves de uma KMS chave para outra KMS

O get-key-policy exemplo a seguir obtém a política de chaves de uma KMS chave e a salva em um arquivo de texto. Em seguida, ele substitui a política de uma KMS chave diferente usando o arquivo de texto como entrada da política.

Como o --policy parâmetro de put-key-policy requer uma string, você deve usar a --output text opção de retornar a saída como uma string de texto em vez deJSON.

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

Este comando não produz saída.

Para obter mais informações, consulte PutKeyPolicyna AWS KMSAPIReferência.

Para recuperar o status de rotação de uma KMS chave.

O get-key-rotation-status exemplo a seguir retorna informações sobre o status de rotação da KMS chave especificada, incluindo se a rotação automática está ativada, o período de rotação e a próxima data de rotação programada. Você pode usar esse comando em KMS chaves gerenciadas pelo cliente e KMS chaves AWS gerenciadas. No entanto, todas as KMS chaves AWS gerenciadas são alternadas automaticamente a cada ano.

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

Saída:

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

Para obter mais informações, consulte Rotating keys no Guia do desenvolvedor do AWS Key Management Service.

Para obter os itens necessários para importar o material chave em uma KMS chave

O get-parameters-for-import exemplo a seguir obtém a chave pública e o token de importação necessários para importar o material da chave em uma KMS chave. Ao usar o import-key-material comando, certifique-se de usar o token de importação e o material da chave criptografados pela chave pública que foram retornados no mesmo get-parameters-for-import comando. Além disso, o algoritmo de encapsulamento especificado nesse comando deve ser usado para criptografar o material da chave com a chave pública.

Para especificar a KMS chave, use o key-id parâmetro. Este exemplo usa um ID de chave, mas você pode usar um ID de chave ou chave ARN neste comando.

aws kms get-parameters-for-import \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --wrapping-algorithm RSAES_OAEP_SHA_256 \
    --wrapping-key-spec RSA_2048

Saída:

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

Para obter mais informações, consulte Baixar a chave pública e importar o token no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para baixar a chave pública de uma chave assimétrica KMS

O get-public-key exemplo a seguir baixa a chave pública de uma chave assimétricaKMS.

Além de retornar a chave pública, a saída inclui informações das quais você precisa usar a chave pública com segurança fora dela AWS KMS, incluindo o uso da chave e os algoritmos de criptografia compatíveis.

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

Saída:

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

Para obter mais informações sobre o uso de KMS chaves assimétricas em AWS KMS, consulte Usando chaves simétricas e assimétricas na Referência do AWS Key Management Service. API

Exemplo 2: Para converter uma chave pública em DER formato (Linux e macOS)

O get-public-key exemplo a seguir baixa a chave pública de uma KMS chave assimétrica e a salva em um DER arquivo.

Quando você usa o get-public-key comando no AWS CLI, ele retorna uma chave pública X.509 DER codificada em -que é codificada em Base64. Este exemplo obtém o valor da PublicKey propriedade como texto. Ele decodifica em Base64 PublicKey e o salva no arquivo. public_key.der O output parâmetro retorna a saída como texto, em vez deJSON. O --query parâmetro obtém somente a PublicKey propriedade, não as propriedades das quais você precisa usar a chave pública com segurança fora dela AWS KMS.

Antes de executar esse comando, substitua o ID de chave de exemplo por um ID de chave válido da sua AWS conta.

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

Este comando não produz saída.

Para obter mais informações sobre o uso de KMS chaves assimétricas em AWS KMS, consulte Usando chaves simétricas e assimétricas na Referência do AWS Key Management Service. API

Para importar material chave em uma KMS chave

O import-key-material exemplo a seguir carrega material de chave em uma KMS chave que foi criada sem material de chave. O estado chave da KMS chave deve serPendingImport.

Esse comando usa material de chave que você criptografou com a chave pública que o get-parameters-for-import comando retornou. Ele também usa o token de importação do mesmo get-parameters-for-import comando.

O expiration-model parâmetro indica que o material chave expira automaticamente na data e hora especificadas pelo valid-to parâmetro. Quando o material da chave expira, o material da chave é AWS KMS excluído, o estado da chave muda para Pending import e a KMS KMS chave fica inutilizável. Para restaurar a KMS chave, você deve reimportar o mesmo material de chave. Para usar um material de chave diferente, você deve criar uma nova KMS chave.

Antes de executar esse comando, substitua o ID da chave de exemplo por um ID de chave válido ou por uma chave ARN da sua AWS conta.

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

Este comando não produz saída.

Para obter mais informações sobre a importação de material de chaves, consulte Importando material de chaves no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para listar todos os aliases em uma AWS conta e região

O exemplo a seguir usa o list-aliases comando para listar todos os aliases na região padrão da AWS conta. A saída inclui aliases associados às KMS chaves AWS gerenciadas e às KMS chaves gerenciadas pelo cliente.

aws kms list-aliases

Saída:

{
    "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"
        },
        ...
    ]
}

Exemplo 2: Para listar todos os aliases de uma chave específica KMS

O exemplo a seguir usa o list-aliases comando e seu key-id parâmetro para listar todos os aliases associados a uma KMS chave específica.

Cada alias está associado a apenas uma KMS chave, mas uma KMS chave pode ter vários aliases. Esse comando é muito útil porque o AWS KMS console lista somente um alias para cada KMS chave. Para encontrar todos os aliases de uma KMS chave, você deve usar o list-aliases comando.

Este exemplo usa o ID da KMS chave para o --key-id parâmetro, mas você pode usar um ID de chave, chaveARN, nome de alias ou alias ARN nesse comando.

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

Saída:

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

Para obter mais informações, consulte Working with aliases no Guia do desenvolvedor do AWS Key Management Service.

Para ver as concessões em uma AWS KMS chave

O list-grants exemplo a seguir exibe todas as concessões na KMS chave AWS gerenciada especificada para o Amazon DynamoDB em sua conta. Essa concessão permite que o DynamoDB use KMS a chave em seu nome para criptografar uma tabela do DynamoDB antes de gravá-la no disco. Você pode usar um comando como esse para visualizar as concessões nas KMS chaves AWS gerenciadas e nas KMS chaves gerenciadas pelo cliente na AWS conta e na região.

Esse comando usa o key-id parâmetro com um ID de chave para identificar a KMS chave. Você pode usar um ID de chave ou chave ARN para identificar a KMS chave. Para obter o ID da chave ou a chave ARN de uma KMS chave AWS gerenciada, use o list-aliases comando list-keys ou.

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

O resultado mostra que a concessão dá ao Amazon DynamoDB permissão para usar KMS a chave para operações criptográficas, além de permitir que ele visualize detalhes sobre a chave DescribeKey () e KMS retire as concessões (). RetireGrant A restrição EncryptionContextSubset limita a permissão às solicitações que incluem os pares de contexto de criptografia especificados. Como resultado, as permissões na concessão são efetivas somente na conta especificada e na tabela do 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"
        }
    ]
}

Para obter mais informações, consulte Concessões AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Para obter os nomes das principais políticas de uma KMS chave

O exemplo de list-key-policies a seguir obtém os nomes das políticas de chave de uma chave gerenciada pelo cliente na conta e região de exemplo. Você pode usar esse comando para encontrar os nomes das políticas de chaves para chaves AWS gerenciadas e chaves gerenciadas pelo cliente.

Como o único nome de política de chave válido é default, esse comando não é muito útil.

Para especificar a KMS chave, use o key-id parâmetro. Este exemplo usa um valor de ID de chave, mas você pode usar um ID de chave ou chave ARN neste comando.

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

Saída:

{
    "PolicyNames": [
    "default"
    ]
}

Para obter mais informações sobre políticas AWS KMS principais, consulte Usando políticas de chaves AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Para recuperar informações sobre todas as rotações de materiais principais concluídas

O list-key-rotations exemplo a seguir lista informações sobre todas as rotações de material-chave concluídas para a KMS chave especificada.

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

Saída:

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

Para obter mais informações, consulte Rotating keys no Guia do desenvolvedor do AWS Key Management Service.

Para obter as KMS chaves em uma conta e região

O list-keys exemplo a seguir obtém as KMS chaves em uma conta e região. Esse comando retorna as chaves AWS gerenciadas e as chaves gerenciadas pelo cliente.

aws kms list-keys

Saída:

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

Para obter mais informações, consulte Viewing Keys no Guia do desenvolvedor do AWS Key Management Service.

Para obter as etiquetas em uma KMS chave

O list-resource-tags exemplo a seguir obtém as tags de uma KMS chave. Para adicionar ou substituir tags de recursos nas KMS teclas, use o tag-resource comando. A saída mostra que essa KMS chave tem duas tags de recursos, cada uma com uma chave e um valor.

Para especificar a KMS chave, use o key-id parâmetro. Este exemplo usa um valor de ID de chave, mas você pode usar um ID de chave ou chave ARN neste comando.

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

Saída:

{
    "Tags": [
    {
        "TagKey": "Dept",
        "TagValue": "IT"
    },
    {
        "TagKey": "Purpose",
        "TagValue": "Test"
    }
    ],
    "Truncated": false
}

Para obter mais informações sobre o uso de tags em AWS KMS, consulte Como marcar chaves no Guia do desenvolvedor do AWS Key Management Service.

Para ver os subsídios que um diretor pode se aposentar

O list-retirable-grants exemplo a seguir mostra todas as concessões que o ExampleAdmin usuário pode retirar com as KMS chaves em uma AWS conta e região. Você pode usar um comando como este para ver as concessões que qualquer diretor de conta pode retirar com KMS chaves na AWS conta e na região.

O valor do retiring-principal parâmetro necessário deve ser o Amazon Resource Name (ARN) de uma conta, usuário ou função.

Você não pode especificar um serviço para o valor de retiring-principal neste comando, mesmo que um serviço possa ser o principal que está se aposentando. Para encontrar as concessões nas quais um determinado serviço é o diretor que está se aposentando, use o list-grants comando.

O resultado mostra que o ExampleAdmin usuário tem permissão para retirar subsídios em duas KMS chaves diferentes na conta e na região. Além do principal que se aposenta, a conta tem permissão para retirar qualquer subsídio na conta.

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

Saída:

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

Para obter mais informações, consulte Concessões AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Para alterar a política de chaves para uma KMS chave

O exemplo de put-key-policy a seguir altera a política de chave de uma chave gerenciada pelo cliente.

Para começar, crie uma política de chaves e salve-a em um JSON arquivo local. Neste exemplo, o arquivo é key_policy.json. Você também pode especificar a política de chave como o valor da string do parâmetro policy.

A primeira declaração nessa política de chaves dá permissão à AWS conta para usar IAM políticas para controlar o acesso à KMS chave. A segunda instrução dá permissão ao test-user usuário para executar os list-keys comandos describe-key e na KMS tecla.

Conteúdo 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" : "*"
        }
    ]
}

Para identificar a KMS chave, este exemplo usa o ID da chave, mas você também pode usar uma chaveARN. O comando usa o parâmetro policy para especificar a política de chave. Para indicar que a política está em um arquivo, ela usa o prefixo file:// necessário. Esse prefixo é necessário para identificar arquivos em todos os sistemas operacionais compatíveis. Por fim, o comando usa o parâmetro policy-name com um valor default. Se não houver nenhum nome de política especificado, o valor padrão será default. O único valor válido é default.

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

Esse comando não produz nenhuma saída. Use o comando get-key-policy para verificar se o comando está em vigor. O comando de exemplo a seguir obtém a política de chaves para a mesma KMS chave. O parâmetro output com o valor text retorna um formato de texto fácil de ler.

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

Saída:

{
    "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" : "*"
        }
    ]
}

Para obter mais informações, consulte Changing a Key Policy no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para recriptografar uma mensagem criptografada com uma KMS chave simétrica diferente (Linux e macOS).

O exemplo de re-encrypt comando a seguir demonstra a forma recomendada de recriptografar dados com o. AWS CLI

Forneça o texto cifrado em um arquivo. No valor do --ciphertext-blob parâmetro, use o fileb:// prefixo, que instrui o CLI a ler os dados de um arquivo binário. Se o arquivo não estiver no diretório atual, digite o caminho completo para o arquivo. Para obter mais informações sobre a leitura de valores de AWS CLI parâmetros de um arquivo, consulte Carregando AWS CLI parâmetros de um arquivo < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> no Guia do usuário da interface de linha de AWS comando e práticas recomendadas para parâmetros de arquivos locais< https://aws.amazon.com/blogs/ developer/ best-practices-for-local -file-parameters/> no blog da ferramenta de linha de AWS comando .Especifique a chave de origemKMS, que descriptografa o texto cifrado.O parâmetro não é necessário ao descriptografar com criptografia simétrica --source-key-id KMSchaves. AWS KMSpode obter a KMS chave usada para criptografar os dados dos metadados no blob de texto cifrado. Mas é sempre uma boa prática especificar a KMS chave que você está usando. Essa prática garante que você use a KMS chave desejada e evita que você decodifique inadvertidamente um texto cifrado usando uma KMS chave na qual você não confia.Especifique a chave de destinoKMS, que criptografa novamente os dados.O parâmetro é sempre obrigatório. --destination-key-id Este exemplo usa uma chaveARN, mas você pode usar qualquer identificador de chave válido.Solicite a saída de texto sem formatação como um valor de texto.O --query parâmetro diz CLI ao para obter somente o valor do campo da saída. Plaintext O parâmetro --output retorna a saída como texto. Decodifique o texto simples em Base64 e salve-o em um arquivo. O seguinte exemplo canaliza ( | ) o valor do parâmetro Plaintext para o utilitário Base64, que o decodifica. Em seguida, ele redireciona ( > ) a saída decodificada para o arquivo ExamplePlaintext.

Antes de executar esse comando, substitua a chave IDs de exemplo por identificadores de chave válidos da sua AWS conta.

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

Este comando não produz saída. A saída do comando re-encrypt é decodificada em base64 e salva em um arquivo.

Para obter mais informações, consulte ReEncrypt < https://docs.aws.amazon.com/kms/ latest/APIReference/API _ ReEncrypt .html na APIReferência do Serviço de Gerenciamento de AWS Chaves.

Exemplo 2: Para recriptografar uma mensagem criptografada com uma KMS chave simétrica diferente (prompt de comando do Windows).

O exemplo de comando re-encrypt a seguir é o mesmo que o anterior, mas ele usa o utilitário certutil para decodificar em Base64 os dados em texto simples. Esse procedimento requer dois comandos, conforme mostrado nos exemplos a seguir.

Antes de executar esse comando, substitua o ID de chave de exemplo por um ID de chave válido da sua AWS conta.

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

Em seguida, use o utilitário certutil.

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Saída:

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

Para obter mais informações, consulte ReEncrypt < https://docs.aws.amazon.com/kms/ latest/APIReference/API _ ReEncrypt .html na APIReferência do Serviço de Gerenciamento de AWS Chaves.

Como descontinuar uma concessão em uma chave mestra do cliente

O retire-grant exemplo a seguir exclui uma concessão de uma KMS chave.

O comando de exemplo a seguir especifica os parâmetros grant-id e key-id. O valor do key-id parâmetro deve ser a chave ARN da KMS chave.

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

Este comando não produz saída. Use o comando list-grants para confirmar a descontinuação da concessão.

Para obter mais informações, consulte Retiring and revoking grants no Guia do desenvolvedor do AWS Key Management Service.

Como revogar uma concessão em uma chave mestra do cliente

O revoke-grant exemplo a seguir exclui uma concessão de uma KMS chave. O comando de exemplo a seguir especifica os parâmetros grant-id e key-id. O valor do key-id parâmetro pode ser o ID da chave ou a chave ARN da KMS chave.

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

Este comando não produz saída. Use o comando list-grants para confirmar que a concessão foi revogada.

Para obter mais informações, consulte Retiring and revoking grants no Guia do desenvolvedor do AWS Key Management Service.

Para realizar a rotação sob demanda de uma chave KMS

O rotate-key-on-demand exemplo a seguir inicia imediatamente a rotação do material da chave para a KMS chave especificada.

aws kms rotate-key-on-demand \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Saída:

{
    "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab"
}

Para obter mais informações, consulte Como realizar a rotação de chaves sob demanda no Guia do desenvolvedor do AWS Key Management Service.

Para agendar a exclusão de uma KMS chave gerenciada pelo cliente.

O schedule-key-deletion exemplo a seguir agenda a KMS chave gerenciada pelo cliente especificada para ser excluída em 15 dias.

O --key-id parâmetro identifica a KMS chave. Este exemplo usa um ARN valor de chave, mas você pode usar o ID da chave ou o ARN da KMS chave. O --pending-window-in-days parâmetro especifica a duração do período de espera de 7 a 30 dias. Por padrão, o período de espera é de 30 dias. Este exemplo especifica um valor de 15, que indica AWS a exclusão permanente da KMS chave 15 dias após a conclusão do comando.

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

A resposta inclui a chaveARN, o estado da chave, o período de espera (PendingWindowInDays) e a data de exclusão no horário Unix. Para ver a data de exclusão no horário local, use o AWS KMS console. KMSchaves no estado PendingDeletion chave não podem ser usadas em operações criptográficas.

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

Para obter mais informações, consulte Deleting keys no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: gerar uma assinatura digital para uma mensagem

O exemplo de sign a seguir gera uma assinatura criptográfica para uma mensagem curta. A saída do comando inclui um campo Signature codificado em base64 que você pode verificar usando o comando verify.

Você deve especificar uma mensagem para assinar e um algoritmo de assinatura compatível com sua KMS chave assimétrica. Para obter os algoritmos de assinatura da sua KMS chave, use o describe-key comando.

Na AWS CLI versão 2.0, o valor do message parâmetro deve ser codificado em Base64. Ou você pode salvar a mensagem em um arquivo e usar o fileb:// prefixo, que instrui o usuário AWS CLI a ler os dados binários do arquivo.

Antes de executar esse comando, substitua o ID de chave de exemplo por um ID de chave válido da sua AWS conta. O ID da chave deve representar uma KMS chave assimétrica com um uso de chave 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

Saída:

{
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "Signature": "ABCDEFhpyVYyTxbafE74ccSvEJLJr3zuoV1Hfymz4qv+/fxmxNLA7SE1SiF8lHw80fKZZ3bJ...",
    "SigningAlgorithm": "RSASSA_PKCS1_V1_5_SHA_256"
}

Para obter mais informações sobre o uso de KMS chaves assimétricas em AWS KMS, consulte Chaves assimétricas AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 2: Para salvar uma assinatura digital em um arquivo (Linux emacOs)

O exemplo de sign a seguir gera uma assinatura criptográfica para uma mensagem curta armazenada em um arquivo local. O comando também obtém a Signature propriedade da resposta, decodifica em Base64 e a salva no arquivo. ExampleSignature Você pode usar o arquivo de assinatura em um comando verify que verifica a assinatura.

O sign comando requer uma mensagem codificada em Base64 e um algoritmo de assinatura compatível com sua chave assimétrica. KMS Para obter os algoritmos de assinatura compatíveis com sua KMS chave, use o describe-key comando.

Antes de executar esse comando, substitua o ID de chave de exemplo por um ID de chave válido da sua AWS conta. O ID da chave deve representar uma KMS chave assimétrica com um uso de chave 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

Este comando não produz saída. Este exemplo extrai a propriedade Signature da saída e a salva em um arquivo.

Para obter mais informações sobre o uso de KMS chaves assimétricas em AWS KMS, consulte Chaves assimétricas AWS KMS no Guia do desenvolvedor do AWS Key Management Service.

Para adicionar uma tag a uma KMS chave

O tag-resource exemplo a seguir adiciona "Purpose":"Test" e "Dept":"IT" marca uma KMS chave gerenciada pelo cliente. Você pode usar tags como essas para rotular KMS chaves e criar categorias de KMS chaves para permissões e auditoria.

Para especificar a KMS chave, use o key-id parâmetro. Este exemplo usa um valor de ID de chave, mas você pode usar um ID de chave ou chave ARN neste comando.

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

Este comando não produz saída. Para ver as tags em uma AWS KMS KMS chave, use o list-resource-tags comando.

Para obter mais informações sobre o uso de tags em AWS KMS, consulte Como marcar chaves no Guia do desenvolvedor do AWS Key Management Service.

Para excluir uma tag de uma KMS chave

O untag-resource exemplo a seguir exclui a tag com a "Purpose" chave de uma KMS chave gerenciada pelo cliente.

Para especificar a KMS chave, use o key-id parâmetro. Este exemplo usa um valor de ID de chave, mas você pode usar um ID de chave ou chave ARN neste comando. Antes de executar esse comando, substitua o ID de chave de exemplo por um ID de chave válido da sua AWS conta.

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

Este comando não produz saída. Para ver as tags em uma AWS KMS KMS chave, use o list-resource-tags comando.

Para obter mais informações sobre o uso de tags em AWS KMS, consulte Como marcar chaves no Guia do desenvolvedor do AWS Key Management Service.

Para associar um alias a uma chave diferente KMS

O update-alias exemplo a seguir associa o alias alias/test-key a uma chave diferenteKMS.

O parâmetro --alias-name especifica o alias. O valor do nome do alias deve começar com alias/ .O --target-key-id parâmetro especifica a KMS chave a ser associada ao alias. Você não precisa especificar a KMS chave atual para o alias.

aws kms update-alias \
    --alias-name alias/test-key \
    --target-key-id 1234abcd-12ab-34cd-56ef-1234567890ab

Este comando não produz saída. Use o list-aliases comando para localizar o alias.

Para obter mais informações, consulte Updating aliases no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para editar o nome amigável de um armazenamento de chaves personalizado

O update-custom-key-store exemplo a seguir altera o nome do armazenamento de chaves personalizadas. Este exemplo funciona para um armazenamento de HSM chaves do AWS Cloud ou um armazenamento de chaves externo.

Use o custom-key-store-id para identificar o armazenamento de chaves. Use o new-custom-key-store-name parâmetro para especificar o novo nome amigável.

Para atualizar o nome amigável de um armazenamento de HSM chaves do AWS Cloud, você deve primeiro desconectar o armazenamento de chaves, por exemplo, usando o disconnect-custom-key-store comando. Você pode atualizar o nome amigável de um armazenamento de chaves externo enquanto ele estiver conectado ou desconectado. Para encontrar o estado da conexão do seu armazenamento de chaves personalizadas, use o describe-custom-key-store comando.

aws kms update-custom-key-store \
    --custom-key-store-id cks-1234567890abcdef0 \
    --new-custom-key-store-name ExampleKeyStore

Esse comando não retorna nenhum dado. Para verificar se o comando funcionou, use um describe-custom-key-stores comando.

Para obter mais informações sobre a atualização de um armazenamento de HSM chaves do AWS Cloud, consulte Editando as configurações do armazenamento de HSM chaves do AWS Cloud no Guia do desenvolvedor do AWS Key Management Service.

Para obter mais informações sobre a atualização de um armazenamento de chaves externo, consulte Edição das propriedades do armazenamento de chaves externo no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 2: para editar a senha kmsuser de um AWS armazenamento de chaves do Cloud HSM

O update-custom-key-store exemplo a seguir atualiza o valor da kmsuser senha para a senha atual do HSM cluster kmsuser in the Cloud associado ao armazenamento de chaves especificado. Esse comando não altera a kmsuser senha do cluster. Ele apenas informa AWS KMS a senha atual. Se KMS não tiver a kmsuser senha atual, não poderá se conectar ao armazenamento de HSM chaves do AWS Cloud.

NOTE: antes de atualizar um armazenamento de HSM chaves do AWS Cloud, você deve desconectá-lo. Use o comando disconnect-custom-key-store. Depois que o comando for concluído, você poderá reconectar o AWS armazenamento de HSM chaves do Cloud. Use o comando connect-custom-key-store.

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

Esse comando não retorna nenhuma saída. Para verificar se a alteração foi efetiva, use um describe-custom-key-stores comando.

Para obter mais informações sobre a atualização de um armazenamento de HSM chaves do AWS Cloud, consulte Editando as configurações do armazenamento de HSM chaves do AWS Cloud no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 3: Para editar o HSM cluster de AWS nuvem de um armazenamento de HSM chaves do AWS Cloud

O exemplo a seguir altera o HSM cluster do AWS Cloud associado a um armazenamento de HSM chaves do AWS Cloud para um cluster relacionado, como um backup diferente do mesmo cluster.

NOTE: antes de atualizar um armazenamento de HSM chaves do AWS Cloud, você deve desconectá-lo. Use o comando disconnect-custom-key-store. Depois que o comando for concluído, você poderá reconectar o AWS armazenamento de HSM chaves do Cloud. Use o comando connect-custom-key-store.

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

Esse comando não retorna nenhuma saída. Para verificar se a alteração foi efetiva, use um describe-custom-key-stores comando.

Para obter mais informações sobre a atualização de um armazenamento de HSM chaves do AWS Cloud, consulte Editando as configurações do armazenamento de HSM chaves do AWS Cloud no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 4: Para editar a credencial de autenticação de proxy de um armazenamento de chaves externo

O exemplo a seguir atualiza a credencial de autenticação de proxy para seu armazenamento de chaves externo. Você deve especificar o raw-secret-access-key e oaccess-key-id, mesmo se estiver alterando somente um dos valores. Você pode usar esse recurso para corrigir uma credencial inválida ou para alterar a credencial quando o proxy externo do armazenamento de chaves a gira.

Estabeleça a credencial de autenticação de proxy AWS KMS em seu armazenamento de chaves externo. Em seguida, use esse comando para fornecer a credencial a. AWS KMS AWS KMSusa essa credencial para assinar suas solicitações no proxy externo do armazenamento de chaves.

Você pode atualizar a credencial de autenticação do proxy enquanto o armazenamento de chaves externo estiver conectado ou desconectado. Para encontrar o estado da conexão do seu armazenamento de chaves personalizadas, use o describe-custom-key-store comando.

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

Esse comando não retorna nenhuma saída. Para verificar se a alteração foi efetiva, use um describe-custom-key-stores comando.

Para obter mais informações sobre a atualização de um armazenamento de chaves externo, consulte Edição das propriedades do armazenamento de chaves externo no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 5: Para editar a conectividade proxy de um armazenamento de chaves externo

O exemplo a seguir altera a opção de conectividade proxy do armazenamento de chaves externo de conectividade de endpoint público para conectividade de serviço de VPC endpoint. Além de alterar o xks-proxy-connectivity valor, você deve alterar o xks-proxy-uri-endpoint valor para refletir o DNS nome privado associado ao serviço de VPC endpoint. Você também deve agregar um xks-proxy-vpc-endpoint-service-name valor.

NOTE: antes de atualizar a conectividade proxy de uma loja externa, você deve desconectá-la. Use o comando disconnect-custom-key-store. Depois que o comando for concluído, você poderá reconectar o armazenamento de chaves externo usando o connect-custom-key-store comando.

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"

Esse comando não retorna nenhuma saída. Para verificar se a alteração foi efetiva, use um describe-custom-key-stores comando.

Para obter mais informações sobre a atualização de um armazenamento de chaves externo, consulte Edição das propriedades do armazenamento de chaves externo no Guia do desenvolvedor do AWS Key Management Service.

Exemplo 1: Para adicionar ou alterar uma descrição em uma KMS chave gerenciada pelo cliente

O update-key-description exemplo a seguir adiciona uma descrição a uma KMS chave gerenciada pelo cliente. Você pode usar o mesmo comando para alterar uma descrição existente.

O --key-id parâmetro identifica a KMS chave no comando. Este exemplo usa um ARN valor de chave, mas você pode usar o ID da chave ou a chave ARN da KMS chave. O --description parâmetro especifica a nova descrição. O valor desse parâmetro substitui a descrição atual da KMS chave, se houver.

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"

Este comando não produz saída. Para ver a descrição de uma KMS chave, use o describe-key comando.

Para obter mais informações, consulte UpdateKeyDescriptionna APIReferência do Serviço de Gerenciamento de AWS Chaves.

Exemplo 2: Para excluir a descrição de uma KMS chave gerenciada pelo cliente

O update-key-description exemplo a seguir exclui a descrição de uma KMS chave gerenciada pelo cliente.

O --key-id parâmetro identifica a KMS chave no comando. Este exemplo usa um valor de ID de chave, mas você pode usar o ID da chave ou a chave ARN da KMS chave. O --description parâmetro com um valor de cadeia de caracteres vazio (“) exclui a descrição existente.

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

Este comando não produz saída. Para ver a descrição de uma KMS chave, use o comando describe-key.

Para obter mais informações, consulte UpdateKeyDescriptionna APIReferência do Serviço de Gerenciamento de AWS Chaves.

Para verificar uma assinatura digital

O exemplo de verify a seguir verifica uma assinatura criptográfica para uma mensagem curta codificada em base64. O ID da chave, a mensagem, o tipo de mensagem e o algoritmo de assinatura devem ser os mesmos usados para assinar a mensagem. A assinatura que você especifica não pode ter codificação base64. Para obter ajuda na decodificação da assinatura retornada pelo comando sign, consulte os exemplos do comando sign.

A saída do comando inclui um campo SignatureValid booliano que indica que a assinatura foi verificada. Se a validação da assinatura falhar, o comando verify também falhará.

Antes de executar esse comando, substitua o ID de chave de exemplo por um ID de chave válido da sua AWS conta.

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

Saída:

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

Para obter mais informações sobre o uso de KMS chaves assimétricas em AWS KMS, consulte Usando chaves assimétricas no AWS Key Management Service Developer Guide.