AWS KMS esempi che utilizzano AWS CLI

Per annullare l'eliminazione pianificata di una chiave KMS gestita dal cliente

L'cancel-key-deletionesempio seguente annulla l'eliminazione pianificata di una chiave KMS gestita dal cliente.

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

Output:

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

Quando il cancel-key-deletion comando ha esito positivo, l'eliminazione pianificata viene annullata. Tuttavia, lo stato della chiave KMS èDisabled, quindi non è possibile utilizzare la chiave KMS nelle operazioni crittografiche. Per ripristinarne la funzionalità, usa il comando. enable-key

Per ulteriori informazioni, consulta Pianificazione e annullamento dell'eliminazione delle chiavi nella AWS Key Management Service Developer Guide.

Per connettere un archivio di chiavi personalizzato

L'connect-custom-key-storeesempio seguente riconnette l'archivio di chiavi personalizzato specificato. È possibile utilizzare un comando come questo per connettere un archivio chiavi personalizzato per la prima volta o per ricollegare un archivio chiavi che era disconnesso.

È possibile utilizzare questo comando per connettere un key store AWS CloudHSM o un key store esterno.

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

Questo comando non restituisce alcun output. Per verificare che il comando sia stato efficace, utilizzare il describe-custom-key-stores comando.

Per informazioni sulla connessione di un key store AWS CloudHSM, consulta Connessione e disconnessione di un key store AWS CloudHSM nella Key Management Service Developer Guide.AWS

Per informazioni sulla connessione di un archivio di chiavi esterno, consulta Connessione e disconnessione di un archivio di chiavi esterno nella Key Management Service Developer Guide.AWS

Per creare un alias per una chiave KMS

Il create-alias comando seguente crea un alias denominato example-alias per la chiave KMS identificata dall'ID della chiave. 1234abcd-12ab-34cd-56ef-1234567890ab

I nomi alias devono iniziare con. alias/ Non utilizzare alias che iniziano conalias/aws. Questi sono riservati all'uso di. AWS

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

Questo comando non restituisce alcun output. Per vedere il nuovo alias, usa il list-aliases comando.

Per ulteriori informazioni, vedere Using alias nella AWS Key Management Service Developer Guide.

Esempio 1: creare un key store AWS CloudHSM

L'create-custom-key-storeesempio seguente crea un archivio di chiavi AWS CloudHSM supportato da un cluster AWS CloudHSM utilizzando i parametri richiesti. Puoi anche aggiungere il. custom-key-store-type``parameter with the default value: ``AWS_CLOUDHSM

Per specificare l'input del file per il trust-anchor-certificate comando nella AWS CLI, è necessario il file:// prefisso.

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

Output:

{
    "CustomKeyStoreId": cks-1234567890abcdef0
}

Per ulteriori informazioni, consulta Creating an AWS CloudHSM key store nella Key Management Service AWS Developer Guide.

Esempio 2: creare un archivio di chiavi esterno con connettività endpoint pubblica

L'create-custom-key-storeesempio seguente crea un archivio di chiavi esterno (XKS) che comunica con AWS KMS tramite Internet.

In questo esempio, XksProxyUriPath utilizza un prefisso opzionale di. example-prefix

NOTA: se utilizzi la versione AWS CLI 1.0, esegui il comando seguente prima di specificare un parametro con un valore HTTP o HTTPS, come il parametro. XksProxyUriEndpoint

aws configure set cli_follow_urlparam false

Altrimenti, la versione AWS CLI 1.0 sostituisce il valore del parametro con il contenuto trovato in quell'indirizzo URI.

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

Output:

{
    "CustomKeyStoreId": cks-2234567890abcdef0
}

Per ulteriori informazioni, consulta Creazione di un archivio di chiavi esterno nella AWS Key Management Service Developer Guide.

Esempio 3: creare un archivio di chiavi esterno con connettività del servizio endpoint VPC

L'create-custom-key-storeesempio seguente crea un archivio di chiavi esterno (XKS) che utilizza un servizio endpoint Amazon VPC per comunicare con KMS. AWS

NOTA: se utilizzi la versione AWS CLI 1.0, esegui il comando seguente prima di specificare un parametro con un valore HTTP o HTTPS, come il parametro. XksProxyUriEndpoint

aws configure set cli_follow_urlparam false

Altrimenti, la versione AWS CLI 1.0 sostituisce il valore del parametro con il contenuto trovato in quell'indirizzo URI.

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

Output:

{
    "CustomKeyStoreId": cks-3234567890abcdef0
}

Per ulteriori informazioni, consulta Creazione di un archivio di chiavi esterno nella AWS Key Management Service Developer Guide.

Per creare una sovvenzione

L'create-grantesempio seguente crea una concessione che consente all'exampleUserutente di utilizzare il decrypt comando sulla chiave KMS di 1234abcd-12ab-34cd-56ef-1234567890ab esempio. Il preside uscente è il adminRole ruolo. La concessione utilizza il vincolo EncryptionContextSubset grant per consentire questa autorizzazione solo quando il contesto di crittografia nella decrypt richiesta include la "Department": "IT" coppia chiave-valore.

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

Output:

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

Per visualizzare informazioni dettagliate sulla concessione, utilizzare il comando. list-grants

Per ulteriori informazioni, consulta Grants in AWS KMS nella AWS Key Management Service Developer Guide.

Esempio 1: creare una chiave KMS gestita dal cliente in AWS KMS

L'create-keyesempio seguente crea una chiave KMS di crittografia simmetrica.

Per creare la chiave KMS di base, una chiave di crittografia simmetrica, non è necessario specificare alcun parametro. I valori predefiniti per tali parametri creano una chiave di crittografia simmetrica.

Poiché questo comando non specifica una politica chiave, la chiave KMS ottiene la politica di chiave predefinita per le chiavi KMS create a livello di codice. Per visualizzare la politica chiave, usa il comando. get-key-policy Per modificare la politica chiave, usa il put-key-policy comando.

aws kms create-key

Il create-key comando restituisce i metadati chiave, inclusi l'ID chiave e l'ARN della nuova chiave KMS. Puoi utilizzare questi valori per identificare la chiave KMS in altre operazioni KMS. AWS L'output non include i tag. Per visualizzare i tag di una chiave KMS, usa illist-resource-tags command.

Output:

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

Nota: il create-key comando non consente di specificare un alias. Per creare un alias per la nuova chiave KMS, usa il comando. create-alias

Per ulteriori informazioni, vedere Creating keys nella AWS Key Management Service Developer Guide.

Esempio 2: creare una chiave RSA KMS asimmetrica per la crittografia e la decrittografia

L'create-keyesempio seguente crea una chiave KMS che contiene una coppia di chiavi RSA asimmetrica per la crittografia e la decrittografia. Le specifiche e l'utilizzo della chiave non possono essere modificati dopo la creazione della chiave. :

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

Output:

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

Per ulteriori informazioni, consulta Chiavi asimmetriche in AWS KMS nella AWS Key Management Service Developer Guide.

Esempio 3: creare una chiave KMS a curva ellittica asimmetrica per la firma e la verifica

Per creare una chiave KMS asimmetrica che contenga una coppia di chiavi a curva ellittica asimmetrica (ECC) per la firma e la verifica. Il --key-usage parametro è obbligatorio anche se è l'unico valore valido per le chiavi ECC SIGN_VERIFY KMS. Le specifiche e l'utilizzo della chiave non possono essere modificati dopo la creazione della chiave. :

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

Output:

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

Per ulteriori informazioni, consulta Chiavi asimmetriche in AWS KMS nella AWS Key Management Service Developer Guide.

Esempio 4: creare una chiave KMS ML-DSA asimmetrica per la firma e la verifica

Questo esempio crea una chiave ML-DSA (Module-Lattice Digital Signature Algorithm) per la firma e la verifica. Il parametro key-usage è obbligatorio anche se SIGN_VERIFY è l'unico valore valido per le chiavi ML-DSA.

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

Output:

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

Per ulteriori informazioni, consulta la sezione Chiavi asimmetriche in AWS KMS nella Key Management Service Developer Guide.AWS

Esempio 5: creare una chiave HMAC KMS

L'create-keyesempio seguente crea una chiave KMS HMAC a 384 bit. Il GENERATE_VERIFY_MAC valore del --key-usage parametro è obbligatorio anche se è l'unico valore valido per le chiavi HMAC KMS.

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

Output:

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

Per ulteriori informazioni, consulta le chiavi HMAC in AWS KMS nella Guida per gli sviluppatori del servizio di gestione delle AWS chiavi.

Esempio 6: per creare una chiave KMS primaria multiregionale

L'create-keyesempio seguente crea una chiave di crittografia simmetrica primaria multiregione. Poiché i valori predefiniti per tutti i parametri creano una chiave di crittografia simmetrica, per questa chiave KMS è richiesto solo il --multi-region parametro. Nella AWS CLI, per indicare che un parametro booleano è vero, è sufficiente specificare il nome del parametro.

aws kms create-key \
    --multi-region

Output:

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

Per ulteriori informazioni, consulta la sezione Chiavi asimmetriche in AWS KMS nella Key Management Service Developer Guide.AWS

Esempio 7: per creare una chiave KMS per il materiale chiave importato

L'create-keyesempio seguente crea una chiave KMS senza materiale chiave. Una volta completata l'operazione, puoi importare il tuo materiale chiave nella chiave KMS. Per creare questa chiave KMS, imposta il --origin parametro su. EXTERNAL

aws kms create-key \
    --origin EXTERNAL

Output:

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

Per ulteriori informazioni, consulta Importazione di materiale chiave nelle chiavi AWS KMS nella AWS Key Management Service Developer Guide.

Esempio 6: creare una chiave KMS in un key store AWS CloudHSM

L'create-keyesempio seguente crea una chiave KMS nell'archivio di chiavi AWS CloudHSM specificato. L'operazione crea la chiave KMS e i relativi metadati in AWS KMS e crea il materiale chiave nel cluster CloudHSM associato all' AWS archivio chiavi personalizzato. I parametri --custom-key-store-id e --origin sono obbligatori.

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

Output:

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

Per ulteriori informazioni, consulta AWS CloudHSM key store nella Key Management Service AWS Developer Guide.

Esempio 8: creare una chiave KMS in un archivio di chiavi esterno

L'create-keyesempio seguente crea e crea una chiave KMS nell'archivio di chiavi esterno specificato. I --xks-key-id parametri --custom-key-store-id--origin, e sono obbligatori in questo comando.

Il --xks-key-id parametro specifica l'ID di una chiave di crittografia simmetrica esistente nel gestore di chiavi esterno. Questa chiave funge da materiale chiave esterno per la chiave KMS. Il valore del --origin parametro deve essere EXTERNAL_KEY_STORE .Il custom-key-store-id parametro deve identificare un archivio chiavi esterno collegato al relativo proxy di archiviazione chiavi esterno.

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

Output:

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

Per ulteriori informazioni, consulta gli archivi di chiavi esterni nella AWS Key Management Service Developer Guide.

Esempio 1: decrittografare un messaggio crittografato con una chiave KMS simmetrica (Linux e macOS)

Il seguente esempio di decrypt comando mostra il metodo consigliato per decrittografare i dati con la CLI. AWS Questa versione mostra come decrittografare i dati con una chiave KMS simmetrica.

Fornisci il testo cifrato in un file. Nel valore del --ciphertext-blob parametro, usa il fileb:// prefisso, che indica alla CLI di leggere i dati da un file binario. Se il file non si trova nella directory corrente, digitate il percorso completo del file. Per ulteriori informazioni sulla lettura dei valori dei parametri AWS CLI da un file, consulta Loading AWS CLI parameters from a file < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> nella Command Line Interface User Guide e Best Practices for Local File Parameters< https://aws.amazon.com/blogs/ developer/ best-practices-for-local -file-parameters/> nel AWS Command Line Tool Blog .Specificare la chiave KMS per decrittografare il CipherText.Il AWS parametro non è necessario quando si esegue la decrittografia con una chiave KMS simmetrica. --key-id AWS KMS può ottenere l'ID della chiave KMS utilizzata per crittografare i dati dai metadati nel testo cifrato. Tuttavia è sempre consigliabile specificare la chiave KMS che stai utilizzando. Questa pratica garantisce l'utilizzo della chiave KMS desiderata e impedisce di decifrare inavvertitamente un testo cifrato utilizzando una chiave KMS non attendibile.Richiedi l'output di testo in chiaro come valore di testo.Il --query parametro indica alla CLI di ottenere solo il valore del campo dall'output. Plaintext Il --output parametro restituisce l'output come text.base64: decodifica il testo semplice e lo salva in un file. L'esempio seguente invia (|) il valore del Plaintext parametro all'utilità Base64, che lo decodifica. Quindi, reindirizza (>) l'output decodificato al file. ExamplePlaintext

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo account. AWS

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

Questo comando non produce alcun output. L'output del decrypt comando viene decodificato in base64 e salvato in un file.

Per ulteriori informazioni, vedete Decrypt nel Key Management Service API Reference.AWS

Esempio 2: per decrittografare un messaggio crittografato con una chiave KMS simmetrica (prompt dei comandi di Windows)

L'esempio seguente è lo stesso del precedente, tranne per il fatto che utilizza l'certutilutilità per decodificare in Base64 i dati di testo in chiaro. Questa procedura richiede due comandi, come illustrato negli esempi seguenti.

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account.

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

Esegui il comando certutil.

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Output:

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

Per ulteriori informazioni, consulta Decrypt nel riferimento all'API di AWS riferimento del servizio di gestione delle chiavi.

Esempio 3: decrittografare un messaggio crittografato con una chiave KMS asimmetrica (Linux e macOS)

Il seguente esempio di decrypt comando mostra come decrittografare i dati crittografati con una chiave KMS asimmetrica RSA.

Quando si utilizza una chiave KMS asimmetrica, è obbligatorio il encryption-algorithm parametro che specifica l'algoritmo utilizzato per crittografare il testo in chiaro.

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID di chiave valido del tuo account. AWS

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

Questo comando non produce alcun output. L'output del decrypt comando viene decodificato in base64 e salvato in un file.

Per ulteriori informazioni, consulta la sezione Chiavi asimmetriche in KMS nella AWS Key Management Service Developer Guide.AWS

Per eliminare un AWS alias KMS

L'delete-aliasesempio seguente elimina l'alias. alias/example-alias Il nome dell'alias deve iniziare con alias/.

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

Questo comando non produce alcun output. Per trovare l'alias, usa il comando. list-aliases

Per ulteriori informazioni, vedere Eliminazione di un alias nella AWS Key Management Service Developer Guide.

Per eliminare un archivio di chiavi personalizzato

L'delete-custom-key-storeesempio seguente elimina l'archivio di chiavi personalizzato specificato.

L'eliminazione di un key store AWS CloudHSM non ha alcun effetto sul cluster CloudHSM associato. L'eliminazione di un key store esterno non ha alcun effetto sul proxy dell'archivio chiavi esterno associato, sul gestore di chiavi esterno o sulle chiavi esterne.

NOTA: prima di poter eliminare un archivio chiavi personalizzato, è necessario pianificare l'eliminazione di tutte le chiavi KMS nell'archivio chiavi personalizzato e quindi attendere che tali chiavi KMS vengano eliminate. Quindi, è necessario disconnettere l'archivio chiavi personalizzato. Per assistenza nella ricerca delle chiavi KMS nell'archivio chiavi personalizzato, consulta Eliminare un AWS archivio di chiavi (API) di CloudHSM nella Key Management Service Developer AWS Guide.

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

Questo comando non restituisce alcun output. Per verificare che l'archivio di chiavi personalizzato venga eliminato, usa il comando. describe-custom-key-stores

Per informazioni sull'eliminazione di un archivio di chiavi AWS CloudHSM, consulta Eliminazione di un archivio di chiavi AWS CloudHSM nella Key Management Service Developer Guide.AWS

Per informazioni sull'eliminazione di archivi di chiavi esterni, vedere Eliminazione di un archivio di chiavi esterne nella Key Management Service Developer Guide.AWS

Per eliminare il materiale chiave importato da una chiave KMS

L'delete-imported-key-materialesempio seguente elimina il materiale chiave che era stato importato in una chiave KMS.

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

Output:

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

Per ulteriori informazioni, vedere Eliminazione del materiale chiave importato nella AWS Key Management Service Developer Guide.

Per ricavare un segreto condiviso

L'derive-shared-secretesempio seguente ricava un segreto condiviso utilizzando un algoritmo di accordo chiave.

È necessario utilizzare una coppia di chiavi KMS asimmetrica a curva ellittica (ECC) o (solo per le SM2 regioni della Cina) consigliata dal NIST con un valore pari a to call. KeyUsage KEY_AGREEMENT DeriveSharedSecret

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

Output:

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

Per ulteriori informazioni, consulta la sezione Key Management Service API Reference. DeriveSharedSecretAWS

Esempio 1: Per ottenere dettagli su un key store AWS CloudHSM

L'describe-custom-key-storeesempio seguente visualizza i dettagli sull'archivio di chiavi AWS CloudHSM specificato. Il comando è lo stesso per tutti i tipi di archivi chiavi personalizzati, ma l'output differisce a seconda del tipo di archivio chiavi e, per un archivio chiavi esterno, della relativa opzione di connettività.

Per impostazione predefinita, questo comando visualizza informazioni su tutti gli archivi di chiavi personalizzati nell'account e nella regione. Per visualizzare informazioni su un particolare archivio di chiavi personalizzato, utilizzare il custom-key-store-id parametro custom-key-store-name o.

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

L'output di questo comando include dettagli utili sull'archivio di chiavi AWS CloudHSM, incluso lo stato della connessione (). ConnectionState Se lo stato della connessione èFAILED, l'output include un ConnectionErrorCode campo che descrive il problema.

Output:

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

Per ulteriori informazioni, consulta Viewing an AWS CloudHSM key store nella Key Management Service AWS Developer Guide.

Esempio 2: per ottenere dettagli su un archivio di chiavi esterno con connettività endpoint pubblica

L'describe-custom-key-storeesempio seguente mostra i dettagli sull'archivio di chiavi esterno specificato. Il comando è lo stesso per tutti i tipi di archivi chiavi personalizzati, ma l'output differisce a seconda del tipo di archivio chiavi e, per un archivio chiavi esterno, della relativa opzione di connettività.

Per impostazione predefinita, questo comando visualizza informazioni su tutti gli archivi di chiavi personalizzati nell'account e nella regione. Per visualizzare informazioni su un particolare archivio di chiavi personalizzato, utilizzare il custom-key-store-id parametro custom-key-store-name o.

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

L'output di questo comando include dettagli utili sull'archivio chiavi esterno, incluso lo stato della connessione (ConnectionState). Se lo stato della connessione èFAILED, l'output include un ConnectionErrorCode campo che descrive il problema.

Output:

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

Per ulteriori informazioni, vedere Visualizzazione di un archivio di chiavi esterno nella Guida per gli sviluppatori del servizio di gestione delle AWS chiavi.

Esempio 3: per ottenere dettagli su un archivio di chiavi esterno con connettività del servizio endpoint VPC

L'describe-custom-key-storeesempio seguente mostra i dettagli sull'archivio di chiavi esterno specificato. Il comando è lo stesso per tutti i tipi di archivi chiavi personalizzati, ma l'output differisce a seconda del tipo di archivio chiavi e, per un archivio chiavi esterno, della relativa opzione di connettività.

Per impostazione predefinita, questo comando visualizza informazioni su tutti gli archivi di chiavi personalizzati nell'account e nella regione. Per visualizzare informazioni su un particolare archivio di chiavi personalizzato, utilizzare il custom-key-store-id parametro custom-key-store-name o.

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

L'output di questo comando include dettagli utili sull'archivio chiavi esterno, incluso lo stato della connessione (ConnectionState). Se lo stato della connessione èFAILED, l'output include un ConnectionErrorCode campo che descrive il problema.

Output:

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

Per ulteriori informazioni, vedere Visualizzazione di un archivio di chiavi esterno nella Guida per gli sviluppatori del servizio di gestione delle AWS chiavi.

Esempio 1: per trovare informazioni dettagliate su una chiave KMS

L'describe-keyesempio seguente ottiene informazioni dettagliate sulla chiave AWS gestita per Amazon S3 nell'account e nella regione di esempio. Puoi utilizzare questo comando per trovare dettagli sulle chiavi gestite e sulle chiavi AWS gestite dai clienti.

Per specificare la chiave KMS, usa il key-id parametro. Questo esempio utilizza un valore di nome alias, ma è possibile utilizzare un ID chiave, un ARN di chiave, un nome alias o un alias ARN in questo comando.

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

Output:

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

Per ulteriori informazioni, vedere Viewing keys nella AWS Key Management Service Developer Guide.

Esempio 2: per ottenere dettagli su una chiave KMS asimmetrica RSA

L'describe-keyesempio seguente ottiene informazioni dettagliate su una chiave RSA KMS asimmetrica utilizzata per la firma e la verifica.

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

Output:

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

Esempio 3: per ottenere dettagli su una chiave di replica multiregionale

L'describe-keyesempio seguente ottiene i metadati per una chiave di replica multiregionale. Questa chiave multiregionale è una chiave di crittografia simmetrica. L'output di un describe-key comando per qualsiasi chiave multiregionale restituisce informazioni sulla chiave primaria e su tutte le relative repliche.

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

Output:

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

Esempio 4: per ottenere dettagli su una chiave KMS HMAC

L'describe-keyesempio seguente ottiene informazioni dettagliate su una chiave KMS HMAC.

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

Output:

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

Per disabilitare la rotazione automatica di una chiave KMS

L'disable-key-rotationesempio seguente disabilita la rotazione automatica di una chiave KMS gestita dal cliente. Per riattivare la rotazione automatica, utilizzare il comando. enable-key-rotation

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

Questo comando non produce alcun output. Per verificare che la rotazione automatica sia disabilitata per la chiave KMS, usa il get-key-rotation-status comando.

Per ulteriori informazioni, consulta Rotating keys nella AWS Key Management Service Developer Guide.

Per disabilitare temporaneamente una chiave KMS

Il disable-key comando seguente disabilita una chiave KMS gestita dal cliente. Per riattivare la chiave KMS, usa il comando. enable-key

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

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Enabling and Disabling Keys nella AWS Key Management Service Developer Guide.

Per disconnettere un archivio di chiavi personalizzato

L'disconnect-custom-key-storeesempio seguente disconnette un key store personalizzato dal relativo cluster AWS CloudHSM. È possibile disconnettere un archivio di chiavi per risolvere un problema, aggiornarne le impostazioni o impedire l'utilizzo delle chiavi KMS nel keystore nelle operazioni crittografiche.

Questo comando è lo stesso per tutti gli archivi di chiavi personalizzati, inclusi gli archivi di chiavi AWS CloudHSM e gli archivi di chiavi esterni.

Prima di eseguire questo comando, sostituisci l'ID store chiavi personalizzate di esempio con uno valido.

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

Questo comando non produce alcun output. Verifica che il comando sia efficace, usa il comando. describe-custom-key-stores

Per ulteriori informazioni sulla disconnessione di un key store AWS CloudHSM, consulta Connecting and disconnect an AWS CloudHSM key store nella Key Management Service Developer Guide.AWS

Per ulteriori informazioni sulla disconnessione di un archivio di chiavi esterno, consulta Connessione e disconnessione di un archivio di chiavi esterno nella Key Management Service Developer Guide.AWS

Per abilitare la rotazione automatica di una chiave KMS

L'enable-key-rotationesempio seguente abilita la rotazione automatica di una chiave KMS gestita dal cliente con un periodo di rotazione di 180 giorni. La chiave KMS verrà ruotata di un anno (circa 365 giorni) dalla data di completamento di questo comando e successivamente ogni anno.

Il --key-id parametro identifica la chiave KMS. Questo esempio utilizza un valore ARN della chiave, ma è possibile utilizzare l'ID chiave o l'ARN della chiave KMS. Il --rotation-period-in-days parametro specifica il numero di giorni tra ogni data di rotazione. Specificate un valore compreso tra 90 e 2560 giorni. Se non viene specificato alcun valore, il valore predefinito è 365 giorni.

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

Questo comando non produce alcun output. Per verificare che la chiave KMS sia abilitata, usa il get-key-rotation-status comando.

Per ulteriori informazioni, consulta Rotating keys nella AWS Key Management Service Developer Guide.

Per abilitare una chiave KMS

L'enable-keyesempio seguente abilita una chiave gestita dal cliente. Puoi usare un comando come questo per abilitare una chiave KMS che hai temporaneamente disabilitato utilizzando il disable-key comando. Puoi anche usarlo per abilitare una chiave KMS che è disabilitata perché era stata pianificata per l'eliminazione e l'eliminazione è stata annullata.

Per specificare la chiave KMS, usa il parametro. key-id Questo esempio utilizza un valore ID chiave, ma è possibile utilizzare un ID chiave o un valore ARN della chiave in questo comando.

Prima di eseguire questo comando, sostituite l'ID della chiave di esempio con uno valido.

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

Questo comando non produce alcun output. Per verificare che la chiave KMS sia abilitata, usa il describe-key comando. Visualizza i valori dei Enabled campi KeyState e nell'describe-keyoutput.

Per ulteriori informazioni, vedere Enabling and Disabling Keys nella AWS Key Management Service Developer Guide.

Esempio 1: cifrare il contenuto di un file su Linux o macOS

Il encrypt comando seguente illustra il metodo consigliato per crittografare i dati con la AWS CLI.

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

Il comando esegue diverse operazioni:

Utilizza il --plaintext parametro per indicare i dati da crittografare. Il valore di questo parametro deve essere codificato in base 64. Il valore del plaintext parametro deve essere codificato in base 64 oppure è necessario utilizzare il prefissofileb://, che indica alla CLI di leggere i dati binari dal file. Se il AWS file non si trova nella directory corrente, digitare il percorso completo del file. Ad esempio: fileb:///var/tmp/ExamplePlaintextFile o fileb://C:\Temp\ExamplePlaintextFile. Per ulteriori informazioni sulla lettura dei valori dei parametri AWS CLI da un file, vedere Loading Parameters from a File nella AWS Command Line Interface User Guide e Best Practices for Local File Parameters nel blog AWS Command Line Tool. Utilizza --query i parametri --output and per controllare l'output del comando. Questi parametri estraggono i dati crittografati, chiamati ciphertext, dall'output del comando.Per ulteriori informazioni sul controllo dell'output, vedere Controllo del comando Output nella Guida per l'utente dell'interfaccia a riga di AWS comando. Utilizza l'base64utilità per decodificare l'output estratto in dati binari. Il testo cifrato restituito da un encrypt comando riuscito è testo con codifica in base64. È necessario decodificare questo testo prima di poter utilizzare la AWS CLI per decrittografarlo. Salva il testo cifrato binario in un file.La parte finale del comando > ExampleEncryptedFile () salva il testo cifrato binario in un file per semplificare la decrittografia. Per un comando di esempio che utilizza la AWS CLI per decrittografare i dati, consulta gli esempi di decrittografia.

Esempio 2: utilizzo della AWS CLI per crittografare i dati su Windows

Questo esempio è lo stesso del precedente, tranne per il fatto che utilizza lo certutil strumento anziché. base64 Questa procedura richiede due comandi, come illustrato nell'esempio seguente.

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

Esempio 3: crittografia con una chiave KMS asimmetrica

Il encrypt comando seguente mostra come crittografare il testo in chiaro con una chiave KMS asimmetrica. Il parametro --encryption-algorithm è obbligatorio. Come in tutti i comandi encrypt CLI, il plaintext parametro deve essere codificato in base 64 oppure è necessario utilizzare il prefissofileb://, che indica alla CLI di leggere i dati binari dal file AWS .

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

Questo comando non produce alcun output.

Per generare una coppia di chiavi dati asimmetriche ECC NIST P384

L'generate-data-key-pair-without-plaintextesempio seguente richiede una coppia di chiavi ECC NIST P384 da utilizzare all'esterno di. AWS

Il comando restituisce una chiave pubblica in chiaro e una copia della chiave privata crittografata con la chiave KMS specificata. Non restituisce una chiave privata in testo normale. È possibile archiviare in modo sicuro la chiave privata crittografata con i dati crittografati e chiamare AWS KMS per decrittografare la chiave privata quando è necessario utilizzarla.

Per richiedere una coppia di chiavi dati asimmetriche ECC NIST P384, key-pair-spec utilizzare il parametro con un valore di. ECC_NIST_P384

La chiave KMS specificata deve essere una chiave KMS di crittografia simmetrica, ovvero una chiave KMS con un valore di. KeySpec SYMMETRIC_DEFAULT

NOTA: i valori nell'output di questo esempio vengono troncati per essere visualizzati.

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

Output:

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

I PublicKey e PrivateKeyCiphertextBlob vengono restituiti in formato con codifica base64.

Per ulteriori informazioni, consulta Data key pairs nella Key Management Service Developer AWS Guide.

Per generare una coppia di chiavi dati asimmetriche RSA a 2048 bit

L'generate-data-key-pairesempio seguente richiede una coppia di chiavi dati asimmetriche RSA a 2048 bit da utilizzare all'esterno di. AWS Il comando restituisce una chiave pubblica in testo semplice e una chiave privata in testo semplice per l'uso e l'eliminazione immediati e una copia della chiave privata crittografata con la chiave KMS specificata. È possibile archiviare in modo sicuro la chiave privata crittografata con i dati crittografati.

Per richiedere una coppia di chiavi dati asimmetriche RSA a 2048 bit, key-pair-spec utilizzare il parametro con un valore di. RSA_2048

La chiave KMS specificata deve essere una chiave KMS di crittografia simmetrica, ovvero una chiave KMS con un valore di. KeySpec SYMMETRIC_DEFAULT

NOTA: i valori nell'output di questo esempio vengono troncati per essere visualizzati.

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

Output:

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

I PublicKeyPrivateKeyPlaintext, e PrivateKeyCiphertextBlob vengono restituiti in formato con codifica base64.

Per ulteriori informazioni, consulta Data key pairs nella Key Management Service Developer AWS Guide.

Per generare una chiave dati simmetrica a 256 bit senza una chiave di testo semplice

L'generate-data-key-without-plaintextesempio seguente richiede una copia crittografata di una chiave dati simmetrica a 256 bit da utilizzare all'esterno di. AWS Puoi chiamare AWS KMS per decrittografare la chiave dati quando sei pronto per usarla.

Per richiedere una chiave dati a 256 bit, usa il key-spec parametro con un valore di. AES_256 Per richiedere una chiave dati a 128 bit, utilizzate il key-spec parametro con un valore di. AES_128 Per tutte le altre lunghezze delle chiavi dati, utilizzate il number-of-bytes parametro.

La chiave KMS specificata deve essere una chiave KMS di crittografia simmetrica, ovvero una chiave KMS con un valore specifico della chiave 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

Output:

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

La CiphertextBlob (chiave dati crittografata) viene restituita in formato con codifica base64.

Per ulteriori informazioni, consulta Data keys nella AWS Key Management Service Developer Guide.

Esempio 1: generare una chiave dati simmetrica a 256 bit

L'generate-data-keyesempio seguente richiede una chiave dati simmetrica a 256 bit da utilizzare all'esterno di. AWS Il comando restituisce una chiave di dati in testo semplice per l'uso e l'eliminazione immediati e una copia di tale chiave dati crittografata con la chiave KMS specificata. Puoi archiviare la chiave di dati crittografata in modo sicuro con i dati crittografati.

Per richiedere una chiave dati a 256 bit, utilizzate il key-spec parametro con un valore di. AES_256 Per richiedere una chiave dati a 128 bit, utilizzate il key-spec parametro con un valore di. AES_128 Per tutte le altre lunghezze delle chiavi dati, utilizzate il number-of-bytes parametro.

La chiave KMS specificata deve essere una chiave KMS di crittografia simmetrica, ovvero una chiave KMS con un valore specifico della chiave SYMMETRIC_DEFAULT.

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

Output:

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

La Plaintext (chiave dati in chiaro) e la (chiave dati crittografata) vengono restituite in formato con codifica base64. CiphertextBlob

Per ulteriori informazioni, consulta Data keys nella Key Management Service Developer Guide.AWS Esempio 2: generare una chiave dati simmetrica a 512 bit

L'generate-data-keyesempio seguente richiede una chiave dati simmetrica a 512 bit per la crittografia e la decrittografia. Il comando restituisce una chiave di dati in testo semplice per l'uso e l'eliminazione immediati e una copia di tale chiave dati crittografata con la chiave KMS specificata. Puoi archiviare la chiave di dati crittografata in modo sicuro con i dati crittografati.

Per richiedere una lunghezza di chiave diversa da 128 o 256 bit, utilizzate il parametro. number-of-bytes Per richiedere una chiave dati a 512 bit, l'esempio seguente utilizza il number-of-bytes parametro con un valore di 64 (byte).

La chiave KMS specificata deve essere una chiave KMS di crittografia simmetrica, ovvero una chiave KMS con un valore specifico della chiave SYMMETRIC_DEFAULT.

NOTA: i valori nell'output di questo esempio vengono troncati per essere visualizzati.

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

Output:

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

Plaintext(chiave dati in chiaro) e CiphertextBlob (chiave dati crittografata) vengono restituite in formato con codifica base64.

Per ulteriori informazioni, consulta Data keys nella Key Management Service Developer Guide.AWS

Esempio 1: generare un HMAC per un messaggio

Il generate-mac comando seguente genera un HMAC per un messaggio, una chiave KMS HMAC e un algoritmo MAC. L'algoritmo deve essere supportato dalla chiave KMS HMAC specificata.

In AWS CLI v2, il valore del message parametro deve essere codificato in Base64. In alternativa, puoi salvare il messaggio in un file e utilizzare il fileb:// prefisso, che indica alla AWS CLI di leggere i dati binari dal file.

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account. L'ID chiave deve rappresentare una chiave KMS HMAC con un utilizzo chiave di. GENERATE_VERIFY_MAC

msg=(echo 'Hello World' | base64)

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

Output:

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

Per ulteriori informazioni sull'utilizzo delle chiavi HMAC KMS in KMS, consulta le chiavi HMAC in AWS KMS nella AWS Key Management Service Developer Guide.AWS

Esempio 2: salvare un HMAC in un file (Linux e macOS)

L'generate-macesempio seguente genera un HMAC per un breve messaggio memorizzato in un file locale. Il comando ottiene anche la Mac proprietà dalla risposta, Base64 la decodifica e la salva nel file. ExampleMac È possibile utilizzare il file MAC in un verify-mac comando che verifica il MAC.

Il generate-mac comando richiede un messaggio con codifica Base64 e un algoritmo MAC supportato dalla chiave KMS HMAC. Per ottenere gli algoritmi MAC supportati dalla tua chiave KMS, usa il comando. describe-key

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account. L'ID della chiave deve rappresentare una chiave KMS asimmetrica con un utilizzo chiave di GENERATE_VERIFY_MAC.

echo 'hello world' | base64 > EncodedMessage

aws kms generate-mac \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --message fileb://EncodedMessage \
    --mac-algorithm HMAC_SHA_384 \
    --output text \
    --query Mac | base64 --decode > ExampleMac

Questo comando non produce alcun output. Questo esempio estrae la proprietà dell'output e la salva in un file. Mac

Per ulteriori informazioni sull'utilizzo delle chiavi HMAC KMS in AWS KMS, consulta le chiavi HMAC in KMS nella AWS Key Management Service Developer Guide.AWS

Esempio 1: generare una stringa di byte casuale a 256 bit (Linux o macOS)

L'generate-randomesempio seguente genera una stringa di byte casuali a 256 bit (32 byte) con codifica in base64. L'esempio decodifica la stringa di byte e la salva in un file casuale.

Quando si esegue questo comando, è necessario utilizzare il number-of-bytes parametro per specificare la lunghezza del valore casuale in byte.

Non si specifica una chiave KMS quando si esegue questo comando. La stringa di byte casuale non è correlata a nessuna chiave KMS.

Per impostazione predefinita, AWS KMS genera il numero casuale. Tuttavia, se si specifica un key store personalizzato, la stringa di byte casuale viene generata nel cluster AWS CloudHSM associato all'archivio chiavi personalizzato.

Questo esempio utilizza i seguenti parametri e valori:

Utilizza il --number-of-bytes parametro richiesto con un valore di 32 per richiedere una stringa da 32 byte (256 bit). Utilizza il --output parametro con un valore di per text indirizzare la AWS CLI a restituire l'output come testo, anziché JSON.Utilizza il per estrarre il valore della Plaintext proprietà da Response.it invia (|) l'output del comando --query parameter all'base64utilità, che decodifica l'output estratto.Utilizza l'operatore di reindirizzamento (>) per salvare la decodifica stringa di byte aggiunta al file. Utilizza l'operatore di reindirizzamento (>) ExampleRandom per salvare il testo cifrato binario in un file.

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

Questo comando non produce alcun output.

Per ulteriori informazioni, vedere GenerateRandomnel AWS Key Management Service API Reference.

Esempio 2: generare un numero casuale a 256 bit (prompt dei comandi di Windows)

L'esempio seguente utilizza il generate-random comando per generare una stringa di byte casuali a 256 bit (32 byte) con codifica base64. L'esempio decodifica la stringa di byte e la salva in un file casuale. Questo esempio è lo stesso dell'esempio precedente, tranne per il fatto che utilizza l'certutilutilità di Windows per decodificare in base64 la stringa di byte casuale prima di salvarla in un file.

Innanzitutto, genera una stringa di byte casuali codificata in base64 e la salva in un file temporaneo,. ExampleRandom.base64

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

Poiché l'output del generate-random comando viene salvato in un file, questo esempio non produce alcun output.

Ora utilizzate il certutil -decode comando per decodificare la stringa di byte codificata in base64 nel file. ExampleRandom.base64 Quindi, salva la stringa di byte decodificata nel file. ExampleRandom

certutil -decode ExampleRandom.base64 ExampleRandom

Output:

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

Per ulteriori informazioni, consulta GenerateRandomla sezione AWS Key Management Service API Reference.

Per copiare una politica chiave da una chiave KMS a un'altra chiave KMS

L'get-key-policyesempio seguente ottiene la politica chiave da una chiave KMS e la salva in un file di testo. Quindi, sostituisce la politica di una chiave KMS diversa utilizzando il file di testo come input della politica.

Poiché il --policy parametro di put-key-policy richiede una stringa, è necessario utilizzare l'--output textopzione per restituire l'output come stringa di testo anziché JSON.

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

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

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta PutKeyPolicyla sezione AWS KMS API Reference.

Per recuperare lo stato di rotazione di una chiave KMS.

L'get-key-rotation-statusesempio seguente restituisce informazioni sullo stato di rotazione della chiave KMS specificata, incluso se la rotazione automatica è abilitata, il periodo di rotazione e la successiva data di rotazione pianificata. È possibile utilizzare questo comando sulle chiavi KMS gestite dal cliente e sulle chiavi KMS AWS gestite. Tuttavia, tutte le chiavi KMS AWS gestite vengono ruotate automaticamente ogni anno.

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

Output:

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

Per ulteriori informazioni, consulta Rotating keys nella AWS Key Management Service Developer Guide.

Per ottenere gli articoli necessari per importare il materiale chiave in una chiave KMS

L'get-parameters-for-importesempio seguente ottiene la chiave pubblica e il token di importazione necessari per importare il materiale chiave in una chiave KMS. Quando usi il import-key-material comando, assicurati di utilizzare il token di importazione e il materiale chiave crittografati dalla chiave pubblica restituiti nello stesso get-parameters-for-import comando. Inoltre, l'algoritmo di wrapping specificato in questo comando deve essere quello utilizzato per crittografare il materiale della chiave con la chiave pubblica.

Per specificare la chiave KMS, utilizzate il parametro. key-id Questo esempio utilizza un ID chiave, ma in questo comando è possibile utilizzare un ID chiave o un ARN di chiave.

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

Output:

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

Per ulteriori informazioni, consulta Scaricare la chiave pubblica e importare il token nella AWS Key Management Service Developer Guide.

Esempio 1: scaricare la chiave pubblica di una chiave KMS asimmetrica

L'get-public-keyesempio seguente scarica la chiave pubblica di una chiave KMS asimmetrica.

Oltre a restituire la chiave pubblica, l'output include le informazioni necessarie per utilizzare la chiave pubblica in modo sicuro al di fuori di AWS KMS, incluso l'utilizzo della chiave e gli algoritmi di crittografia supportati.

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

Output:

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

Per ulteriori informazioni sull'utilizzo delle chiavi KMS asimmetriche in KMS, consulta la sezione Chiavi asimmetriche in AWS KMS nella Key Management Service Developer Guide. AWS AWS Esempio 2: convertire una chiave pubblica in formato DER (Linux e macOS)

L'get-public-keyesempio seguente scarica la chiave pubblica di una chiave KMS asimmetrica e la salva in un file DER.

Quando si utilizza il get-public-key comando nella AWS CLI, restituisce una chiave pubblica X.509 con codifica DER e codifica Base64. Questo esempio ottiene il valore della proprietà come testo. PublicKey Base64 decodifica PublicKey e lo salva nel file. public_key.der Il output parametro restituisce l'output come testo, anziché in JSON. Il --query parametro ottiene solo la PublicKey proprietà, non le proprietà necessarie per utilizzare la chiave pubblica in modo sicuro all'esterno di AWS KMS.

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account.

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

Questo comando non produce alcun output.

Per ulteriori informazioni sull'utilizzo delle chiavi KMS asimmetriche in KMS, consulta Chiavi asimmetriche in AWS KMS nella AWS Key Management Service Developer Guide.AWS

Per importare materiale chiave in una chiave KMS

L'import-key-materialesempio seguente carica il materiale chiave in una chiave KMS creata senza materiale chiave. Lo stato chiave della chiave KMS deve essere. PendingImport

Questo comando utilizza materiale chiave crittografato con la chiave pubblica restituita dal get-parameters-for-import comando. Utilizza anche il token di importazione dello stesso get-parameters-for-import comando.

Il expiration-model parametro indica che il materiale chiave scade automaticamente alla data e all'ora specificate dal valid-to parametro. Quando il materiale chiave scade, AWS KMS elimina il materiale chiave, lo stato chiave della chiave KMS cambia Pending import e la chiave KMS diventa inutilizzabile. Per ripristinare la chiave KMS, è necessario reimportare lo stesso materiale chiave. Per utilizzare materiale chiave diverso, è necessario creare una nuova chiave KMS.

Prima di eseguire questo comando, sostituisci l'ID chiave di esempio con un ID chiave o un ARN di chiave valido dal tuo AWS account.

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

Output:

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

Per ulteriori informazioni sull'importazione di materiale chiave, vedere Importazione di materiale chiave nella Key Management Service AWS Developer Guide.

Esempio 1: per elencare tutti gli alias in un AWS account e in una regione

L'esempio seguente utilizza il list-aliases comando per elencare tutti gli alias nella regione predefinita dell' AWS account. L'output include alias associati alle chiavi KMS AWS gestite e alle chiavi KMS gestite dal cliente.

aws kms list-aliases

Output:

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

Esempio 2: per elencare tutti gli alias per una particolare chiave KMS

L'esempio seguente utilizza il list-aliases comando e il relativo key-id parametro per elencare tutti gli alias associati a una particolare chiave KMS.

Ogni alias è associato a una sola chiave KMS, ma una chiave KMS può avere più alias. Questo comando è molto utile perché la console AWS KMS elenca solo un alias per ogni chiave KMS. Per trovare tutti gli alias per una chiave KMS, devi usare il comando. list-aliases

Questo esempio utilizza l'ID chiave della chiave KMS per il --key-id parametro, ma è possibile utilizzare un ID chiave, un ARN di chiave, un nome alias o un alias ARN in questo comando.

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

Output:

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

Per ulteriori informazioni, consulta Working with Aliases nella Key Management Service Developer Guide AWS .

Per visualizzare le sovvenzioni su una chiave AWS KMS

L'list-grantsesempio seguente mostra tutte le concessioni sulla chiave KMS AWS gestita specificata per Amazon DynamoDB nel tuo account. Questa concessione consente a DynamoDB di utilizzare la chiave KMS per conto dell'utente per crittografare una tabella DynamoDB prima di scriverla su disco. Puoi utilizzare un comando come questo per visualizzare le concessioni relative alle chiavi KMS gestite e alle chiavi KMS AWS gestite dal cliente nell'account e nella regione. AWS

Questo comando utilizza il key-id parametro con un ID chiave per identificare la chiave KMS. È possibile utilizzare un ID chiave o un ARN per identificare la chiave KMS. Per ottenere l'ID o l'ARN della chiave di una chiave KMS AWS gestita, usa il list-keys comando or. list-aliases

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

L'output mostra che la concessione autorizza Amazon DynamoDB a utilizzare la chiave KMS per operazioni crittografiche e consente di visualizzare i dettagli sulla chiave KMS () e di ritirare le sovvenzioni DescribeKey (). RetireGrant Il EncryptionContextSubset vincolo limita queste autorizzazioni alle richieste che includono le coppie di contesti di crittografia specificate. Di conseguenza, le autorizzazioni incluse nella concessione sono valide solo per l'account e la tabella DynamoDB specificati.

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

Per ulteriori informazioni, consulta Grants in AWS KMS nella AWS Key Management Service Developer Guide.

Per ottenere i nomi delle politiche chiave per una chiave KMS

L'list-key-policiesesempio seguente ottiene i nomi delle politiche chiave per una chiave gestita dal cliente nell'account e nella regione di esempio. È possibile utilizzare questo comando per trovare i nomi delle politiche chiave per le chiavi AWS gestite e le chiavi gestite dal cliente.

Poiché l'unico nome di policy chiave valido èdefault, questo comando non è utile.

Per specificare la chiave KMS, usa il key-id parametro. Questo esempio utilizza un valore ID chiave, ma è possibile utilizzare un ID chiave o un ARN di chiave in questo comando.

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

Output:

{
    "PolicyNames": [
    "default"
    ]
}

Per ulteriori informazioni sulle politiche chiave AWS KMS, consulta Using Key Policies in AWS KMS nella AWS Key Management Service Developer Guide.

Per recuperare informazioni su tutte le rotazioni dei materiali chiave completate

L'list-key-rotationsesempio seguente elenca le informazioni su tutte le rotazioni del materiale chiave completate per la chiave KMS specificata.

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

Output:

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

Per ulteriori informazioni, consulta Rotating keys nella AWS Key Management Service Developer Guide.

Per ottenere le chiavi KMS in un account e in una regione

L'list-keysesempio seguente ottiene le chiavi KMS in un account e in una regione. Questo comando restituisce sia le chiavi AWS gestite che le chiavi gestite dal cliente.

aws kms list-keys

Output:

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

Per ulteriori informazioni, vedere Viewing Keys nella AWS Key Management Service Developer Guide.

Per ottenere i tag su una chiave KMS

L'list-resource-tagsesempio seguente ottiene i tag per una chiave KMS. Per aggiungere o sostituire i tag di risorsa sulle chiavi KMS, usa il tag-resource comando. L'output mostra che questa chiave KMS ha due tag di risorsa, ognuno dei quali ha una chiave e un valore.

Per specificare la chiave KMS, usa il key-id parametro. Questo esempio utilizza un valore ID chiave, ma è possibile utilizzare un ID chiave o un ARN di chiave in questo comando.

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

Output:

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

Per ulteriori informazioni sull'utilizzo dei tag in AWS KMS, consulta Tagging keys nella AWS Key Management Service Developer Guide.

Per visualizzare le sovvenzioni che un preside può concedere in pensione

L'list-retirable-grantsesempio seguente mostra tutte le sovvenzioni che l'ExampleAdminutente può ritirare con le chiavi KMS in un account e in una regione. AWS Puoi usare un comando come questo per visualizzare le concessioni che qualsiasi titolare dell'account può ritirare sulle chiavi KMS nell'account e nella regione. AWS

Il valore del retiring-principal parametro richiesto deve essere l'Amazon Resource Name (ARN) di un account, utente o ruolo.

Non è possibile specificare un servizio per il valore di retiring-principal in questo comando, anche se un servizio può essere il principale ritirante. Per trovare le concessioni in cui un particolare servizio è il principale ritirante, usa il comando. list-grants

L'output mostra che ExampleAdmin l'utente è autorizzato a ritirare le concessioni su due diverse chiavi KMS nell'account e nella regione. Oltre al titolare uscente, l'account è autorizzato a ritirare qualsiasi sovvenzione contenuta nell'account.

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

Output:

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

Per ulteriori informazioni, consulta Grants in AWS KMS nella AWS Key Management Service Developer Guide.

Per modificare la politica chiave per una chiave KMS

L'put-key-policyesempio seguente modifica la politica chiave per una chiave gestita dal cliente.

Per iniziare, create una policy chiave e salvatela in un file JSON locale. In questo esempio, il file èkey_policy.json. È inoltre possibile specificare la politica chiave come valore di stringa del policy parametro.

La prima dichiarazione di questa politica chiave fornisce all' AWS account l'autorizzazione a utilizzare le politiche IAM per controllare l'accesso alla chiave KMS. La seconda istruzione fornisce test-user all'utente il permesso di eseguire i list-keys comandi describe-key and sulla chiave KMS.

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

Per identificare la chiave KMS, questo esempio utilizza l'ID chiave, ma puoi anche usare una chiave ARN. Per specificare la politica della chiave, il comando utilizza il policy parametro. Per indicare che la politica è contenuta in un file, utilizza il file:// prefisso richiesto. Questo prefisso è necessario per identificare i file su tutti i sistemi operativi supportati. Infine, il comando utilizza il policy-name parametro con un valore didefault. Se non viene specificato alcun nome di policy, il valore predefinito èdefault. L'unico valore valido è default.

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

Il comando non produce output. Per verificare che il comando sia stato efficace, utilizzare il get-key-policy comando. Il comando di esempio seguente ottiene la politica chiave per la stessa chiave KMS. Il output parametro con un valore di text restituisce un formato di testo facile da leggere.

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

Output:

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

Per ulteriori informazioni, vedere Modifica di una politica AWS chiave nella Key Management Service Developer Guide.

Esempio 1: ricrittografare un messaggio crittografato con una chiave KMS simmetrica diversa (Linux e macOS).

L'esempio di re-encrypt comando seguente mostra il metodo consigliato per ricrittografare i dati con la CLI. AWS

Fornisci il testo cifrato in un file. Nel valore del --ciphertext-blob parametro, usa il fileb:// prefisso, che indica alla CLI di leggere i dati da un file binario. Se il file non si trova nella directory corrente, digitate il percorso completo del file. Per ulteriori informazioni sulla lettura dei valori dei parametri AWS CLI da un file, consulta Caricamento dei parametri AWS CLI da un file nella Guida per l'utente dell'interfaccia a riga di AWS comando e Best Practices for Local File Parameters nel Command Line Tool Blog .Specificare la AWS chiave KMS di origine, che decrittografa il CipherText. Il parametro non è richiesto quando si decrittografa con chiavi KMS di crittografia simmetrica. --source-key-id AWS KMS può ottenere la chiave KMS utilizzata per crittografare i dati dai metadati nel blob di testo cifrato. Tuttavia è sempre consigliabile specificare la chiave KMS che stai utilizzando. Questa pratica garantisce l'utilizzo della chiave KMS desiderata e impedisce di decrittografare inavvertitamente un testo cifrato utilizzando una chiave KMS non attendibile.Specificate la chiave KMS di destinazione, che cripta nuovamente i dati.Il parametro è sempre obbligatorio. --destination-key-id Questo esempio utilizza una chiave ARN, ma è possibile utilizzare qualsiasi identificatore di chiave valido. Richiedere l'output in chiaro come valore di testo. Il parametro --query indica alla CLI di ottenere solo il valore del campo dall'output. Plaintext Il --output parametro restituisce l'output come text.base64: decodifica il testo semplice e lo salva in un file. L'esempio seguente invia (|) il valore del Plaintext parametro all'utilità Base64, che lo decodifica. Quindi, reindirizza (>) l'output decodificato al file. ExamplePlaintext

Prima di eseguire questo comando, sostituisci la chiave di esempio IDs con identificatori di chiave validi del tuo account. AWS

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

Questo comando non produce alcun output. L'output del re-encrypt comando viene decodificato in base64 e salvato in un file.

Per ulteriori informazioni, vedere ReEncryptnel AWS Key Management Service API Reference.

Esempio 2: Per crittografare nuovamente un messaggio crittografato con una chiave KMS simmetrica diversa (prompt dei comandi di Windows).

Il seguente esempio di re-encrypt comando è lo stesso del precedente, tranne per il fatto che utilizza l'certutilutilità per decodificare in Base64 i dati in chiaro. Questa procedura richiede due comandi, come illustrato negli esempi seguenti.

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account.

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

Quindi usa l'certutilutilità

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Output:

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

Per ulteriori informazioni, consulta la ReEncryptsezione AWS Key Management Service API Reference.

Ritirare una sovvenzione relativa a una chiave master del cliente

L'retire-grantesempio seguente elimina una concessione da una chiave KMS.

Il comando di esempio seguente specifica i parametri grant-id e. key-id Il valore del key-id parametro deve essere la chiave ARN della chiave KMS.

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

Questo comando non produce alcun output. Per confermare che la concessione è stata ritirata, usa il comando. list-grants

Per ulteriori informazioni, consulta Ritiro e revoca delle sovvenzioni nella AWS Key Management Service Developer Guide.

Per revocare una concessione su una chiave master del cliente

L'revoke-grantesempio seguente elimina una concessione da una chiave KMS. Il comando di esempio seguente specifica i parametri grant-id e. key-id Il valore del key-id parametro può essere l'ID della chiave o l'ARN della chiave KMS.

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

Questo comando non produce alcun output. Per confermare che la concessione è stata revocata, usa il comando. list-grants

Per ulteriori informazioni, consulta Ritiro e revoca delle sovvenzioni nella AWS Key Management Service Developer Guide.

Per eseguire la rotazione su richiesta di una chiave KMS

L'rotate-key-on-demandesempio seguente avvia immediatamente la rotazione del materiale chiave per la chiave KMS specificata.

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

Output:

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

Per ulteriori informazioni, vedere Come eseguire la rotazione delle chiavi su richiesta nella AWS Key Management Service Developer Guide.

Per pianificare l'eliminazione di una chiave KMS gestita dal cliente.

L'schedule-key-deletionesempio seguente pianifica l'eliminazione della chiave KMS gestita dal cliente specificata in 15 giorni.

Il --key-id parametro identifica la chiave KMS. Questo esempio utilizza un valore ARN chiave, ma è possibile utilizzare l'ID chiave o l'ARN della chiave KMS. Il --pending-window-in-days parametro specifica la durata del periodo di attesa di 7-30 giorni. Per impostazione predefinita, il periodo di attesa è di 30 giorni. Questo esempio specifica il valore 15, che indica di AWS eliminare definitivamente la chiave KMS 15 giorni dopo il completamento del 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

La risposta include l'ARN della chiave, lo stato della chiave, il periodo di attesa (PendingWindowInDays) e la data di eliminazione in ora Unix. Per visualizzare la data di cancellazione nell'ora locale, usa la console AWS KMS. Le chiavi KMS nello stato della PendingDeletion chiave non possono essere utilizzate nelle operazioni crittografiche.

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

Per ulteriori informazioni, consulta Eliminazione delle chiavi nella AWS Key Management Service Developer Guide.

Esempio 1: generare una firma digitale per un messaggio

L'signesempio seguente genera una firma crittografica per un breve messaggio. L'output del comando include un Signature campo codificato in base 64 che è possibile verificare utilizzando il comando. verify

È necessario specificare un messaggio da firmare e un algoritmo di firma supportato dalla chiave KMS asimmetrica. Per ottenere gli algoritmi di firma per la tua chiave KMS, usa il comando. describe-key

In AWS CLI v2, il valore del message parametro deve essere codificato in Base64. In alternativa, puoi salvare il messaggio in un file e utilizzare il fileb:// prefisso, che indica alla AWS CLI di leggere i dati binari dal file.

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account. L'ID della chiave deve rappresentare una chiave KMS asimmetrica con un utilizzo chiave di 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

Output:

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

Per ulteriori informazioni sull'utilizzo delle chiavi KMS asimmetriche in KMS, consulta Chiavi asimmetriche in KMS nella AWS Key Management Service Developer Guide. AWS AWS

Esempio 2: salvare una firma digitale in un file (Linux e macOS)

L'signesempio seguente genera una firma crittografica per un breve messaggio memorizzato in un file locale. Il comando ottiene anche la Signature proprietà dalla risposta, Base64-la decodifica e la salva nel file. ExampleSignature È possibile utilizzare il file della firma in un verify comando che verifica la firma.

Il sign comando richiede un messaggio con codifica Base64 e un algoritmo di firma supportato dalla chiave KMS asimmetrica. Per ottenere gli algoritmi di firma supportati dalla tua chiave KMS, usa il comando. describe-key

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account. L'ID della chiave deve rappresentare una chiave KMS asimmetrica con un utilizzo chiave di 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

Questo comando non produce alcun output. Questo esempio estrae la Signature proprietà dell'output e la salva in un file.

Per ulteriori informazioni sull'utilizzo delle chiavi KMS asimmetriche in KMS, consulta le chiavi asimmetriche in AWS KMS nella AWS Key Management Service Developer Guide.AWS

Per aggiungere un tag a una chiave KMS

L'tag-resourceesempio seguente aggiunge "Purpose":"Test" e "Dept":"IT" contrassegna una chiave KMS gestita dal cliente. Puoi utilizzare tag come questi per etichettare le chiavi KMS e creare categorie di chiavi KMS per le autorizzazioni e il controllo.

Per specificare la chiave KMS, usa il parametro. key-id Questo esempio utilizza un valore ID chiave, ma è possibile utilizzare un ID chiave o un ARN di chiave in questo comando.

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

Questo comando non produce alcun output. Per visualizzare i tag su una chiave AWS KMS KMS, usa il comando. list-resource-tags

Per ulteriori informazioni sull'utilizzo dei tag in AWS KMS, consulta Tagging keys nella AWS Key Management Service Developer Guide.

Per eliminare un tag da una chiave KMS

L'untag-resourceesempio seguente elimina il tag con la "Purpose" chiave da una chiave KMS gestita dal cliente.

Per specificare la chiave KMS, utilizza il parametro. key-id Questo esempio utilizza un valore ID chiave, ma è possibile utilizzare un ID chiave o un ARN di chiave in questo comando. Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account.

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

Questo comando non produce alcun output. Per visualizzare i tag su una chiave AWS KMS KMS, usa il list-resource-tags comando.

Per ulteriori informazioni sull'utilizzo dei tag in AWS KMS, consulta Tagging keys nella AWS Key Management Service Developer Guide.

Per associare un alias a una chiave KMS diversa

L'update-aliasesempio seguente associa l'alias a una chiave alias/test-key KMS diversa.

Il --alias-name parametro specifica l'alias. Il valore del nome alias deve iniziare con alias/ .Il --target-key-id parametro specifica la chiave KMS da associare all'alias. Non è necessario specificare la chiave KMS corrente per l'alias.

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

Questo comando non produce alcun output. Per trovare l'alias, usa il comando. list-aliases

Per ulteriori informazioni, vedere Aggiornamento degli alias nella AWS Key Management Service Developer Guide.

Esempio 1: modificare il nome descrittivo di un archivio di chiavi personalizzato

L'update-custom-key-storeesempio seguente modifica il nome dell'archivio chiavi personalizzato. Questo esempio funziona per un key store AWS CloudHSM o un key store esterno.

Usa il custom-key-store-id per identificare l'archivio delle chiavi. Utilizzate il new-custom-key-store-name parametro per specificare il nuovo nome descrittivo.

Per aggiornare il nome descrittivo di un AWS key store CloudHSM, devi prima disconnetterlo, ad esempio usando il comando. disconnect-custom-key-store È possibile aggiornare il nome descrittivo di un archivio di chiavi esterno mentre è connesso o disconnesso. Per trovare lo stato di connessione del tuo archivio chiavi personalizzato, usa il describe-custom-key-store comando.

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

Questo comando non restituisce alcun dato. Per verificare che il comando abbia funzionato, usa un describe-custom-key-stores comando.

Per ulteriori informazioni sull'aggiornamento di un key store AWS CloudHSM, consulta Modifica delle impostazioni del key store di AWS CloudHSM nella Key Management Service Developer Guide.AWS

Per ulteriori informazioni sull'aggiornamento di un archivio di chiavi esterno, consulta Modifica delle proprietà dell'archivio di chiavi esterne nella AWS Key Management Service Developer Guide.

Esempio 2: modificare la password kmsuser di un key store AWS CloudHSM

L'update-custom-key-storeesempio seguente aggiorna il valore della kmsuser password con la password corrente per il kmsuser cluster CloudHSM associato all'archivio di chiavi specificato. Questo comando non modifica la kmsuser password del cluster. Indica solo a AWS KMS la password corrente. Se KMS non dispone della kmsuser password corrente, non può connettersi al key store di AWS CloudHSM.

NOTA: prima di aggiornare un key store AWS CloudHSM, è necessario disconnetterlo. Utilizza il comando disconnect-custom-key-store. Una volta completato il comando, puoi ricollegare l'archivio di chiavi CloudHSM AWS . Utilizza il comando connect-custom-key-store.

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

Questo comando non restituisce alcun output. Per verificare che la modifica sia stata effettiva, utilizzate un comando. describe-custom-key-stores

Per ulteriori informazioni sull'aggiornamento di un key store AWS CloudHSM, consulta Modifica delle impostazioni del key store di AWS CloudHSM nella Key Management Service Developer Guide.AWS

Esempio 3: modificare il cluster AWS CloudHSM di un AWS key store CloudHSM

L'esempio seguente modifica il cluster AWS CloudHSM associato a un key store AWS CloudHSM in un cluster correlato, ad esempio un backup diverso dello stesso cluster.

NOTA: prima di aggiornare un key store AWS CloudHSM, è necessario disconnetterlo. Utilizza il comando disconnect-custom-key-store. Una volta completato il comando, puoi ricollegare l'archivio di chiavi CloudHSM AWS . Utilizza il comando connect-custom-key-store.

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

Questo comando non restituisce alcun output. Per verificare che la modifica sia stata effettiva, utilizzate un comando. describe-custom-key-stores

Per ulteriori informazioni sull'aggiornamento di un key store AWS CloudHSM, consulta Modifica delle impostazioni del key store di AWS CloudHSM nella Key Management Service Developer Guide.AWS

Esempio 4: per modificare le credenziali di autenticazione proxy di un archivio di chiavi esterno

L'esempio seguente aggiorna le credenziali di autenticazione proxy per l'archivio di chiavi esterno. È necessario specificare raw-secret-access-key sia il cheaccess-key-id, anche se si sta modificando solo uno dei valori. È possibile utilizzare questa funzionalità per correggere una credenziale non valida o per modificare la credenziale quando il proxy dell'archivio chiavi esterno la ruota.

Stabilisci le credenziali di autenticazione proxy per AWS KMS sul tuo archivio di chiavi esterno. Quindi usa questo comando per fornire la credenziale a KMS. AWS AWS KMS utilizza questa credenziale per firmare le sue richieste al proxy di archiviazione delle chiavi esterno.

Puoi aggiornare le credenziali di autenticazione del proxy mentre l'archivio chiavi esterno è connesso o disconnesso. Per trovare lo stato di connessione del tuo archivio chiavi personalizzato, usa il 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="

Questo comando non restituisce alcun output. Per verificare che la modifica sia stata effettiva, utilizzate un describe-custom-key-stores comando.

Per ulteriori informazioni sull'aggiornamento di un archivio di chiavi esterno, vedere Modifica delle proprietà dell'archivio chiavi esterno nella AWS Key Management Service Developer Guide.

Esempio 5: per modificare la connettività proxy di un archivio di chiavi esterno

L'esempio seguente modifica l'opzione di connettività proxy dell'archivio chiavi esterno dalla connettività degli endpoint pubblici alla connettività del servizio endpoint VPC. Oltre a modificare il xks-proxy-connectivity valore, è necessario modificare il xks-proxy-uri-endpoint valore in modo che rifletta il nome DNS privato associato al servizio endpoint VPC. È inoltre necessario aggiungere un valore. xks-proxy-vpc-endpoint-service-name

NOTA: prima di aggiornare la connettività proxy di un archivio esterno, è necessario disconnetterlo. Utilizza il comando disconnect-custom-key-store. Al termine del comando, è possibile ricollegare l'archivio di chiavi esterno utilizzando il comando. connect-custom-key-store

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

Questo comando non restituisce alcun output. Per verificare che la modifica sia stata effettiva, utilizzate un describe-custom-key-stores comando.

Per ulteriori informazioni sull'aggiornamento di un archivio di chiavi esterno, vedere Modifica delle proprietà dell'archivio chiavi esterno nella AWS Key Management Service Developer Guide.

Esempio 1: aggiungere o modificare una descrizione a una chiave KMS gestita dal cliente

L'update-key-descriptionesempio seguente aggiunge una descrizione a una chiave KMS gestita dal cliente. È possibile utilizzare lo stesso comando per modificare una descrizione esistente.

Il --key-id parametro identifica la chiave KMS nel comando. Questo esempio utilizza un valore ARN della chiave, ma è possibile utilizzare l'ID chiave o l'ARN della chiave KMS. Il parametro specifica la nuova descrizione. --description Il valore di questo parametro sostituisce l'eventuale descrizione corrente della chiave KMS.

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"

Questo comando non produce alcun output. Per visualizzare la descrizione di una chiave KMS, usa il comando. describe-key

Per ulteriori informazioni, consulta UpdateKeyDescriptionla sezione AWS Key Management Service API Reference.

Esempio 2: eliminare la descrizione di una chiave KMS gestita dal cliente

L'update-key-descriptionesempio seguente elimina la descrizione di una chiave KMS gestita dal cliente.

Il --key-id parametro identifica la chiave KMS nel comando. Questo esempio utilizza un valore ID chiave, ma è possibile utilizzare l'ID chiave o l'ARN della chiave KMS. Il --description parametro con un valore di stringa vuoto («) elimina la descrizione esistente.

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

Questo comando non produce alcun output. Per visualizzare la descrizione di una chiave KMS, usa il comando describe-key.

Per ulteriori informazioni, consulta la sezione AWS Key Management UpdateKeyDescriptionService API Reference.

Esempio 1: per verificare un HMAC

Il verify-mac comando seguente verifica un HMAC per un particolare messaggio, le chiavi HMAC KMS e l'algoritmo MAC. Un valore «true» nel MacValid valore della risposta indica che l'HMAC è valido.

In AWS CLI v2, il valore del message parametro deve essere codificato in Base64. In alternativa, puoi salvare il messaggio in un file e utilizzare il fileb:// prefisso, che indica alla AWS CLI di leggere i dati binari dal file.

Il MAC specificato non può essere codificato in base 64. Per informazioni sulla decodifica del MAC restituito dal generate-mac comando, consultate gli esempi di comandi. generate-mac

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account. L'ID chiave deve rappresentare una chiave KMS HMAC con un utilizzo chiave di. GENERATE_VERIFY_MAC

msg=(echo 'Hello World' | base64)

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

Output:

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

Per ulteriori informazioni sull'utilizzo delle chiavi HMAC KMS in KMS, consulta le chiavi HMAC in AWS KMS nella AWS Key Management Service Developer Guide.AWS

Per verificare una firma digitale

Il verify comando seguente verifica una firma crittografica per un breve messaggio con codifica Base64. L'ID della chiave, il messaggio, il tipo di messaggio e l'algoritmo di firma devono essere gli stessi utilizzati per firmare il messaggio.

In AWS CLI v2, il valore del message parametro deve essere codificato in Base64. In alternativa, puoi salvare il messaggio in un file e utilizzare il fileb:// prefisso, che indica alla AWS CLI di leggere i dati binari dal file.

La firma specificata non può essere codificata in base 64. Per informazioni sulla decodifica della firma restituita dal comando, consultate gli esempi di sign comandi. sign

L'output del comando include un SignatureValid campo booleano che indica che la firma è stata verificata. Se la convalida della firma fallisce, anche il verify comando fallisce.

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account.

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

Output:

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

Per ulteriori informazioni sull'utilizzo delle chiavi KMS asimmetriche in AWS KMS, consulta Using asimmetric keys nella Key Management Service Developer Guide.AWS