Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# AWS KMS Beispiele mit AWS CLI
Die folgenden Codebeispiele zeigen Ihnen, wie Sie mithilfe von AWS Command Line Interface with Aktionen ausführen und allgemeine Szenarien implementieren AWS KMS.
*Aktionen* sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.
Jedes Beispiel enthält einen Link zum vollständigen Quellcode, wo Sie Anweisungen zum Einrichten und Ausführen des Codes im Kodex finden.
**Topics**
+ [Aktionen](#actions)
## Aktionen
### `cancel-key-deletion`
Das folgende Codebeispiel zeigt, wie Sie`cancel-key-deletion`.
**AWS CLI**
**So brechen Sie die geplante Löschung eines kundenseitig verwalteten Schlüssels ab**
Im folgenden Beispiel für `cancel-key-deletion` wird die geplante Löschung eines kundenseitig verwalteten KMS-Schlüssels abgebrochen.
```
aws kms cancel-key-deletion \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"KeyId": "arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}
```
Wenn der `cancel-key-deletion`-Befehl erfolgreich ist, wird das geplante Löschen abgebrochen. Der Schlüsselstatus des KMS-Schlüssels ist jedoch `Disabled`, sodass Sie den KMS-Schlüssel nicht in kryptografischen Vorgängen verwenden können. Verwenden Sie den `enable-key`-Befehl, um die Funktionalität wiederherzustellen.
Weitere Informationen finden Sie unter [Planen und Abbrechen des Löschens von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/deleting-keys.html#deleting-keys-scheduling-key-deletion) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [CancelKeyDeletion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/cancel-key-deletion.html)in der *AWS CLI Befehlsreferenz*.
### `connect-custom-key-store`
Das folgende Codebeispiel zeigt die Verwendung`connect-custom-key-store`.
**AWS CLI**
**So stellen Sie eine Verbindung zu einem benutzerdefinierten Schlüsselspeicher her**
Im folgenden Beispiel für `connect-custom-key-store` wird die Verbindung zum angegebenen benutzerdefinierten Schlüsselspeicher erneut hergestellt. Sie können einen Befehl wie diesen zur erstmaligen Herstellung einer Verbindung zu einem benutzerdefinierten Schlüsselspeicher oder zur erneuten Verbindung eines getrennten Schlüsselspeicher verwenden.
Sie können diesen Befehl verwenden, um einen AWS CloudHSM-Schlüsselspeicher oder einen externen Schlüsselspeicher zu verbinden.
```
aws kms connect-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0
```
Dieser Befehl gibt keine Ausgabe zurück. Verwenden Sie den Befehl `describe-custom-key-stores`, um zu überprüfen, ob der Befehl wirksam war.
*Informationen zum Verbinden eines AWS CloudHSM-Schlüsselspeichers finden Sie unter [Verbinden und Trennen eines AWS CloudHSM-Schlüsselspeichers im Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/disconnect-keystore.html) Developer Guide AWS .*
*Informationen zum Herstellen einer Verbindung zu einem externen Schlüsselspeicher finden Sie unter [Herstellen und Trennen der Verbindung zu einem externen Schlüsselspeicher](https://docs.aws.amazon.com/kms/latest/developerguide/xks-connect-disconnect.html) im Entwicklerhandbuch für AWS Key Management Service*.
+ *Einzelheiten zur API finden Sie in der Befehlsreferenz. [ConnectCustomKeyStore](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/connect-custom-key-store.html)AWS CLI *
### `create-alias`
Das folgende Codebeispiel zeigt die Verwendung`create-alias`.
**AWS CLI**
**So erstellen Sie einen Alias für einen KMS-Schlüssel**
Der folgende `create-alias`-Befehl erstellt einen Alias namens `example-alias` für den KMS-Schlüssel, der durch die Schlüssel-ID `1234abcd-12ab-34cd-56ef-1234567890ab` identifiziert wird.
Aliasnamen müssen mit `alias/` beginnen. Verwenden Sie keine Aliasnamen, die mit `alias/aws` beginnen. Diese sind für die Verwendung durch reserviert AWS.
```
aws kms create-alias \
--alias-name alias/example-alias \
--target-key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Dieser Befehl gibt keine Ausgabe zurück. Verwenden Sie den Befehl `list-aliases`, um den neuen Alias anzuzeigen.
Weitere Informationen finden Sie unter [Verwenden von Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [CreateAlias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/create-alias.html)in der *AWS CLI Befehlsreferenz*.
### `create-custom-key-store`
Das folgende Codebeispiel zeigt die Verwendung`create-custom-key-store`.
**AWS CLI**
**Beispiel 1: So erstellen Sie einen AWS CloudHSM-Schlüsselspeicher**
Im folgenden `create-custom-key-store` Beispiel wird mithilfe der erforderlichen Parameter ein AWS CloudHSM-Schlüsselspeicher erstellt, der von einem AWS CloudHSM-Cluster unterstützt wird. Sie können auch `custom-key-store-type``parameter with the default value: ``AWS_CLOUDHSM` hinzufügen.
Um die Dateieingabe für den `trust-anchor-certificate` Befehl in der AWS CLI anzugeben, ist das `file://` Präfix erforderlich.
```
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
```
Ausgabe:
```
{
"CustomKeyStoreId": cks-1234567890abcdef0
}
```
Weitere Informationen finden Sie unter [Erstellen eines AWS CloudHSM-Schlüsselspeichers im AWS Key](https://docs.aws.amazon.com/kms/latest/developerguide/create-keystore.html) *Management Service Developer Guide*.
**Beispiel 2: So erstellen Sie einen externen Schlüsselspeicher mit der Konnektivität eines öffentlichen Endpunkts**
Im folgenden `create-custom-key-store` Beispiel wird ein externer Schlüsselspeicher (XKS) erstellt, der mit AWS KMS über das Internet kommuniziert.
In diesem Beispiel verwendet der `XksProxyUriPath` das optionale Präfix `example-prefix`.
HINWEIS: Wenn Sie AWS CLI Version 1.0 verwenden, führen Sie den folgenden Befehl aus, bevor Sie einen Parameter mit einem HTTP- oder HTTPS-Wert angeben, z. B. den XksProxyUriEndpoint Parameter.
```
aws configure set cli_follow_urlparam false
```
Andernfalls ersetzt AWS CLI Version 1.0 den Parameterwert durch den Inhalt, der an dieser URI-Adresse gefunden wurde.
```
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="
```
Ausgabe:
```
{
"CustomKeyStoreId": cks-2234567890abcdef0
}
```
Weitere Informationen finden Sie unter [Erstellen eines externen Schlüsselspeichers](https://docs.aws.amazon.com/kms/latest/developerguide/create-keystorecreate-xks-keystore.html) im *Entwicklerhandbuch für AWS Key Management Service*.
**Beispiel 3: So erstellen Sie einen externen Schlüsselspeicher mit der Konnektivität eines VPC-Endpunkt-Service**
Im folgenden `create-custom-key-store` Beispiel wird ein externer Schlüsselspeicher (XKS) erstellt, der einen Amazon VPC-Endpunktservice für die Kommunikation mit AWS KMS verwendet.
HINWEIS: Wenn Sie AWS CLI Version 1.0 verwenden, führen Sie den folgenden Befehl aus, bevor Sie einen Parameter mit einem HTTP- oder HTTPS-Wert angeben, z. B. den XksProxyUriEndpoint Parameter.
```
aws configure set cli_follow_urlparam false
```
Andernfalls ersetzt AWS CLI Version 1.0 den Parameterwert durch den Inhalt, der an dieser URI-Adresse gefunden wurde.
```
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="
```
Ausgabe:
```
{
"CustomKeyStoreId": cks-3234567890abcdef0
}
```
Weitere Informationen finden Sie unter [Erstellen eines externen Schlüsselspeichers](https://docs.aws.amazon.com/kms/latest/developerguide/create-keystorecreate-xks-keystore.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [CreateCustomKeyStore](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/create-custom-key-store.html)unter *AWS CLI Befehlsreferenz*.
### `create-grant`
Das folgende Codebeispiel zeigt die Verwendung`create-grant`.
**AWS CLI**
**So erstellen Sie eine Erteilung**
Im folgenden Beispiel für `create-grant` wird eine Erteilung erstellt, die dem Benutzer `exampleUser` die Verwendung des Befehls `decrypt` im Beispiel-KMS-Schlüssel `1234abcd-12ab-34cd-56ef-1234567890ab` ermöglicht. Der zurückziehende Prinzipal ist die `adminRole`-Rolle. Die Erteilung verwendet die Erteilungseinschränkung `EncryptionContextSubset`, um diese Berechtigung nur dann zuzulassen, wenn der Verschlüsselungskontext in der Anforderung `decrypt` das Verschlüsselungskontextpaar `"Department": "IT"` enthält.
```
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
```
Ausgabe:
```
{
"GrantId": "1a2b3c4d2f5e69f440bae30eaec9570bb1fb7358824f9ddfa1aa5a0dab1a59b2",
"GrantToken": ""
}
```
Verwenden Sie zum Anzeigen detaillierter Informationen zur Erteilung den Befehl `list-grants`.
Weitere Informationen finden Sie unter [Grants in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [CreateGrant](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/create-grant.html)in der *AWS CLI Befehlsreferenz*.
### `create-key`
Das folgende Codebeispiel zeigt die Verwendung`create-key`.
**AWS CLI**
**Beispiel 1: Um einen vom Kunden verwalteten KMS-Schlüssel in AWS KMS zu erstellen**
Im folgenden Beispiel für `create-key` wird ein KMS-Schlüssel für die symmetrische Verschlüsselung erstellt.
Zum Erstellen des grundlegenden KMS-Schlüssels, einem symmetrischen Verschlüsselungsschlüssel, müssen Sie keine Parameter angeben. Die Standardwerte für diese Parameter erstellen einen symmetrischen Verschlüsselungsschlüssel.
Da dieser Befehl keine Schlüsselrichtlinie angibt, erhält der KMS-Schlüssel die [Standardschlüsselrichtlinie](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default) für KMS-Schlüssel, die programmgesteuert erstellt werden. Verwenden Sie den Befehl `get-key-policy`, um die Schlüsselrichtlinie anzuzeigen. Verwenden Sie den Befehl `put-key-policy`, um die Schlüsselrichtlinie zu ändern.
```
aws kms create-key
```
Der Befehl `create-key` gibt die wichtigsten Metadaten zurück, einschließlich der Schlüssel-ID und des ARN des neuen KMS-Schlüssels. Sie können diese Werte verwenden, um den KMS-Schlüssel in anderen AWS KMS-Vorgängen zu identifizieren. Die Ausgabe enthält keine Tags. Verwenden Sie den `list-resource-tags command`, um die Tags für einen KMS-Schlüssel anzuzeigen.
Ausgabe:
```
{
"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"
]
}
}
```
Hinweis: Mit dem Befehl `create-key` können Sie keinen Alias angeben. Verwenden Sie den Befehl `create-alias`, um einen Alias für den neuen KMS-Schlüssel zu erstellen.
Weitere Informationen finden Sie unter [Erstellen von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
**Beispiel 2: So erstellen Sie einen asymmetrischen RSA-KMS-Schlüssel für die Verschlüsselung und Entschlüsselung**
Im folgenden Beispiel für `create-key` wird ein KMS-Schlüssel erstellt, der ein asymmetrisches RSA-Schlüsselpaar für die Verschlüsselung und Entschlüsselung enthält. Die Schlüsselspezifikation und -verwendung können nach dem Erstellen des Schlüssels nicht geändert werden.
```
aws kms create-key \
--key-spec RSA_4096 \
--key-usage ENCRYPT_DECRYPT
```
Ausgabe:
```
{
"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"
}
}
```
Weitere Informationen finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 3: So erstellen Sie einen KMS-Schlüssel mit asymmetrischer Elliptic-Curve für die Signatur und Verifizierung**
Um einen asymmetrischen KMS-Schlüssel zu erstellen, der ein asymmetrisches Schlüsselpaar mit elliptischer Kurve (ECC) für Signatur und Verifizierung enthält. Der Parameter `--key-usage` ist erforderlich, obwohl `SIGN_VERIFY` der einzig gültige Wert für ECC-KMS-Schlüssel ist. Die Schlüsselspezifikation und -verwendung können nach dem Erstellen des Schlüssels nicht geändert werden.
```
aws kms create-key \
--key-spec ECC_NIST_P521 \
--key-usage SIGN_VERIFY
```
Ausgabe:
```
{
"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"
]
}
}
```
Weitere Informationen finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 4: So erstellen Sie einen asymmetrischen ML-DSA-KMS-Schlüssel für Signatur und Verifizierung**
In diesem Beispiel wird ein ML-DSA-Schlüssel (Module-Lattice Digital Signature Algorithm) für Signatur und Verifizierung erstellt. Der Schlüsselnutzungsparameter ist erforderlich, obwohl `SIGN_VERIFY` der einzig gültige Wert für ML-DSA-Schlüssel ist.
```
aws kms create-key \
--key-spec ML_DSA_65 \
--key-usage SIGN_VERIFY
```
Ausgabe:
```
{
"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"
]
}
}
```
Weitere Informationen finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 5: So erstellen Sie einen HMAC-KMS-Schlüssel**
Im folgenden Beispiel für `create-key` wird ein HMAC-KMS-Schlüssel von 384 Bit erstellt. Der Wert `GENERATE_VERIFY_MAC` für den Parameter `--key-usage` ist erforderlich, obwohl er der einzig gültige Wert für HMAC-KMS-Schlüssel ist.
```
aws kms create-key \
--key-spec HMAC_384 \
--key-usage GENERATE_VERIFY_MAC
```
Ausgabe:
```
{
"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"
}
}
```
Weitere Informationen finden Sie unter [HMAC-Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/hmac.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 6: So erstellen Sie einen multiregionalen KMS-Schlüssel**
Im folgenden Beispiel für `create-key` wird ein multiregionaler Primärschlüssel erstellt. Da die Standardwerte für alle Parameter einen symmetrischen Verschlüsselungsschlüssel erzeugen, ist nur der Parameter `--multi-region` für diesen KMS-Schlüssel erforderlich. Um in der AWS CLI anzugeben, dass ein boolescher Parameter wahr ist, geben Sie einfach den Parameternamen an.
```
aws kms create-key \
--multi-region
```
Ausgabe:
```
{
"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"
}
}
```
Weitere Informationen finden Sie unter [Asymmetrische Schlüssel in AWS KMS im AWS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) *Key Management Service* Developer Guide.
**Beispiel 7: So erstellen Sie einen KMS-Schlüssel für importiertes Schlüsselmaterial**
Im folgenden Beispiel für `create-key` wird ein KMS-Schlüssel ohne Schlüsselmaterial erstellt. Wenn der Vorgang abgeschlossen ist, können Sie Ihr eigenes Schlüsselmaterial in den KMS-Schlüssel importieren. Um diesen KMS-Schlüssel zu erstellen, legen Sie den Parameter `--origin` auf `EXTERNAL` fest.
```
aws kms create-key \
--origin EXTERNAL
```
Ausgabe:
```
{
"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"
}
}
```
Weitere Informationen finden Sie unter [Importieren von Schlüsselmaterial in AWS KMS-Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 6: So erstellen Sie einen KMS-Schlüssel in einem AWS CloudHSM-Schlüsselspeicher**
Das folgende `create-key` Beispiel erstellt einen KMS-Schlüssel im angegebenen AWS CloudHSM-Schlüsselspeicher. Der Vorgang erstellt den KMS-Schlüssel und seine Metadaten in AWS KMS und erstellt das Schlüsselmaterial im AWS CloudHSM-Cluster, der dem benutzerdefinierten Schlüsselspeicher zugeordnet ist. Die Parameter `--custom-key-store-id` und `--origin` müssen angegeben werden.
```
aws kms create-key \
--origin AWS_CLOUDHSM \
--custom-key-store-id cks-1234567890abcdef0
```
Ausgabe:
```
{
"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"
}
}
```
Weitere Informationen finden Sie unter [AWS -CloudHSM-Schlüsselspeicher](https://docs.aws.amazon.com/kms/latest/developerguide/keystore-cloudhsm.html) im *Entwicklerhandbuch für AWS Key Management Service*.
**Beispiel 8: So erstellen Sie einen KMS-Schlüssel in einem externen Schlüsselspeicher**
Im folgenden Beispiel für `create-key` wird ein KMS-Schlüssel im angegebenen externen Schlüsselspeicher erstellt. Die Parameter `--custom-key-store-id`, `--origin` und `--xks-key-id` sind in diesem Befehl erforderlich.
Der Parameter `--xks-key-id` gibt die ID eines vorhandenen symmetrischen Verschlüsselungsschlüssels in Ihrem externen Schlüsselmanager an. Dieser Schlüssel dient als externes Schlüsselmaterial für den KMS-Schlüssel. Der Wert des Parameters `--origin` muss `EXTERNAL_KEY_STORE` lauten. Der Parameter `custom-key-store-id` muss einen externen Schlüsselspeicher identifizieren, der mit dem Proxy seines externen Schlüsselspeichers verbunden ist.
```
aws kms create-key \
--origin EXTERNAL_KEY_STORE \
--custom-key-store-id cks-9876543210fedcba9 \
--xks-key-id bb8562717f809024
```
Ausgabe:
```
{
"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"
}
}
}
```
Weitere Informationen finden Sie unter [Externe Schlüsselspeicher](https://docs.aws.amazon.com/kms/latest/developerguide/keystore-external.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [CreateKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/create-key.html)in der *AWS CLI Befehlsreferenz*.
### `decrypt`
Das folgende Codebeispiel zeigt die Verwendung`decrypt`.
**AWS CLI**
**Beispiel 1: So verschlüsseln Sie eine verschlüsselte Nachricht mit einem symmetrischen KMS-Schlüssel (Linux und macOS)**
Das folgende `decrypt` Befehlsbeispiel zeigt die empfohlene Methode zum Entschlüsseln von Daten mit der AWS CLI. Diese Version zeigt, wie Daten unter einem symmetrischen KMS-Schlüssel entschlüsselt werden.
Geben Sie den Geheimtext in einer Datei an. Verwenden Sie im Wert des `--ciphertext-blob`-Parameters das `fileb://`-Präfix, das die CLI anweist, die Daten aus einer Binärdatei zu lesen. Wenn sich die Datei nicht im aktuellen Verzeichnis befindet, geben Sie den vollständigen Dateipfad ein. Weitere Informationen zum Lesen von AWS CLI-Parameterwerten aus einer Datei finden Sie unter AWS CLI-Parameter aus einer Datei laden < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> im *AWS Command Line Interface User Guide* und Best Practices for Local File Parameters< https://aws.amazon.com/blogs/ developer/ best-practices-for-local -file-parameters/> im *AWS Command Line Tool Blog* .Geben Sie den KMS-Schlüssel an, um den Chiffretext zu entschlüsseln. Der Parameter ist bei der Entschlüsselung mit einem symmetrischen KMS-Schlüssel nicht erforderlich. `--key-id` AWS KMS kann die Schlüssel-ID des KMS-Schlüssels, der zur Verschlüsselung der Daten verwendet wurde, aus den Metadaten im Chiffretext abrufen. Es ist jedoch immer eine bewährte Methode, den von Ihnen verwendeten KMS-Schlüssel anzugeben. Diese Methode stellt sicher, dass Sie den beabsichtigten KMS-Schlüssel verwenden, und verhindert, dass Sie versehentlich einen Geheimtext mit einem KMS-Schlüssel entschlüsseln, dem Sie nicht vertrauen. Fordern Sie die Klartextausgabe als Textwert an. Der Parameter `--query` weist die CLI an, nur den Wert des Felds `Plaintext` aus der Ausgabe abzurufen. Der Parameter `--output` gibt die Ausgabe als Text zurück. Base64-dekodieren Sie den Klartext und speichern Sie ihn in einer Datei. Im folgenden Beispiel wird der Wert des Parameters `Plaintext` über eine Pipe (\$1) an das Base64-Dienstprogramm weitergeleitet, das ihn dekodiert. Anschließend erfolgt eine Umleitung (>) der dekodierten Ausgabe in die Datei `ExamplePlaintext`.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem Konto. AWS
```
aws kms decrypt \
--ciphertext-blob fileb://ExampleEncryptedFile \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--output text \
--query Plaintext | base64 \
--decode > ExamplePlaintextFile
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Die Ausgabe des Befehls `decrypt` wird Base64-dekodiert und in einer Datei gespeichert.
Weitere Informationen finden Sie unter [Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) in der *API-Referenz zu AWS Key Management Service*.
**Beispiel 2: Um eine verschlüsselte Nachricht mit einem symmetrischen KMS-Schlüssel zu entschlüsseln (Windows-Befehlszeile)**
Das folgende Beispiel ist mit dem vorherigen identisch, mit dem Unterschied, dass es das Dienstprogramm `certutil` zur Base64-Decodierung der Klartextdaten verwendet. Für dieses Verfahren sind zwei Befehle erforderlich, wie in den folgenden Beispielen gezeigt.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem AWS Konto.
```
aws kms decrypt ^
--ciphertext-blob fileb://ExampleEncryptedFile ^
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab ^
--output text ^
--query Plaintext > ExamplePlaintextFile.base64
```
Führen Sie den Befehl `certutil` aus.
```
certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile
```
Ausgabe:
```
Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.
```
Weitere Informationen finden Sie unter [Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) in der *API-Referenz zu AWS Key Management Service*.
**Beispiel 3: So entschlüsseln Sie eine verschlüsselte Nachricht mit einem asymmetrischen KMS-Schlüssel (Linux und macOS)**
Das folgende Beispiel für den Befehl `decrypt` zeigt, wie Daten entschlüsselt werden, die unter einem asymmetrischen RSA-KMS-Schlüssel verschlüsselt wurden.
Bei Verwendung eines asymmetrischen KMS-Schlüssels ist der Parameter `encryption-algorithm` erforderlich, der den Algorithmus zum Verschlüsseln des Klartextes angibt.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem AWS Konto.
```
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
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Die Ausgabe des Befehls `decrypt` wird Base64-dekodiert und in einer Datei gespeichert.
Weitere Informationen finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
+ Weitere API-Informationen finden Sie unter [Decrypt](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/decrypt.html) in der *AWS CLI -Befehlsreferenz*.
### `delete-alias`
Das folgende Codebeispiel zeigt die Verwendung`delete-alias`.
**AWS CLI**
**Um einen AWS KMS-Alias zu löschen**
Im folgenden Beispiel für `delete-alias` wird die Tabelle `alias/example-alias` gelöscht. Der Aliasname muss mit „alias/“ beginnen.
```
aws kms delete-alias \
--alias-name alias/example-alias
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den Befehl `list-aliases`, um den Alias zu suchen.
Weitere Informationen finden Sie unter [Löschen eines Alias](https://docs.aws.amazon.com/kms/latest/developerguide/alias-manage.html#alias-delete) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [DeleteAlias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/delete-alias.html)in der *AWS CLI Befehlsreferenz*.
### `delete-custom-key-store`
Das folgende Codebeispiel zeigt die Verwendung`delete-custom-key-store`.
**AWS CLI**
**So löschen Sie einen benutzerdefinierten Schlüsselspeicher**
Im folgenden Beispiel für `delete-custom-key-store` wird der angegebene benutzerdefinierte Schlüsselspeicher gelöscht.
Das Löschen eines AWS CloudHSM-Schlüsselspeichers hat keine Auswirkungen auf den zugehörigen CloudHSM-Cluster. Das Löschen eines externen Schlüsselspeichers hat keine Auswirkungen auf den zugehörigen Proxy des externen Schlüsselspeichers, den externen Schlüsselmanager oder die externen Schlüssel.
**HINWEIS:** Bevor Sie einen benutzerdefinierten Schlüsselspeicher löschen können, müssen Sie das Löschen aller KMS-Schlüssel im benutzerdefinierten Schlüsselspeicher planen und dann warten, bis diese KMS-Schlüssel gelöscht sind. Trennen Sie anschließend den benutzerdefinierten Schlüsselspeicher. Hilfe bei der Suche nach den KMS-Schlüsseln in Ihrem benutzerdefinierten Schlüsselspeicher finden [Sie unter Löschen eines AWS CloudHSM-Schlüsselspeichers (API)](https://docs.aws.amazon.com/kms/latest/developerguide/delete-keystore.html#delete-keystore-api) im *AWS Key Management Service Developer Guide*.
```
delete-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0
```
Dieser Befehl gibt keine Ausgabe zurück. Um zu überprüfen, ob der benutzerdefinierte Schlüsselspeicher gelöscht wurde, verwenden Sie den Befehl `describe-custom-key-stores`.
Informationen zum Löschen eines AWS CloudHSM-Schlüsselspeichers finden Sie unter [Löschen eines AWS CloudHSM-Schlüsselspeichers im AWS Key](https://docs.aws.amazon.com/kms/latest/developerguide/delete-keystore.html) *Management* Service Developer Guide.
Weitere Informationen zum Löschen eines externen Schlüsselspeichers finden Sie unter [Löschen eines externen Schlüsselspeichers](https://docs.aws.amazon.com/kms/latest/developerguide/delete-xks.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ *Einzelheiten zur API finden Sie in der Befehlsreferenz [DeleteCustomKeyStore](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/delete-custom-key-store.html).AWS CLI *
### `delete-imported-key-material`
Das folgende Codebeispiel zeigt die Verwendung`delete-imported-key-material`.
**AWS CLI**
**So löschen Sie importiertes Schlüsselmaterial aus einem KMS-Schlüssel**
Im folgenden Beispiel für `delete-imported-key-material` wird Schlüsselmaterial gelöscht, das in einen KMS-Schlüssel importiert wurde.
```
aws kms delete-imported-key-material \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
}
```
Weitere Informationen finden Sie unter [Löschen von importiertem Schlüsselmaterial](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys-delete-key-material.html) im *Entwicklerhandbuch für AWS KMS Key Management Service*.
+ Einzelheiten zur API finden Sie [DeleteImportedKeyMaterial](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/delete-imported-key-material.html)in der *AWS CLI Befehlsreferenz*.
### `derive-shared-secret`
Das folgende Codebeispiel zeigt die Verwendung`derive-shared-secret`.
**AWS CLI**
**So leiten Sie ein freigegebenes Secret ab**
Im folgenden Beispiel für `derive-shared-secret` wird ein gemeinsamer geheimer Schlüssel mithilfe eines Schlüsselvereinbarungsalgorithmus abgeleitet.
Sie müssen ein von NIST empfohlenes asymmetrisches KMS-Schlüsselpaar mit elliptischer Kurve (ECC) oder SM2 (nur Regionen China) mit dem Wert to call verwenden. `KeyUsage` `KEY_AGREEMENT` DeriveSharedSecret
```
aws kms derive-shared-secret \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--key-agreement-algorithm ECDH \
--public-key "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvH3Yj0wbkLEpUl95Cv1cJVjsVNSjwGq3tCLnzXfhVwVvmzGN8pYj3U8nKwgouaHbBWNJYjP5VutbbkKS4Kv4GojwZBJyHN17kmxo8yTjRmjR15SKIQ8cqRA2uaERMLnpztIXdZp232PQPbWGxDyXYJ0aJ5EFSag"
```
Ausgabe:
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"SharedSecret": "MEYCIQCKZLWyTk5runarx6XiAkU9gv3lbwPO/pHa+DXFehzdDwIhANwpsIV2g/9SPWLLsF6p/hiSskuIXMTRwqrMdVKWTMHG",
"KeyAgreementAlgorithm": "ECDH",
"KeyOrigin": "AWS_KMS"
}
```
*Weitere Informationen finden Sie [DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html)in der Key Management Service API-Referenz.AWS *
+ Einzelheiten zur API finden Sie [DeriveSharedSecret](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/derive-shared-secret.html)unter *AWS CLI Befehlsreferenz*.
### `describe-custom-key-stores`
Das folgende Codebeispiel zeigt die Verwendung`describe-custom-key-stores`.
**AWS CLI**
**Beispiel 1: Um Details zu einem AWS CloudHSM-Schlüsselspeicher abzurufen**
Im folgenden `describe-custom-key-store` Beispiel werden Details zum angegebenen AWS CloudHSM-Schlüsselspeicher angezeigt. Der Befehl ist für alle Arten von benutzerdefinierten Schlüsselspeichern identisch, aber die Ausgabe unterscheidet sich je nach Schlüsselspeichertyp und, bei einem externen Schlüsselspeicher, je nach dessen Verbindungsoption.
Diese Funktion zeigt standardmäßig Informationen zu allen benutzerdefinierten Schlüsselspeichern im Konto und in der Region an. Verwenden Sie den Parameter `custom-key-store-name` oder `custom-key-store-id`, um Informationen zu einem bestimmten benutzerdefinierten Schlüsselspeicher anzuzeigen.
```
aws kms describe-custom-key-stores \
--custom-key-store-name ExampleCloudHSMKeyStore
```
Die Ausgabe dieses Befehls enthält nützliche Informationen über den AWS CloudHSM-Schlüsselspeicher, einschließlich seines Verbindungsstatus ()`ConnectionState`. Wenn der Verbindungsstatus `FAILED` lautet, enthält die Ausgabe das Feld `ConnectionErrorCode` mit einer Beschreibung des Problems.
Ausgabe:
```
{
"CustomKeyStores": [
{
"CloudHsmClusterId": "cluster-1a23b4cdefg",
"ConnectionState": "CONNECTED",
"CreationDate": "2022-04-05T14:04:55-07:00",
"CustomKeyStoreId": "cks-1234567890abcdef0",
"CustomKeyStoreName": "ExampleExternalKeyStore",
"TrustAnchorCertificate": ""
}
]
}
```
Weitere Informationen finden Sie unter [AWS CloudHSM-Schlüsselspeicher anzeigen im AWS Key](https://docs.aws.amazon.com/kms/latest/developerguide/view-keystore.html) *Management Service Developer Guide*.
**Beispiel 2: So rufen Sie Details zu einem externen Schlüsselspeicher mit öffentlicher Endpunkt-Konnektivität ab**
Im folgenden Beispiel für `describe-custom-key-store` werden Details zum angegebenen externen Schlüsselspeicher angezeigt. Der Befehl ist für alle Arten von benutzerdefinierten Schlüsselspeichern identisch, aber die Ausgabe unterscheidet sich je nach Schlüsselspeichertyp und, bei einem externen Schlüsselspeicher, je nach dessen Verbindungsoption.
Diese Funktion zeigt standardmäßig Informationen zu allen benutzerdefinierten Schlüsselspeichern im Konto und in der Region an. Verwenden Sie den Parameter `custom-key-store-name` oder `custom-key-store-id`, um Informationen zu einem bestimmten benutzerdefinierten Schlüsselspeicher anzuzeigen.
```
aws kms describe-custom-key-stores \
--custom-key-store-id cks-9876543210fedcba9
```
Die Ausgabe dieses Befehls enthält nützliche Informationen über den externen Schlüsselspeicher, einschließlich seines Verbindungsstatus (`ConnectionState`). Wenn der Verbindungsstatus `FAILED` lautet, enthält die Ausgabe das Feld `ConnectionErrorCode` mit einer Beschreibung des Problems.
Ausgabe:
```
{
"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"
}
}
]
}
```
Weitere Informationen finden Sie unter [Anzeigen eines externen Schlüsselspeichers](https://docs.aws.amazon.com/kms/latest/developerguide/view-xks-keystore.html) im *Entwicklerhandbuch für AWS Key Management Service*.
**Beispiel 3: So rufen Sie Details zu einem externen Schlüsselspeicher mit der Konnektivität eines VPC-Endpunkt-Service**
Im folgenden Beispiel für `describe-custom-key-store` werden Details zum angegebenen externen Schlüsselspeicher angezeigt. Der Befehl ist für alle Arten von benutzerdefinierten Schlüsselspeichern identisch, aber die Ausgabe unterscheidet sich je nach Schlüsselspeichertyp und, bei einem externen Schlüsselspeicher, je nach dessen Verbindungsoption.
Diese Funktion zeigt standardmäßig Informationen zu allen benutzerdefinierten Schlüsselspeichern im Konto und in der Region an. Verwenden Sie den Parameter `custom-key-store-name` oder `custom-key-store-id`, um Informationen zu einem bestimmten benutzerdefinierten Schlüsselspeicher anzuzeigen.
```
aws kms describe-custom-key-stores \
--custom-key-store-id cks-2234567890abcdef0
```
Die Ausgabe dieses Befehls enthält nützliche Informationen über den externen Schlüsselspeicher, einschließlich seines Verbindungsstatus (`ConnectionState`). Wenn der Verbindungsstatus `FAILED` lautet, enthält die Ausgabe das Feld `ConnectionErrorCode` mit einer Beschreibung des Problems.
Ausgabe:
```
{
"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"
}
}
]
}
```
Weitere Informationen finden Sie unter [Anzeigen eines externen Schlüsselspeichers](https://docs.aws.amazon.com/kms/latest/developerguide/view-xks-keystore.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie unter [DescribeCustomKeyStores AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/describe-custom-key-stores.html)*Befehlsreferenz*.
### `describe-key`
Das folgende Codebeispiel zeigt die Verwendung`describe-key`.
**AWS CLI**
**Beispiel 1: So finden Sie detaillierte Informationen zu einem KMS-Schlüssel**
Im folgenden `describe-key` Beispiel werden detaillierte Informationen zum AWS verwalteten Schlüssel für Amazon S3 im Beispielkonto und in der Region abgerufen. Sie können diesen Befehl verwenden, um Details zu AWS verwalteten Schlüsseln und kundenverwalteten Schlüsseln zu finden.
Verwenden Sie den Parameter `key-id`, um den KMS-Schlüssel anzugeben. In diesem Beispiel wird der Wert für einen Aliasnamen verwendet, Sie können in diesem Befehl jedoch eine Schlüssel-ID, einen Schlüssel-ARN, einen Aliasnamen oder einen Alias-ARN verwenden.
```
aws kms describe-key \
--key-id alias/aws/s3
```
Ausgabe:
```
{
"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"
]
}
}
```
Weitere Informationen finden Sie unter [Anzeigen von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
**Beispiel 2: So rufen Sie Details zu einem asymmetrischen RSA-KMS-Schlüssel ab**
Im folgenden Beispiel für `describe-key` werden detaillierte Informationen zu einem asymmetrischen RSA-KMS-Schlüssel abgerufen, der für Signatur und Verifizierung verwendet wird.
```
aws kms describe-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"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"
]
}
}
```
**Beispiel 3: So rufen Sie Details zu einem Replikatschlüssel für mehrere Regionen ab**
Im folgenden Beispiel für `describe-key` werden Metadaten für einen multiregionalen Replikatschlüssel abgerufen. Der multiregionale Schlüssel ist ein symmetrischer Verschlüsselungsschlüssel. Die Ausgabe eines `describe-key`-Befehls für einen beliebigen Schlüssel mit mehreren Regionen gibt Informationen zum Primärschlüssel und allen zugehörigen Replikaten zurück.
```
aws kms describe-key \
--key-id arn:aws:kms:ap-northeast-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab
```
Ausgabe:
```
{
"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"
}
]
}
}
}
```
**Beispiel 4: So rufen Sie Details zu einem asymmetrischen HMAC-KMS-Schlüssel ab**
Im folgenden Beispiel für `describe-key` werden detaillierte Informationen zu einem HMAC-KMS-Schlüssel abgerufen.
```
aws kms describe-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"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
}
}
```
+ Einzelheiten zur API finden Sie [DescribeKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/describe-key.html)in der *AWS CLI Befehlsreferenz*.
### `disable-key-rotation`
Das folgende Codebeispiel zeigt die Verwendung`disable-key-rotation`.
**AWS CLI**
**So deaktivieren Sie die automatische Drehung eines KMS-Schlüssels**
Im folgenden Beispiel für `disable-key-rotation` wird die automatische Rotation eines kundenseitig verwalteten KMS-Schlüssels deaktiviert. Verwenden Sie den Befehl `enable-key-rotation`, um die automatische Rotation erneut zu aktivieren.
```
aws kms disable-key-rotation \
--key-id arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den Befehl `get-key-rotation-status`, um zu überprüfen, ob die automatische Rotation für den KMS-Schlüssel deaktiviert ist.
Weitere Informationen finden Sie unter [Rotieren von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [DisableKeyRotation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/disable-key-rotation.html)in der *AWS CLI Befehlsreferenz*.
### `disable-key`
Das folgende Codebeispiel zeigt die Verwendung`disable-key`.
**AWS CLI**
**So deaktivieren Sie einen KMS-Schlüssel vorübergehend**
Der folgende Befehl `disable-key` deaktiviert einen kundenseitig verwalteten KMS-Schlüssel. Verwenden Sie den Befehl `enable-key`, um den KMS-Schlüssel erneut zu aktivieren.
```
aws kms disable-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter [Aktivieren und Deaktivieren von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [DisableKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/disable-key.html)in der *AWS CLI Befehlsreferenz*.
### `disconnect-custom-key-store`
Das folgende Codebeispiel zeigt die Verwendung`disconnect-custom-key-store`.
**AWS CLI**
**So trennen Sie einen benutzerdefinierten Schlüsselspeicher**
Im folgenden `disconnect-custom-key-store` Beispiel wird die Verbindung eines benutzerdefinierten Schlüsselspeichers von seinem AWS CloudHSM-Cluster getrennt. Sie können die Verbindung zu einem Schlüsselspeicher trennen, um ein Problem zu beheben, seine Einstellungen zu aktualisieren oder um zu verhindern, dass KMS-Schlüssel im Schlüsselspeicher für kryptografische Vorgänge verwendet werden.
Dieser Befehl ist für alle benutzerdefinierten Schlüsselspeicher identisch, einschließlich AWS CloudHSM-Schlüsselspeicher und externer Schlüsselspeicher.
Vor der Ausführung dieses Befehls müssen Sie die Beispiel-ID des benutzerdefinierten Schlüsselspeichers durch eine gültige ID ersetzen.
```
$ aws kms disconnect-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0
```
Dieser Befehl erzeugt keine Ausgabe. Vergewissern Sie sich, dass der Befehl wirksam war, und verwenden Sie den Befehl `describe-custom-key-stores`.
*Weitere Informationen zum Trennen eines AWS CloudHSM-Schlüsselspeichers finden Sie unter [Verbinden und Trennen eines AWS CloudHSM-Schlüsselspeichers im Key Management Service Developer](https://docs.aws.amazon.com/kms/latest/developerguide/disconnect-keystore.html) Guide.AWS *
Weitere Informationen zum Trennen eines externen Schlüsselspeichers finden Sie unter [Verbinden und Trennen eines externen Schlüsselspeichers](https://docs.aws.amazon.com/kms/latest/developerguide/xks-connect-disconnect.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ *Einzelheiten zur API finden Sie in der Befehlsreferenz. [DisconnectCustomKeyStore](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/disconnect-custom-key-store.html)AWS CLI *
### `enable-key-rotation`
Das folgende Codebeispiel zeigt die Verwendung`enable-key-rotation`.
**AWS CLI**
**So aktivieren Sie die automatische Rotation eines KMS-Schlüssels**
Das folgende Beispiel für `enable-key-rotation` ermöglicht die automatische Rotation eines kundenseitig verwalteten KMS-Schlüssels mit einem Rotationszeitraum von 180 Tagen. Der KMS-Schlüssel wird ab dem Datum, an dem dieser Befehl abgeschlossen wurde, ein Jahr (ungefähr 365 Tage) rotiert, und danach jedes Jahr.
Der Parameter `--key-id` identifiziert den KMS-Schlüssel. In diesem Beispiel wird ein Schlüssel-ARN-Wert verwendet, Sie können jedoch entweder die Schlüssel-ID oder den ARN des KMS-Schlüssels verwenden. Der Parameter `--rotation-period-in-days` gibt die Anzahl der Tage zwischen den einzelnen Rotationsdatumsangaben an. Geben Sie einen Wert zwischen 90 und 2 560 an. Wenn kein Wert angegeben wird, lautet der Standardwert 365 Tage.
```
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
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den Befehl `get-key-rotation-status`, um zu überprüfen, ob der KMS-Schlüssel aktiviert ist.
Weitere Informationen finden Sie unter [Rotieren von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [EnableKeyRotation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/enable-key-rotation.html)in der *AWS CLI Befehlsreferenz*.
### `enable-key`
Das folgende Codebeispiel zeigt die Verwendung`enable-key`.
**AWS CLI**
**So aktivieren Sie einen KMS-Schlüssel**
Im folgenden Beispiel für `enable-key` wird ein kundenseitig verwalteter Schlüssel aktiviert. Sie können einen Befehl wie diesen verwenden, um einen KMS-Schlüssel zu aktivieren, den Sie mit dem Befehl `disable-key` vorübergehend deaktiviert haben. Sie können ihn auch verwenden, um einen deaktivierten KMS-Schlüssel zu aktivieren, er zum Löschen vorgesehen war und der Löschvorgang abgebrochen wurde.
Verwenden Sie den Parameter `key-id`, um den KMS-Schlüssel anzugeben. In diesem Beispiel wird ein Schlüssel-ID-Wert verwendet, Sie können jedoch eine Schlüssel-ID- oder einen Schlüssel-ARN-Wert in diesem Befehl verwenden.
Ersetzen Sie vor Ausführung dieses Befehls die Beispielschlüssel-ID durch eine gültige.
```
aws kms enable-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den Befehl `describe-key`, um zu überprüfen, ob der KMS-Schlüssel aktiviert ist. Sehen Sie sich die Werte der Felder `KeyState` und `Enabled` und in der Ausgabe von `describe-key` an.
Weitere Informationen finden Sie unter [Aktivieren und Deaktivieren von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [EnableKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/enable-key.html)in der *AWS CLI Befehlsreferenz*.
### `encrypt`
Das folgende Codebeispiel zeigt die Verwendung`encrypt`.
**AWS CLI**
**Beispiel 1: So verschlüsseln Sie den Inhalt einer Datei unter Linux oder MacOS**
Der folgende `encrypt` Befehl demonstriert die empfohlene Methode zum Verschlüsseln von Daten mit der AWS CLI.
```
aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob | base64 \
--decode > ExampleEncryptedFile
```
Der Befehl führt mehrere Aktionen aus:
Er verwendet den Parameter `--plaintext`, um die zu verschlüsselnden Daten anzugeben. Dieser Parameterwert muss Base64-kodiert sein. Der Wert des `plaintext` Parameters muss Base64-kodiert sein, oder Sie müssen das `fileb://` Präfix verwenden, das die AWS CLI anweist, Binärdaten aus der Datei zu lesen. Wenn sich die Datei nicht im aktuellen Verzeichnis befindet, geben Sie den vollständigen Dateipfad ein. Beispiel: `fileb:///var/tmp/ExamplePlaintextFile` oder `fileb://C:\Temp\ExamplePlaintextFile`. [Weitere Informationen zum Lesen von AWS CLI-Parameterwerten aus einer Datei finden Sie unter [Laden von Parametern aus einer Datei](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-file) im *Benutzerhandbuch für die AWS Befehlszeilenschnittstelle* und [Best Practices für lokale Dateiparameter](https://blogs.aws.amazon.com/cli/post/TxLWWN1O25V1HE/Best-Practices-for-Local-File-Parameters) im Blog des AWS Befehlszeilentools. Verwendet die `--query` Parameter `--output` und, um die Ausgabe des Befehls zu steuern.Diese Parameter extrahieren die verschlüsselten Daten, den so genannten *Chiffretext*, aus der Befehlsausgabe. Weitere Informationen zur Steuerung der Ausgabe finden Sie unter Steuerung des Befehls. ](https://docs.aws.amazon.com/cli/latest/userguide/controlling-output.html)Ausgabe im *AWS Command Line Interface User Guide*. Verwendet das `base64` Hilfsprogramm, um die extrahierte Ausgabe in Binärdaten zu dekodieren. Der Chiffretext, der von einem erfolgreichen `encrypt` Befehl zurückgegeben wird, ist Base64-codierter Text. Sie müssen diesen Text dekodieren, bevor Sie ihn mit der AWS CLI entschlüsseln können. Speichert den binären Chiffretext in einer Datei. Der letzte Teil des Befehls (`> ExampleEncryptedFile`) speichert den binären Chiffretext in einer Datei, um die Entschlüsselung zu vereinfachen. Einen Beispielbefehl, der die AWS CLI zum Entschlüsseln von Daten verwendet, finden Sie in den Entschlüsselungsbeispielen.
**Beispiel 2: Verwenden der AWS CLI zum Verschlüsseln von Daten unter Windows**
Dieses Beispiel ist mit dem vorherigen identisch, mit dem Unterschied, dass es das Tool `certutil` anstelle von `base64` verwendet. Für dieses Verfahren sind zwei Befehle erforderlich, wie in den folgenden Beispielen gezeigt.
```
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
```
**Beispiel 3: Verschlüsseln mit einem asymmetrischen KMS-Schlüssel**
Der folgende Befehl `encrypt` zeigt, wie Klartext mit einem asymmetrischen KMS-Schlüssel verschlüsselt wird. Der Parameter `--encryption-algorithm` muss angegeben werden. Wie bei allen `encrypt` CLI-Befehlen muss der `plaintext` Parameter base64-codiert sein, oder Sie müssen das `fileb://` Präfix verwenden, das die AWS CLI anweist, Binärdaten aus der Datei zu lesen.
```
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
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Weitere API-Informationen finden Sie unter [Encrypt](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/encrypt.html) in der *AWS CLI -Befehlsreferenz*.
### `generate-data-key-pair-without-plaintext`
Das folgende Codebeispiel zeigt die Verwendung. `generate-data-key-pair-without-plaintext`
**AWS CLI**
**So generieren Sie ein asymmetrisches Datenschlüsselpaar vom Typ ECC NIST P384**
Im folgenden `generate-data-key-pair-without-plaintext` Beispiel wird ein ECC NIST P384-Schlüsselpaar zur Verwendung außerhalb von angefordert. AWS
Der Befehl gibt einen öffentlichen Klartextschlüssel und eine mit dem angegebenen KMS-Schlüssel verschlüsselte Kopie des privaten Schlüssels zurück. Er gibt keinen privaten Klartextschlüssel zurück. Sie können den verschlüsselten privaten Schlüssel sicher zusammen mit den verschlüsselten Daten speichern und AWS KMS aufrufen, um den privaten Schlüssel zu entschlüsseln, wenn Sie ihn benötigen.
Um ein asymmetrisches Datenschlüsselpaar vom Typ ECC NIST P384 anzufordern, verwenden Sie den Parameter `key-pair-spec` mit dem Wert `ECC_NIST_P384`.
Bei dem von Ihnen angegebenen KMS-Schlüssel muss es sich um einen KMS-Schlüssel mit symmetrischer Verschlüsselung handeln, d. h. um einen KMS-Schlüssel mit einem `KeySpec`-Wert von `SYMMETRIC_DEFAULT`.
HINWEIS: Die Werte in der Ausgabe dieses Beispiels sind zur Anzeige gekürzt.
```
aws kms generate-data-key-pair-without-plaintext \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--key-pair-spec ECC_NIST_P384
```
Ausgabe:
```
{
"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"
}
```
`PublicKey` und `PrivateKeyCiphertextBlob` werden im Base64-kodierten Format zurückgegeben.
Weitere Informationen finden Sie unter [Datenschlüsselpaare](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-key-pairs) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [GenerateDataKeyPairWithoutPlaintext](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-data-key-pair-without-plaintext.html)in der *AWS CLI Befehlsreferenz.*
### `generate-data-key-pair`
Das folgende Codebeispiel zeigt die Verwendung`generate-data-key-pair`.
**AWS CLI**
**So generieren Sie ein asymmetrisches RSA-Datenschlüsselpaar mit 2 048 Bit**
Im folgenden `generate-data-key-pair` Beispiel wird ein asymmetrisches 2048-Bit-RSA-Datenschlüsselpaar zur Verwendung außerhalb von angefordert. AWS Der Befehl gibt einen öffentlichen und einen privaten Klartextschlüssel zur sofortigen Verwendung und Löschung sowie eine Kopie des privaten Schlüssels zurück, die unter dem angegebenen KMS-Schlüssel verschlüsselt ist. Sie können den verschlüsselten Privatschlüssel sicher mit den verschlüsselten Daten speichern.
Um ein asymmetrisches RSA-Datenschlüsselpaar mit 2 048 Bit anzufordern, verwenden Sie den Parameter `key-pair-spec` mit dem Wert `RSA_2048`.
Bei dem von Ihnen angegebenen KMS-Schlüssel muss es sich um einen KMS-Schlüssel mit symmetrischer Verschlüsselung handeln, d. h. um einen KMS-Schlüssel mit einem `KeySpec`-Wert von `SYMMETRIC_DEFAULT`.
HINWEIS: Die Werte in der Ausgabe dieses Beispiels sind zur Anzeige gekürzt.
```
aws kms generate-data-key-pair \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--key-pair-spec RSA_2048
```
Ausgabe:
```
{
"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"
}
```
`PublicKey`, `PrivateKeyPlaintext` und `PrivateKeyCiphertextBlob` werden im Base64-kodierten Format zurückgegeben.
Weitere Informationen finden Sie unter [Datenschlüsselpaare](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-key-pairs) im *Entwicklerhandbuch für AWS Key Management Service*.
+ *Einzelheiten zur API finden Sie unter [GenerateDataKeyPair](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-data-key-pair.html)Befehlsreferenz.AWS CLI *
### `generate-data-key-without-plaintext`
Das folgende Codebeispiel zeigt die Verwendung`generate-data-key-without-plaintext`.
**AWS CLI**
**So generieren Sie einen symmetrischen 256-Bit-Datenschlüssel ohne Klartextschlüssel**
Im folgenden Beispiel für `generate-data-key-without-plaintext` wird ein symmetrisches RSA-Datenschlüsselpaar mit 256 Bit zur Verwendung außerhalb von AWS angefordert. Sie können AWS KMS aufrufen, um den Datenschlüssel zu entschlüsseln, wenn Sie bereit sind, ihn zu verwenden.
Um einen 256-Bit-Datenschlüssel anzufordern, verwenden Sie den Parameter `key-spec` mit dem Wert `AES_256`. Um einen 128-Bit-Datenschlüssel anzufordern, verwenden Sie den Parameter `key-spec` mit dem Wert `AES_128`. Verwenden Sie für alle anderen Datenschlüssellängen den Parameter `number-of-bytes`.
Bei dem von Ihnen angegebenen KMS-Schlüssel muss es sich um einen KMS-Schlüssel mit symmetrischer Verschlüsselung handeln, d. h. um einen KMS-Schlüssel mit KeySpec-Wert von SYMMETRIC\$1DEFAULT.
```
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
```
Ausgabe:
```
{
"CiphertextBlob": "AQEDAHjRYf5WytIc0C857tFSnBaPn2F8DgfmThbJlGfR8P3WlwAAAH4wfAYJKoZIhvcNAQcGoG8wbQIBADBoBgkqhkiG9w0BBwEwHgYJYIZIAWUDBAEuMBEEDEFogL",
"KeyId": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
}
```
Der `CiphertextBlob` (verschlüsselte Datenschlüssel) wird im Base64-codierten Format zurückgegeben.
Weitere Informationen finden Sie unter [Datenschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [GenerateDataKeyWithoutPlaintext](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-data-key-without-plaintext.html)in der *AWS CLI Befehlsreferenz.*
### `generate-data-key`
Das folgende Codebeispiel zeigt die Verwendung`generate-data-key`.
**AWS CLI**
**Beispiel 1: So generieren Sie einen symmetrischen 256-Bit-Datenschlüssel**
Im folgenden `generate-data-key` Beispiel wird ein symmetrischer 256-Bit-Datenschlüssel zur Verwendung außerhalb von angefordert. AWS Der Befehl gibt einen Klartextdatenschlüssel zur sofortigen Verwendung und Löschung sowie eine Kopie dieses Datenschlüssels zurück, die unter dem angegebenen KMS-Schlüssel verschlüsselt ist. Sie können den verschlüsselten Datenschlüssel sicher neben den verschlüsselten Daten speichern.
Um einen 256-Bit-Datenschlüssel anzufordern, verwenden Sie den Parameter `key-spec` mit dem Wert `AES_256`. Um einen 128-Bit-Datenschlüssel anzufordern, verwenden Sie den Parameter `key-spec` mit dem Wert `AES_128`. Verwenden Sie für alle anderen Datenschlüssellängen den Parameter `number-of-bytes`.
Bei dem von Ihnen angegebenen KMS-Schlüssel muss es sich um einen KMS-Schlüssel mit symmetrischer Verschlüsselung handeln, d. h. um einen KMS-Schlüssel mit KeySpec-Wert von SYMMETRIC\$1DEFAULT.
```
aws kms generate-data-key \
--key-id alias/ExampleAlias \
--key-spec AES_256
```
Ausgabe:
```
{
"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="
}
```
Der `Plaintext` (Klartextdatenschlüssel) und der `CiphertextBlob` (verschlüsselte Datenschlüssel) werden im Base64-codierten Format zurückgegeben.
Weitere Informationen finden Sie unter [Datenschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/data-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*. **Beispiel 2: So generieren Sie einen symmetrischen 512-Bit-Datenschlüssel**
Im folgenden Beispiel für `generate-data-key` wird ein symmetrischer 512-Bit-Datenschlüssel für Ver- und Entschlüsselung angefordert. Der Befehl gibt einen Klartextdatenschlüssel zur sofortigen Verwendung und Löschung sowie eine Kopie dieses Datenschlüssels zurück, die unter dem angegebenen KMS-Schlüssel verschlüsselt ist. Sie können den verschlüsselten Datenschlüssel sicher neben den verschlüsselten Daten speichern.
Verwenden Sie den Parameter `number-of-bytes`, um eine andere Schlüssellänge als 128 oder 256 Bit anzufordern. Um einen 512-Bit-Datenschlüssel anzufordern, verwendet das folgende Beispiel den Parameter `number-of-bytes` mit einem Wert von 64 (Byte).
Bei dem von Ihnen angegebenen KMS-Schlüssel muss es sich um einen KMS-Schlüssel mit symmetrischer Verschlüsselung handeln, d. h. um einen KMS-Schlüssel mit KeySpec-Wert von SYMMETRIC\$1DEFAULT.
HINWEIS: Die Werte in der Ausgabe dieses Beispiels sind zur Anzeige gekürzt.
```
aws kms generate-data-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--number-of-bytes 64
```
Ausgabe:
```
{
"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"
}
```
Der `Plaintext` (Klartextdatenschlüssel) und der `CiphertextBlob` (verschlüsselte Datenschlüssel) werden im Base64-codierten Format zurückgegeben.
Weitere Informationen finden Sie unter [Datenschlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/data-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ *Einzelheiten zur API finden Sie unter Befehlsreferenz [GenerateDataKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-data-key.html).AWS CLI *
### `generate-mac`
Das folgende Codebeispiel zeigt die Verwendung`generate-mac`.
**AWS CLI**
**Beispiel 1: So generieren Sie einen HMAC für eine Nachricht**
Der folgende Befehl `generate-mac` generiert einen HMAC für eine Nachricht, einen HMAC-KMS-Schlüssel und einen MAC-Algorithmus. Der Algorithmus muss vom angegebenen HMAC-KMS-Schlüssel unterstützt werden.
In AWS CLI v2 muss der Wert des `message` Parameters Base64-codiert sein. Oder Sie können die Nachricht in einer Datei speichern und das `fileb://` Präfix verwenden, das die AWS CLI anweist, Binärdaten aus der Datei zu lesen.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem AWS Konto. Die Schlüssel-ID muss einen HMAC-KMS-Schlüssel mit der Schlüsselverwendung von `GENERATE_VERIFY_MAC` darstellen.
```
msg=(echo 'Hello World' | base64)
aws kms generate-mac \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--message fileb://Message \
--mac-algorithm HMAC_SHA_384
```
Ausgabe:
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"Mac": "",
"MacAlgorithm": "HMAC_SHA_384"
}
```
Weitere Informationen zur Verwendung von HMAC-KMS-Schlüsseln in AWS KMS finden Sie unter [HMAC-Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/hmac.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 2: So speichern Sie einen HMAC in einer Datei (Linux und macOs)**
Im folgenden Beispiel für `generate-mac` wird ein HMAC für eine Kurznachricht generiert, die in einer lokalen Datei gespeichert ist. Der Befehl ruft auch die `Mac` Eigenschaft aus der Antwort ab, dekodiert sie mit Base64 und speichert sie in der Datei. ExampleMac Sie können die MAC-Datei in einem `verify-mac`-Befehl verwenden, der den MAC verifiziert.
Der Befehl `generate-mac` erfordert eine Base64-codierte Nachricht und einen MAC-Algorithmus, den Ihr HMAC-KMS-Schlüssel unterstützt. Verwenden Sie den Befehl `describe-key`, um die MAC-Algorithmen abzurufen, die Ihr KMS-Schlüssel unterstützt.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem Konto. AWS Die Schlüssel-ID muss einen asymmetrischen KMS-Schlüssel mit der Schlüsselverwendung GENERATE\$1VERIFY\$1MAC darstellen.
```
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
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. In diesem Beispiel wird die Eigenschaft `Mac` der Ausgabe extrahiert und in einer Datei gespeichert.
Weitere Informationen zur Verwendung von HMAC-KMS-Schlüsseln in AWS KMS finden Sie unter [HMAC-Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/hmac.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [GenerateMac](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-mac.html)in der *AWS CLI Befehlsreferenz*.
### `generate-random`
Das folgende Codebeispiel zeigt die Verwendung`generate-random`.
**AWS CLI**
**Beispiel 1: So generieren Sie eine 256-Bit-Zufallsbytezeichenfolge (Linux oder macOs)**
Im folgenden Beispiel für `generate-random` wird eine Base64-kodierte 256-Bit-Zufallsbytezeichenfolge (32 Byte) generiert. Im Beispiel wird die Bytezeichenfolge dekodiert und in der Zufallsdatei gespeichert.
Wenn Sie diesen Befehl ausführen, müssen Sie den Parameter `number-of-bytes` verwenden, um die Länge des Zufallswerts in Byte anzugeben.
Sie geben keinen KMS-Schlüssel an, wenn Sie diesen Befehl ausführen. Die Zufallsbytezeichenfolge steht in keinem Zusammenhang mit einem KMS-Schlüssel.
Standardmäßig generiert AWS KMS die Zufallszahl. Wenn Sie jedoch einen [benutzerdefinierten Schlüsselspeicher](https://docs.aws.amazon.com/kms/latest/developerguide/custom-key-store-overview.html) angeben, wird die zufällige Bytezeichenfolge in dem AWS CloudHSM-Cluster generiert, der dem benutzerdefinierten Schlüsselspeicher zugeordnet ist.
Im folgenden Beispiel werden die folgenden Parameter und Werte verwendet:
Es verwendet den erforderlichen `--number-of-bytes` Parameter mit dem Wert von, `32` um eine 32-Byte-Zeichenfolge (256-Bit) anzufordern.Es verwendet den `--output` Parameter mit dem Wert von, `text` um die AWS CLI anzuweisen, die Ausgabe als Text und nicht als JSON zurückzugeben.Es verwendet den, um den Wert der `Plaintext` Eigenschaft aus der Antwort `--query parameter` zu extrahieren.Es leitet (\$1) die Ausgabe des Befehls an das `base64` Hilfsprogramm weiter, das die extrahierte Ausgabe dekodiert. Es verwendet den Umleitungsoperator (>), um die dekodierte Bytezeichenfolge zu speichern File.it verwendet den Umleitungsoperator (>) `ExampleRandom` um den binären Chiffretext in einer Datei zu speichern.
```
aws kms generate-random \
--number-of-bytes 32 \
--output text \
--query Plaintext | base64 --decode > ExampleRandom
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie [GenerateRandom](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateRandom.html)in der *API-Referenz für den AWS Key Management Service*.
**Beispiel 2: So generieren Sie eine 256-Bit-Zufallszahl zu generieren (Windows-Befehlszeile)**
Im folgenden Beispiel wird der Befehl `generate-random` verwendet, um eine Base64-kodierte 256-Bit-Zufallsbytezeichenfolge (32 Byte) zu generieren. Im Beispiel wird die Bytezeichenfolge dekodiert und in der Zufallsdatei gespeichert. Dieses Beispiel ist mit dem vorherigen Beispiel identisch, mit dem Unterschied, dass es das Dienstprogramm `certutil` in Windows verwendet, um die zufällige Bytefolge vor dem Speichern in einer Datei mit Base64 zu dekodieren.
Generieren Sie zunächst eine Base64-kodierte Zufallsbytezeichenfolge und speichern Sie sie in einer temporären Datei, `ExampleRandom.base64`.
```
aws kms generate-random \
--number-of-bytes 32 \
--output text \
--query Plaintext > ExampleRandom.base64
```
Da die Ausgabe des Befehls `generate-random` in einer Datei gespeichert wird, erzeugt dieses Beispiel keine Ausgabe.
Verwenden Sie nun den Befehl `certutil -decode`, um die Base64-kodierte Bytezeichenfolge in der Datei `ExampleRandom.base64` zu dekodieren. Anschließend wird die dekodierte Bytezeichenfolge in der Datei `ExampleRandom` gespeichert.
```
certutil -decode ExampleRandom.base64 ExampleRandom
```
Ausgabe:
```
Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.
```
Weitere Informationen finden Sie [GenerateRandom](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateRandom.html)in der *API-Referenz für den AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [GenerateRandom](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/generate-random.html)unter *AWS CLI Befehlsreferenz*.
### `get-key-policy`
Das folgende Codebeispiel zeigt die Verwendung`get-key-policy`.
**AWS CLI**
**So kopieren Sie eine Schlüsselrichtlinie von einem KMS-Schlüssel in einen anderen**
Im folgenden Beispiel für `get-key-policy` wird die Schlüsselrichtlinie von einem KMS-Schlüssel abgerufen und in einer Textdatei gespeichert. Anschließend wird die Richtlinie eines anderen KMS-Schlüssels ersetzt, wobei die Textdatei als Richtlinieneingabe verwendet wird.
Da für den Parameter `--policy` von `put-key-policy` eine Zeichenfolge erforderlich ist, müssen Sie die Option `--output text` verwenden, um die Ausgabe als Textzeichenfolge statt als JSON zurückzugeben.
```
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
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie [PutKeyPolicy](https://docs.aws.amazon.com/kms/latest/APIReference/API_PutKeyPolicy.html)in der *AWS KMS-API-Referenz*.
+ Einzelheiten zur API finden Sie [GetKeyPolicy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/get-key-policy.html)unter *AWS CLI Befehlsreferenz*.
### `get-key-rotation-status`
Das folgende Codebeispiel zeigt die Verwendung`get-key-rotation-status`.
**AWS CLI**
**So rufen Sie den Rotationsstatus für einen KMS-Schlüssel ab.**
Im folgenden Beispiel für `get-key-rotation-status` werden Informationen zum Rotationsstatus des angegebenen KMS-Schlüssels zurückgegeben, einschließlich der Angabe, ob die automatische Rotation aktiviert ist, des Rotationszeitraums und des nächsten geplanten Rotationsdatums. Sie können diesen Befehl für vom Kunden verwaltete KMS-Schlüssel und AWS verwaltete KMS-Schlüssel verwenden. Alle AWS verwalteten KMS-Schlüssel werden jedoch jedes Jahr automatisch rotiert.
```
aws kms get-key-rotation-status \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyRotationEnabled": true,
"NextRotationDate": "2024-02-14T18:14:33.587000+00:00",
"RotationPeriodInDays": 365
}
```
Weitere Informationen finden Sie unter [Rotieren von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [GetKeyRotationStatus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/get-key-rotation-status.html)in der *AWS CLI Befehlsreferenz*.
### `get-parameters-for-import`
Das folgende Codebeispiel zeigt die Verwendung`get-parameters-for-import`.
**AWS CLI**
**So rufen Sie die Elemente ab, die für den Import von Schlüsselmaterial in einen KMS-Schlüssel erforderlich sind**
Im folgenden Beispiel für `get-parameters-for-import` werden der öffentliche Schlüssel und Import-Token abgerufen, die Sie zum Importieren von Schlüsselmaterial in einen KMS-Schlüssel benötigen. Achten Sie bei Verwendung des Befehls `import-key-material` darauf, dass Sie das Import-Token und das mit dem öffentlichen Schlüssel verschlüsselte Schlüsselmaterial verwenden, die im selben Befehl `get-parameters-for-import` zurückgegeben wurden. Außerdem muss es sich bei dem in diesem Befehl angegebenen Wrapping-Algorithmus um einen Algorithmus handeln, mit Sie das Schlüsselmaterial mit dem öffentlichen Schlüssel verschlüsseln.
Verwenden Sie den Parameter `key-id`, um den KMS-Schlüssel anzugeben. In diesem Beispiel wird eine Schlüssel-ID verwendet, Sie können jedoch eine Schlüssel-ID oder einen Schlüssel-ARN in diesem Befehl verwenden.
```
aws kms get-parameters-for-import \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--wrapping-algorithm RSAES_OAEP_SHA_256 \
--wrapping-key-spec RSA_2048
```
Ausgabe:
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"PublicKey": "",
"ImportToken": "",
"ParametersValidTo": 1593893322.32
}
```
Weitere Informationen finden Sie unter [Herunterladen des öffentlichen Schlüssels und Importieren des Tokens](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys-get-public-key-and-token.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [GetParametersForImport](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/get-parameters-for-import.html)in der *AWS CLI Befehlsreferenz*.
### `get-public-key`
Das folgende Codebeispiel zeigt die Verwendung`get-public-key`.
**AWS CLI**
**Beispiel 1: So laden Sie den öffentlichen Schlüssel eines asymmetrischen KMS-Schlüssels herunter**
Im folgenden Beispiel für `get-public-key` laden Sie den öffentlichen Schlüssel eines asymmetrischen KMS-Schlüssels herunter.
Zusätzlich zur Rückgabe des öffentlichen Schlüssels enthält die Ausgabe Informationen, die Sie benötigen, um den öffentlichen Schlüssel sicher außerhalb von AWS KMS zu verwenden, einschließlich der Schlüsselverwendung und der unterstützten Verschlüsselungsalgorithmen.
```
aws kms get-public-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"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"
]
}
```
Weitere Informationen zur Verwendung asymmetrischer KMS-Schlüssel in AWS KMS finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*. **Beispiel 2: So konvertieren Sie einen öffentlichen Schlüssel in das DER-Format (Linux und macOS)**
Im folgenden Beispiel für `get-public-key` wird der öffentliche Schlüssel eines asymmetrischen KMS-Schlüssels heruntergeladen und in einer DER-Datei gespeichert.
Wenn Sie den `get-public-key` Befehl in der AWS CLI verwenden, gibt er einen DER-codierten öffentlichen X.509-Schlüssel zurück, der Base64-kodiert ist. In diesem Beispiel wird der Wert der Eigenschaft `PublicKey` als Text abgerufen. `PublicKey` wird Base64-dekodiert und in der Datei `public_key.der` gespeichert. Der Parameter `output` gibt die Ausgabe als Text statt als JSON zurück. Der `--query` Parameter ruft nur die `PublicKey` Eigenschaft ab, nicht die Eigenschaften, die Sie benötigen, um den öffentlichen Schlüssel sicher außerhalb von KMS zu verwenden. AWS
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem AWS Konto.
```
aws kms get-public-key \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--output text \
--query PublicKey | base64 --decode > public_key.der
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen zur Verwendung asymmetrischer KMS-Schlüssel in AWS KMS finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [GetPublicKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/get-public-key.html)in der *AWS CLI Befehlsreferenz*.
### `import-key-material`
Das folgende Codebeispiel zeigt die Verwendung`import-key-material`.
**AWS CLI**
**So importieren Sie Schlüsselmaterial in einen KMS-Schlüssel**
Im folgenden Beispiel für `import-key-material` wird Schlüsselmaterial in einen KMS-Schlüssel hochgeladen, der ohne Schlüsselmaterial erstellt wurde. Der Schlüsselstatus des KMS-Schlüssels muss `PendingImport` lauten.
Dieser Befehl verwendet Schlüsselmaterial, das Sie mit dem öffentlichen Schlüssel verschlüsselt haben, den der `get-parameters-for-import` Befehl zurückgegeben hat. Außerdem wird das Import-Token aus demselben Befehl `get-parameters-for-import` verwendet.
Der Parameter `expiration-model` gibt an, dass das Schlüsselmaterial automatisch zu der durch den Parameter `valid-to` angegebenen Datums- und Uhrzeitangabe abläuft. Wenn das Schlüsselmaterial abläuft, löscht AWS KMS das Schlüsselmaterial, der Schlüsselstatus des KMS-Schlüssels ändert sich `Pending import` und der KMS-Schlüssel wird unbrauchbar. Um den Schlüssel wiederherzustellen, müssen Sie dasselbe Schlüsselmaterial erneut in den Schlüssel importieren. Um anderes Schlüsselmaterial zu verwenden, müssen Sie einen neuen KMS-Schlüssel erstellen.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID oder Schlüssel-ARN aus Ihrem AWS Konto.
```
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
```
Ausgabe:
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"KeyMaterialId": "0b7fd7ddbac6eef27907413567cad8c810e2883dc8a7534067a82ee1142fc1e6"
}
```
Weitere Informationen zum Importieren von Schlüsselmaterial finden Sie unter [Importieren von Schlüsselmaterial](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [ImportKeyMaterial](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/import-key-material.html)in der *AWS CLI Befehlsreferenz*.
### `list-aliases`
Das folgende Codebeispiel zeigt die Verwendung`list-aliases`.
**AWS CLI**
**Beispiel 1: Um alle Aliase in einem AWS Konto und einer Region aufzulisten**
Im folgenden Beispiel wird der `list-aliases` Befehl verwendet, um alle Aliase in der Standardregion des AWS Kontos aufzulisten. Die Ausgabe umfasst Aliase, die AWS verwalteten KMS-Schlüsseln und kundenverwalteten KMS-Schlüsseln zugeordnet sind.
```
aws kms list-aliases
```
Ausgabe:
```
{
"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"
},
...
]
}
```
**Beispiel 2: So listen Sie alle Aliasnamen für einen bestimmten KMS-Schlüssel auf**
Im folgenden Beispiel werden der Befehl `list-aliases` und sein Parameter `key-id` verwendet, um alle Aliasname aufzulisten, die einem bestimmten KMS-Schlüssel zugeordnet sind.
Jeder Alias ist nur mit einem KMS-Schlüssel verbunden, ein KMS-Schlüssel kann jedoch über mehrere Aliasse verfügen. Dieser Befehl ist sehr nützlich, da die AWS KMS-Konsole nur einen Alias für jeden KMS-Schlüssel auflistet. Um alle Aliasnamen für einen KMS-Schlüssel zu suchen, müssen Sie den Befehl `list-aliases` verwenden.
In diesem Beispiel wird die Schlüssel-ID des KMS-Schlüssels für den Parameter `--key-id` verwendet. Sie können in diesem Befehl jedoch eine Schlüssel-ID, einen Schlüssel-ARN, einen Aliasnamen oder einen Alias-ARN verwenden.
```
aws kms list-aliases --key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"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"
}
]
}
```
Weitere Informationen finden Sie unter [Arbeiten mit Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/programming-aliases.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [ListAliases](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-aliases.html)in der *AWS CLI Befehlsreferenz*.
### `list-grants`
Das folgende Codebeispiel zeigt die Verwendung`list-grants`.
**AWS CLI**
**Um die Grants für einen AWS KMS-Schlüssel anzuzeigen**
Im folgenden `list-grants` Beispiel werden alle Grants für den angegebenen AWS verwalteten KMS-Schlüssel für Amazon DynamoDB in Ihrem Konto angezeigt. Diese Erteilung ermöglicht es DynamoDB, den KMS-Schlüssel in Ihrem Namen zu verwenden, um eine DynamoDB-Tabelle zu verschlüsseln, bevor sie auf die Festplatte geschrieben wird. Sie können einen Befehl wie diesen verwenden, um die Zuschüsse für die AWS verwalteten KMS-Schlüssel und die vom Kunden verwalteten KMS-Schlüssel für das AWS Konto und die Region anzuzeigen.
Dieser Befehl verwendet den Parameter `key-id` mit einer Schlüssel-ID, um den KMS-Schlüssel zu identifizieren. Sie können den KMS-Schlüssel mit einer Schlüssel-ID oder einem Schlüssel-ARN identifizieren. Verwenden Sie den `list-aliases` Befehl or, um die Schlüssel-ID oder den Schlüssel-ARN eines AWS verwalteten KMS-Schlüssels abzurufen. `list-keys`
```
aws kms list-grants \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Die Ausgabe zeigt, dass Amazon DynamoDB durch die Erteilung dazu berechtigt ist, den KMS-Schlüssel für kryptografische Vorgänge zu verwenden und Details zum KMS-Schlüssel (`DescribeKey`) anzuzeigen und Erteilungen (`RetireGrant`) zurückzuziehen. Die Einschränkung `EncryptionContextSubset` beschränkt diese Berechtigung auf Anforderungen, die die angegebenen Verschlüsselungskontextpaare enthalten. Daher sind die Berechtigungen in der Erteilung nur für das angegebene Konto und die angegebene DynamoDB-Tabelle wirksam.
```
{
"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"
}
]
}
```
Weitere Informationen finden Sie unter [Grants in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [ListGrants](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-grants.html)in der *AWS CLI Befehlsreferenz*.
### `list-key-policies`
Das folgende Codebeispiel zeigt die Verwendung`list-key-policies`.
**AWS CLI**
**So rufen Sie die Namen von Schlüsselrichtlinien für einen KMS-Schlüssel ab**
Im folgenden Beispiel für `list-key-policies` werden die Namen der Schlüsselrichtlinien für einen kundenseitig verwalteten Schlüssel im Beispielkonto und in der Beispielregion abgerufen. Sie können diesen Befehl verwenden, um die Namen der wichtigsten Richtlinien für AWS verwaltete Schlüssel und vom Kunden verwaltete Schlüssel zu finden.
Da der einzige gültige Name der Schlüsselrichtlinie `default` lautet, ist dieser Befehl nicht hilfreich.
Verwenden Sie den Parameter `key-id`, um den KMS-Schlüssel anzugeben. In diesem Beispiel wird ein Schlüssel-ID-Wert verwendet, Sie können jedoch eine Schlüssel-ID oder einen Schlüssel-ARN in diesem Befehl verwenden.
```
aws kms list-key-policies \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"PolicyNames": [
"default"
]
}
```
Weitere Informationen zu AWS KMS-Schlüsselrichtlinien finden Sie unter [Verwenden von Schlüsselrichtlinien in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [ListKeyPolicies](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-key-policies.html)in der *AWS CLI Befehlsreferenz*.
### `list-key-rotations`
Das folgende Codebeispiel zeigt die Verwendung`list-key-rotations`.
**AWS CLI**
**So rufen Sie Informationen zu allen abgeschlossenen Rotationen von Schlüsselmaterialen ab**
Im folgenden Beispiel für `list-key-rotations` werden Informationen zu allen abgeschlossenen Rotationen von Schlüsselmaterialien für den angegebenen KMS-Schlüssel aufgeführt.
```
aws kms list-key-rotations \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"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
}
```
Weitere Informationen finden Sie unter [Rotieren von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [ListKeyRotations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-key-rotations.html)in der *AWS CLI Befehlsreferenz*.
### `list-keys`
Das folgende Codebeispiel zeigt die Verwendung`list-keys`.
**AWS CLI**
**So rufen Sie die KMS-Schlüssel für ein Konto und eine Region ab**
Im folgenden Beispiel für `list-keys` werden die KMS-Schlüssel für ein Konto und eine Region abgerufen. Dieser Befehl gibt sowohl AWS verwaltete Schlüssel als auch vom Kunden verwaltete Schlüssel zurück.
```
aws kms list-keys
```
Ausgabe:
```
{
"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"
}
]
}
```
Weitere Informationen finden Sie unter [Anzeigen von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [ListKeys](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-keys.html)in der *AWS CLI Befehlsreferenz*.
### `list-resource-tags`
Das folgende Codebeispiel zeigt die Verwendung`list-resource-tags`.
**AWS CLI**
**So rufen Sie die Tags eines KMS-Schlüssels ab**
Im folgenden Beispiel für `list-resource-tags` werden die Tags für einen KMS-Schlüssel abgerufen. Verwenden Sie den Befehl `tag-resource`, um Ressourcen-Tags zu KMS-Schlüsseln hinzuzufügen oder zu ersetzen. Die Ausgabe zeigt, dass dieser KMS-Schlüssel über zwei Ressourcentags mit jeweils einem Schlüssel und einem Wert verfügt.
Verwenden Sie den Parameter `key-id`, um den KMS-Schlüssel anzugeben. In diesem Beispiel wird ein Schlüssel-ID-Wert verwendet, Sie können jedoch eine Schlüssel-ID oder einen Schlüssel-ARN in diesem Befehl verwenden.
```
aws kms list-resource-tags \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"Tags": [
{
"TagKey": "Dept",
"TagValue": "IT"
},
{
"TagKey": "Purpose",
"TagValue": "Test"
}
],
"Truncated": false
}
```
Weitere Informationen zur Verwendung von Tags in AWS KMS finden Sie unter [Tagging Keys](https://docs.aws.amazon.com/kms/latest/developerguide/tagging-keys.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [ListResourceTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-resource-tags.html)in der *AWS CLI Befehlsreferenz.*
### `list-retirable-grants`
Das folgende Codebeispiel zeigt die Verwendung`list-retirable-grants`.
**AWS CLI**
**So zeigen Sie die Erteilungen an, die ein Prinzipal zurückziehen kann**
Im folgenden `list-retirable-grants` Beispiel werden alle Berechtigungen angezeigt, die der `ExampleAdmin` Benutzer für die KMS-Schlüssel in einem AWS Konto und einer Region zurückziehen kann. Sie können einen Befehl wie diesen verwenden, um die Zuweisungen anzuzeigen, die jeder Kontoinhaber für KMS-Schlüssel im AWS Konto und in der Region zurückziehen kann.
Der Wert des erforderlichen Parameters `retiring-principal` muss der Amazon-Ressourcenname (ARN) eines Kontos, eines Benutzers oder einer Rolle sein.
Sie können in diesem Befehl keinen Service für den Wert `retiring-principal` angeben, auch wenn ein Service der zurückziehende Prinzipal sein kann. Verwenden Sie den Befehl `list-grants`, um die Erteilungen zu ermitteln, in denen ein bestimmter Service der zurückziehende Prinzipal ist.
Die Ausgabe zeigt, dass der Benutzer `ExampleAdmin` berechtigt ist, Erteilungen für zwei verschiedene KMS-Schlüssel im Konto und in der Region zurückzuziehen. Zusätzlich zum zurückziehenden Prinzipal ist das Konto berechtigt, jede Erteilung im Konto zurückzuziehen.
```
aws kms list-retirable-grants \
--retiring-principal arn:aws:iam::111122223333:user/ExampleAdmin
```
Ausgabe:
```
{
"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
}
```
Weitere Informationen finden Sie unter [Grants in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [ListRetirableGrants](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/list-retirable-grants.html)in der *AWS CLI Befehlsreferenz*.
### `put-key-policy`
Das folgende Codebeispiel zeigt die Verwendung`put-key-policy`.
**AWS CLI**
**So ändern Sie die Schlüsselrichtlinie für einen KMS-Schlüssel**
Im folgenden Beispiel für `put-key-policy` wird die Schlüsselrichtlinie für einen kundenseitig verwalteten Schlüssel geändert.
Erstellen Sie zunächst eine Schlüsselrichtlinie und speichern Sie sie in einer lokalen JSON-Datei. In diesem Beispiel handelt es sich um die Datei `key_policy.json`. Sie können die Schlüsselrichtlinie auch als Zeichenfolgenwert des Parameters `policy` angeben.
Die erste Anweisung in dieser Schlüsselrichtlinie erteilt dem AWS Konto die Erlaubnis, IAM-Richtlinien zur Steuerung des Zugriffs auf den KMS-Schlüssel zu verwenden. Die zweite Anweisung erteilt dem Benutzer `test-user` die Berechtigung, die Befehle `describe-key` und `list-keys` auf dem KMS-Schlüssel auszuführen.
Inhalt von `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" : "*"
}
]
}
```
In diesem Beispiel wird der KMS-Schlüssel mit der Schlüssel-ID identifiziert, Sie können jedoch auch einen Schlüssel-ARN verwenden. Der Befehl verwendet den Parameter `policy`, um die Schlüsselrichtlinie festzulegen. Um anzugeben, dass sich die Richtlinie in einer Datei befindet, wird das erforderliche Präfix `file://` verwendet. Dieses Präfix ist erforderlich, um Dateien auf allen unterstützten Betriebssystemen zu identifizieren. Schließlich verwendet der Befehl den Parameter `policy-name` mit dem Wert `default`. Wenn kein Richtlinienwert angegeben wird, lautet der Standardwert `default`. Der einzige gültige Wert ist `default`.
```
aws kms put-key-policy \
--policy-name default \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--policy file://key_policy.json
```
Dieser Befehl erzeugt keine Ausgabe. Verwenden Sie den Befehl `get-key-policy`, um zu überprüfen, ob der Befehl wirksam war. Mit dem folgenden Beispielbefehl wird die Schlüsselrichtlinie für denselben KMS-Schlüssel abgerufen. Der Parameter `output` mit dem Wert `text` gibt ein leicht lesbares Textformat zurück.
```
aws kms get-key-policy \
--policy-name default \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--output text
```
Ausgabe:
```
{
"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" : "*"
}
]
}
```
Weitere Informationen finden Sie unter [Ändern einer Schlüsselrichtlinie](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [PutKeyPolicy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/put-key-policy.html)in der *AWS CLI Befehlsreferenz.*
### `re-encrypt`
Das folgende Codebeispiel zeigt die Verwendung`re-encrypt`.
**AWS CLI**
**Beispiel 1: So verschlüsseln Sie eine verschlüsselte Nachricht unter einem symmetrischen KMS-Schlüssel (Linux und macOS) erneut).**
Das folgende `re-encrypt` Befehlsbeispiel zeigt die empfohlene Methode zum erneuten Verschlüsseln von Daten mit der AWS CLI.
Geben Sie den Geheimtext in einer Datei an. Verwenden Sie im Wert des `--ciphertext-blob`-Parameters das `fileb://`-Präfix, das die CLI anweist, die Daten aus einer Binärdatei zu lesen. Wenn sich die Datei nicht im aktuellen Verzeichnis befindet, geben Sie den vollständigen Dateipfad ein. Weitere Informationen zum Lesen von AWS CLI-Parameterwerten aus einer Datei finden Sie unter [Laden von AWS CLI-Parametern aus einer Datei](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html) im *Benutzerhandbuch für die AWS Befehlszeilenschnittstelle* und [Best Practices für lokale Dateiparameter](https://aws.amazon.com/blogs/developer/best-practices-for-local-file-parameters/) im *AWS Command Line Tool-Blog*. Geben Sie den KMS-Quellschlüssel an, der den Chiffretext entschlüsselt. Der `--source-key-id` Parameter ist bei der Entschlüsselung mit symmetrischer Verschlüsselung von KMS-Schlüsseln nicht erforderlich. AWS KMS kann den KMS-Schlüssel, der zur Verschlüsselung der Daten verwendet wurde, aus den Metadaten im Chiffretext-Blob abrufen. Es ist jedoch immer eine bewährte Methode, den von Ihnen verwendeten KMS-Schlüssel anzugeben. Diese Methode stellt sicher, dass Sie den beabsichtigten KMS-Schlüssel verwenden, und verhindert, dass Sie versehentlich einen Geheimtext mit einem KMS-Schlüssel entschlüsseln, dem Sie nicht vertrauen. Geben Sie den KMS-Schlüssel an, der die Daten erneut verschlüsselt. Der Parameter `--destination-key-id` ist immer erforderlich. In diesem Beispiel wird ein Schlüssel-ARN verwendet, Sie können jedoch jede gültige Schlüsselkennung verwenden. Fordern Sie die Klartextausgabe als Textwert an. Der Parameter `--query` weist die CLI an, nur den Wert des Feldes `Plaintext` aus der Ausgabe abzurufen. Der Parameter `--output` gibt die Ausgabe als Text zurück. Base64-dekodieren Sie den Klartext und speichern Sie ihn in einer Datei. Im folgenden Beispiel wird der Wert des Parameters `Plaintext` über eine Pipe (\$1) an das Base64-Dienstprogramm weitergeleitet, das ihn dekodiert. Anschließend erfolgt eine Umleitung (>) der dekodierten Ausgabe in die Datei `ExamplePlaintext`.
Bevor Sie diesen Befehl ausführen, ersetzen Sie den Beispielschlüssel durch gültige IDs Schlüsselkennungen aus Ihrem Konto. 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
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Die Ausgabe des Befehls `re-encrypt` wird Base64-dekodiert und in einer Datei gespeichert.
Weitere Informationen finden Sie [ReEncrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html)in der *API-Referenz für den AWS Key Management Service*.
**Beispiel 2: So verschlüsseln Sie eine verschlüsselte Nachricht unter einem symmetrischen KMS-Schlüssel (Windows-Befehlszeile) erneut).**
Das folgende Beispiel für den Befehl `re-encrypt` ist mit dem vorherigen identisch, mit dem Unterschied, dass es das Dienstprogramm `certutil` zur Base64-Decodierung der Klartextdaten verwendet. Für dieses Verfahren sind zwei Befehle erforderlich, wie in den folgenden Beispielen gezeigt.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem AWS Konto.
```
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
```
Verwenden Sie dann das Dienstprogramm `certutil`.
```
certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile
```
Ausgabe:
```
Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.
```
Weitere Informationen finden Sie [ReEncrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html)in der *API-Referenz für den AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [ReEncrypt](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/re-encrypt.html)unter *AWS CLI Befehlsreferenz*.
### `retire-grant`
Das folgende Codebeispiel zeigt die Verwendung`retire-grant`.
**AWS CLI**
**So ziehen Sie eine Erteilung für einen Kundenhauptschlüssel zurück**
Im folgenden Beispiel für `retire-grant` wird ein Zuschuss aus einem KMS-Schlüssel gelöscht.
Der folgende Beispielbefehl legt die Parameter `grant-id` und `key-id` fest. Der Wert des Parameters `key-id` muss der Schlüssel-ARN des KMS-Schlüssels sein.
```
aws kms retire-grant \
--grant-id 1234a2345b8a4e350500d432bccf8ecd6506710e1391880c4f7f7140160c9af3 \
--key-id arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den Befehl `list-grants`, um zu bestätigen, dass die Erteilung zurückgezogen wurde.
Weitere Informationen finden Sie unter [Zurückziehen und Widerrufen von Erteilungen](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#grant-delete) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [RetireGrant](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/retire-grant.html)in der *AWS CLI Befehlsreferenz*.
### `revoke-grant`
Das folgende Codebeispiel zeigt die Verwendung`revoke-grant`.
**AWS CLI**
**So ziehen Sie eine Erteilung für einen Kundenhauptschlüssel zurück**
Im folgenden Beispiel für `revoke-grant` wird ein Zuschuss aus einem KMS-Schlüssel gelöscht. Der folgende Beispielbefehl legt die Parameter `grant-id` und `key-id` fest. Der Wert des Parameters `key-id` kann die Schlüssel-ID oder der Schlüssel-ARN des KMS-Schlüssels sein.
```
aws kms revoke-grant \
--grant-id 1234a2345b8a4e350500d432bccf8ecd6506710e1391880c4f7f7140160c9af3 \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den Befehl `list-grants`, um zu bestätigen, dass die Erteilung zurückgezogen wurde.
Weitere Informationen finden Sie unter [Zurückziehen und Widerrufen von Erteilungen](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#grant-delete) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [RevokeGrant](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/revoke-grant.html)in der *AWS CLI Befehlsreferenz*.
### `rotate-key-on-demand`
Das folgende Codebeispiel zeigt die Verwendung`rotate-key-on-demand`.
**AWS CLI**
**So führen Sie die On-Demand-Rotation eines KMS-Schlüssels durch**
Im folgenden Beispiel für `rotate-key-on-demand` wird sofort die Rotation des Schlüsselmaterials für den angegebenen KMS-Schlüssel initiiert.
```
aws kms rotate-key-on-demand \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Ausgabe:
```
{
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab"
}
```
Weitere Informationen finden Sie unter [So führen Sie die Schlüsselrotation bei Bedarf durch](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html#rotating-keys-on-demand) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [RotateKeyOnDemand](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/rotate-key-on-demand.html)in der *AWS CLI Befehlsreferenz*.
### `schedule-key-deletion`
Das folgende Codebeispiel zeigt die Verwendung`schedule-key-deletion`.
**AWS CLI**
**So planen Sie das Löschen eines kundenseitig verwalteten KMS-Schlüssels.**
Im folgenden Beispiel für `schedule-key-deletion` wird geplant, dass der angegebene kundenseitig verwaltete KMS-Schlüssel innerhalb von 15 Tagen gelöscht wird.
Der Parameter `--key-id` identifiziert den KMS-Schlüssel. In diesem Beispiel wird ein Schlüssel-ARN-Wert verwendet, Sie können jedoch entweder die Schlüssel-ID oder den ARN des KMS-Schlüssels verwenden. Der Parameter `--pending-window-in-days` gibt die Dauer der Wartezeit von 7 bis 30 Tagen an. Die Wartezeit beträgt standardmäßig 30 Tage. In diesem Beispiel wird der Wert 15 angegeben, der angibt, dass der KMS-Schlüssel 15 Tage nach Abschluss des Befehls dauerhaft gelöscht werden AWS soll.
```
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
```
Die Antwort enthält den Schlüssel-ARN, den Schlüsselstatus, die Wartezeit (`PendingWindowInDays`) und das Löschdatum in Unix-Zeit. Verwenden Sie die AWS KMS-Konsole, um das Löschdatum in Ortszeit anzuzeigen. KMS-Schlüssel im Schlüsselstatus `PendingDeletion` können nicht in kryptografischen Vorgängen verwendet werden.
```
{
"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
}
```
Weitere Informationen finden Sie unter [Löschen von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/deleting-keys.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [ScheduleKeyDeletion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/schedule-key-deletion.html)in der *AWS CLI Befehlsreferenz*.
### `sign`
Das folgende Codebeispiel zeigt die Verwendung`sign`.
**AWS CLI**
**Beispiel 1: So generieren Sie eine digitale Signatur für eine Nachricht**
Im folgenden Beispiel für `sign` wird eine kryptografische Signatur für eine Kurznachricht generiert. Die Ausgabe des Befehls enthält das mit base-64 codiertes Feld `Signature`, das Sie mit dem Befehl `verify` überprüfen können.
Sie müssen eine zu signierende Nachricht und einen Signierungsalgorithmus angeben, den Ihr asymmetrischer KMS-Schlüssel unterstützt. Verwenden Sie den Befehl `describe-key`, um den Signierungsalgorithmus für Ihren KMS-Schlüssel abzurufen.
In AWS CLI v2 muss der Wert des `message` Parameters Base64-codiert sein. Oder Sie können die Nachricht in einer Datei speichern und das `fileb://` Präfix verwenden, das die AWS CLI anweist, Binärdaten aus der Datei zu lesen.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem AWS Konto. Die Schlüssel-ID muss einen asymmetrischen KMS-Schlüssel mit der Schlüsselverwendung SIGN\$1VERIFY darstellen.
```
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
```
Ausgabe:
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"Signature": "ABCDEFhpyVYyTxbafE74ccSvEJLJr3zuoV1Hfymz4qv+/fxmxNLA7SE1SiF8lHw80fKZZ3bJ...",
"SigningAlgorithm": "RSASSA_PKCS1_V1_5_SHA_256"
}
```
Weitere Informationen zur Verwendung asymmetrischer KMS-Schlüssel in AWS KMS finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
**Beispiel 2: So speichern Sie eine digitale Signatur in einer Datei (Linux und macOs)**
Im folgenden Beispiel für `sign` wird eine kryptografische Signatur für eine Kurznachricht generiert, die in einer lokalen Datei gespeichert ist. Der Befehl ruft auch die `Signature` Eigenschaft aus der Antwort ab, dekodiert sie mit Base64 und speichert sie in der Datei. ExampleSignature Sie können die Signaturdatei in einem `verify`-Befehl verwenden, der die Signatur überprüft.
Der Befehl `sign` erfordert eine Base64-codierte Nachricht und einen Signaturalgorithmus, den Ihr asymmetrischer KMS-Schlüssel unterstützt. Verwenden Sie den Befehl `describe-key`, um den Signaturalgorithmus abzurufen, den Ihr KMS-Schlüssel unterstützt.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem Konto. AWS Die Schlüssel-ID muss einen asymmetrischen KMS-Schlüssel mit der Schlüsselverwendung SIGN\$1VERIFY darstellen.
```
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
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. In diesem Beispiel wird die Eigenschaft `Signature` der Ausgabe extrahiert und in einer Datei gespeichert.
Weitere Informationen zur Verwendung asymmetrischer KMS-Schlüssel in AWS KMS finden Sie unter [Asymmetrische Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
+ Weitere API-Informationen finden Sie unter [Sign](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/sign.html) in der *AWS CLI -Befehlsreferenz*.
### `tag-resource`
Das folgende Codebeispiel zeigt die Verwendung. `tag-resource`
**AWS CLI**
**So fügen Sie einem KMS-Schlüssel ein Tag hinzu**
Im folgenden Beispiel für `tag-resource` werden einem kundenseitig verwalteten KMS-Schlüssel die Tags `"Purpose":"Test"` und `"Dept":"IT"` hinzugefügt. Sie können Tags wie diese verwenden, um KMS-Schlüssel zu kennzeichnen und Kategorien von KMS-Schlüsseln für Berechtigungen und Prüfungen zu erstellen.
Verwenden Sie den Parameter `key-id`, um den KMS-Schlüssel anzugeben. In diesem Beispiel wird ein Schlüssel-ID-Wert verwendet, Sie können jedoch eine Schlüssel-ID oder einen Schlüssel-ARN in diesem Befehl verwenden.
```
aws kms tag-resource \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--tags TagKey='Purpose',TagValue='Test' TagKey='Dept',TagValue='IT'
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den `list-resource-tags` Befehl, um die Tags auf einem AWS KMS-KMS-Schlüssel anzuzeigen.
Weitere Informationen zur Verwendung von Tags in AWS KMS finden Sie unter [Tagging Keys](https://docs.aws.amazon.com/kms/latest/developerguide/tagging-keys.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/tag-resource.html)in der *AWS CLI Befehlsreferenz.*
### `untag-resource`
Das folgende Codebeispiel zeigt die Verwendung`untag-resource`.
**AWS CLI**
**So löschen Sie ein Tag aus einem KMS-Schlüssel**
Im folgenden Beispiel für `untag-resource` wird das Tag mit dem Schlüssel `"Purpose"` aus einem kundenseitig verwalteten KMS-Schlüssel gelöscht.
Verwenden Sie den Parameter `key-id`, um den KMS-Schlüssel anzugeben. In diesem Beispiel wird ein Schlüssel-ID-Wert verwendet, Sie können jedoch eine Schlüssel-ID oder einen Schlüssel-ARN in diesem Befehl verwenden. Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem AWS Konto.
```
aws kms untag-resource \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--tag-key 'Purpose'
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den `list-resource-tags` Befehl, um die Tags auf einem AWS KMS-KMS-Schlüssel anzuzeigen.
Weitere Informationen zur Verwendung von Tags in AWS KMS finden Sie unter [Tagging Keys](https://docs.aws.amazon.com/kms/latest/developerguide/tagging-keys.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/untag-resource.html)in der *AWS CLI Befehlsreferenz.*
### `update-alias`
Das folgende Codebeispiel zeigt die Verwendung`update-alias`.
**AWS CLI**
**So verknüpfen Sie einen Alias mit einem anderen KMS-Schlüssel**
Im folgenden Beispiel für `update-alias` wird der Alias `alias/test-key` einem anderen KMS-Schlüssel zugeordnet.
Der Parameter `--alias-name` gibt den Alias an. Der Wert des Aliasnamens muss mit `alias/` beginnen. Der Parameter `--target-key-id` gibt den KMS-Schlüssel an, der dem Alias zugeordnet werden soll. Sie müssen den aktuellen KMS-Schlüssel für den Alias nicht angeben.
```
aws kms update-alias \
--alias-name alias/test-key \
--target-key-id 1234abcd-12ab-34cd-56ef-1234567890ab
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den Befehl `list-aliases`, um den Alias zu suchen.
Weitere Informationen finden Sie unter [Aktualisieren von Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/alias-manage.html#alias-update) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [UpdateAlias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/update-alias.html)in der *AWS CLI Befehlsreferenz*.
### `update-custom-key-store`
Das folgende Codebeispiel zeigt die Verwendung`update-custom-key-store`.
**AWS CLI**
**Beispiel 1: So bearbeiten Sie den Anzeigenamen eines benutzerdefinierten Schlüsselspeichers**
Im folgenden Beispiel für `update-custom-key-store` wird der Name des benutzerdefinierten Schlüsselspeichers geändert. Dieses Beispiel funktioniert für einen AWS CloudHSM-Schlüsselspeicher oder einen externen Schlüsselspeicher.
Verwenden Sie die `custom-key-store-id`, um den Schlüsselspeicher zu identifizieren. Verwenden Sie den Parameter `new-custom-key-store-name`, um den neuen Anzeigenamen anzugeben.
Um den Anzeigenamen eines AWS CloudHSM-Schlüsselspeichers zu aktualisieren, müssen Sie zuerst die Verbindung zum Schlüsselspeicher trennen, z. B. mit dem `disconnect-custom-key-store` Befehl. Sie können den Anzeigenamen eines externen Schlüsselspeichers aktualisieren, während er verbunden oder getrennt ist. Verwenden Sie den `describe-custom-key-store`-Befehl, um den Verbindungsstatus Ihres benutzerdefinierten Schlüsselspeichers zu ermitteln.
```
aws kms update-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0 \
--new-custom-key-store-name ExampleKeyStore
```
Dieser Befehl gibt keine Daten zurück. Verwenden Sie einen Befehl `describe-custom-key-stores`, um zu überprüfen, ob der Befehl funktioniert hat.
Weitere Informationen zum Aktualisieren eines AWS CloudHSM-Schlüsselspeichers finden Sie unter [Bearbeiten der AWS CloudHSM-Schlüsselspeicher-Einstellungen im AWS Key](https://docs.aws.amazon.com/kms/latest/developerguide/update-keystore.html) *Management* Service Developer Guide.
Weitere Informationen zum Aktualisieren eines externen Schlüsselspeichers finden Sie unter [Bearbeiten der Eigenschaften eines externen Schlüsselspeichers](https://docs.aws.amazon.com/kms/latest/developerguide/update-xks-keystore.html) im *Entwicklerhandbuch für AWS Key Management Service*.
**Beispiel 2: Um das kmsuser-Passwort eines AWS CloudHSM-Schlüsselspeichers zu bearbeiten**
Im folgenden Beispiel für `update-custom-key-store` wird der Wert des Passworts `kmsuser` auf das aktuelle Passwort für den `kmsuser` im CloudHSM-Cluster aktualisiert, der dem angegebenen Schlüsselspeicher zugeordnet ist. Dieser Befehl ändert das Passwort `kmsuser` im Cluster nicht. Es teilt AWS KMS nur das aktuelle Passwort mit. Wenn KMS nicht über das aktuelle `kmsuser` Passwort verfügt, kann es keine Verbindung zum AWS CloudHSM-Schlüsselspeicher herstellen.
**HINWEIS:** Bevor Sie einen AWS CloudHSM-Schlüsselspeicher aktualisieren, müssen Sie die Verbindung trennen. Verwenden Sie den Befehl `disconnect-custom-key-store`. Nachdem der Befehl abgeschlossen ist, können Sie den AWS CloudHSM-Schlüsselspeicher erneut verbinden. Verwenden Sie den Befehl `connect-custom-key-store`.
```
aws kms update-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0 \
--key-store-password ExamplePassword
```
Dieser Befehl gibt keine Ausgabe zurück. Verwenden Sie einen `describe-custom-key-stores`-Befehl, um zu überprüfen, ob die Änderung wirksam war.
Weitere Informationen zum Aktualisieren eines AWS CloudHSM-Schlüsselspeichers finden Sie unter [Bearbeiten der AWS CloudHSM-Schlüsselspeicher-Einstellungen im AWS Key](https://docs.aws.amazon.com/kms/latest/developerguide/update-keystore.html) *Management* Service Developer Guide.
**Beispiel 3: So bearbeiten Sie den AWS CloudHSM-Cluster eines AWS CloudHSM-Schlüsselspeichers**
Im folgenden Beispiel wird der AWS CloudHSM-Cluster, der einem AWS CloudHSM-Schlüsselspeicher zugeordnet ist, in einen verwandten Cluster geändert, z. B. ein anderes Backup desselben Clusters.
**HINWEIS:** Bevor Sie einen AWS CloudHSM-Schlüsselspeicher aktualisieren, müssen Sie die Verbindung trennen. Verwenden Sie den Befehl `disconnect-custom-key-store`. Nachdem der Befehl abgeschlossen ist, können Sie den AWS CloudHSM-Schlüsselspeicher erneut verbinden. Verwenden Sie den Befehl `connect-custom-key-store`.
```
aws kms update-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0 \
--cloud-hsm-cluster-id cluster-1a23b4cdefg
```
Dieser Befehl gibt keine Ausgabe zurück. Verwenden Sie einen `describe-custom-key-stores`-Befehl, um zu überprüfen, ob die Änderung wirksam war.
Weitere Informationen zum Aktualisieren eines AWS CloudHSM-Schlüsselspeichers finden Sie unter [Bearbeiten der AWS CloudHSM-Schlüsselspeicher-Einstellungen im AWS Key](https://docs.aws.amazon.com/kms/latest/developerguide/update-keystore.html) *Management* Service Developer Guide.
**Beispiel 4: So bearbeiten Sie die Proxy-Authentifizierungsanmeldeinformationen eines externen Schlüsselspeichers**
Im folgenden Beispiel werden die Proxy-Authentifizierungsanmeldeinformationen für Ihren externen Schlüsselspeicher aktualisiert. Sie müssen den `raw-secret-access-key` und die `access-key-id` auch dann angeben, wenn Sie nur einen der Werte ändern. Sie können dieses Feature verwenden, um ungültige Anmeldeinformationen zu korrigieren oder die Anmeldeinformationen zu ändern, wenn der externe Schlüsselspeicher-Proxy sie rotiert.
Richten Sie die Anmeldeinformationen für die Proxyauthentifizierung für AWS KMS in Ihrem externen Schlüsselspeicher ein. Verwenden Sie dann diesen Befehl, um die Anmeldeinformationen für KMS bereitzustellen. AWS AWS KMS verwendet diese Anmeldeinformationen, um seine Anfragen an Ihren externen Schlüsselspeicher-Proxy zu signieren.
Sie können die Anmeldeinformationen für die Proxy-Authentifizierung aktualisieren, während der externe Schlüsselspeicher verbunden oder getrennt ist. Verwenden Sie den `describe-custom-key-store`-Befehl, um den Verbindungsstatus Ihres benutzerdefinierten Schlüsselspeichers zu ermitteln.
```
aws kms update-custom-key-store \
--custom-key-store-id cks-1234567890abcdef0 \
--xks-proxy-authentication-credential "AccessKeyId=ABCDE12345670EXAMPLE, RawSecretAccessKey=DXjSUawnel2fr6SKC7G25CNxTyWKE5PF9XX6H/u9pSo="
```
Dieser Befehl gibt keine Ausgabe zurück. Verwenden Sie einen `describe-custom-key-stores`-Befehl, um zu überprüfen, ob die Änderung wirksam war.
Weitere Informationen zum Aktualisieren eines externen Schlüsselspeichers finden Sie unter [Bearbeiten der Eigenschaften eines externen Schlüsselspeichers](https://docs.aws.amazon.com/kms/latest/developerguide/update-xks-keystore.html) im *Entwicklerhandbuch für AWS Key Management Service*.
**Beispiel 5: So bearbeiten Sie die Proxy-Konnektivität eines externen Schlüsselspeichers**
Im folgenden Beispiel wird die Proxy-Konnektivitätsoption des externen Schlüsselspeichers von der Konnektivität eines öffentlichen Endpunkts in die Konnektivität des VPC-Endpunkt-Service geändert. Zusätzlich zur Änderung des Werts `xks-proxy-connectivity` müssen Sie den Wert `xks-proxy-uri-endpoint` so ändern, dass er den privaten DNS-Namen widerspiegelt, der dem VPC-Endpunktservice zugeordnet ist. Sie müssen auch den Wert `xks-proxy-vpc-endpoint-service-name` hinzufügen.
**HINWEIS:** Bevor Sie die Konnektivität des Proxys eines externen Speichers aktualisieren, müssen Sie dessen Verbindung trennen. Verwenden Sie den Befehl `disconnect-custom-key-store`. Nach Abschluss des Befehls können Sie den externen Schlüsselspeicher mit dem Befehl `connect-custom-key-store` erneut verbinden.
```
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"
```
Dieser Befehl gibt keine Ausgabe zurück. Verwenden Sie einen `describe-custom-key-stores`-Befehl, um zu überprüfen, ob die Änderung wirksam war.
Weitere Informationen zum Aktualisieren eines externen Schlüsselspeichers finden Sie unter [Bearbeiten der Eigenschaften eines externen Schlüsselspeichers](https://docs.aws.amazon.com/kms/latest/developerguide/update-xks-keystore.html) im *Entwicklerhandbuch für AWS Key Management Service*.
+ Einzelheiten zur API finden Sie unter [UpdateCustomKeyStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/update-custom-key-store.html)*Befehlsreferenz.*
### `update-key-description`
Das folgende Codebeispiel zeigt die Verwendung`update-key-description`.
**AWS CLI**
**Beispiel 1: So fügen Sie einem kundenseitig verwalteten KMS-Schlüssel eine Beschreibung hinzu oder ändern sie**
Im folgenden Beispiel für `update-key-description` wird einem kundenseitig verwalteten KMS-Schlüssel eine Beschreibung hinzugefügt. Sie können denselben Befehl verwenden, um eine vorhandene Beschreibung zu ändern.
Der `--key-id`-Parameter identifiziert den KMS-Schlüssel im Befehl. In diesem Beispiel wird ein Schlüssel-ARN-Wert verwendet, Sie können jedoch entweder die Schlüssel-ID oder Schlüssel-ARN des KMS-Schlüssels verwenden. Der Parameter `--description` gibt die neue Beschreibung an. Der Wert dieses Parameters ersetzt die aktuelle Beschreibung des KMS-Schlüssels, falls vorhanden.
```
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"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den Befehl `describe-key`, um die Beschreibung eines KMS-Schlüssels anzuzeigen.
Weitere Informationen finden Sie [UpdateKeyDescription](https://docs.aws.amazon.com/cli/latest/reference/kms/update-key-description.html)in der *API-Referenz für den AWS Key Management Service*.
**Beispiel 2: So löschen Sie die Beschreibung eines kundenseitig verwalteten KMS-Schlüssels**
Im folgenden Beispiel für `update-key-description` wird die Beschreibung eines kundenseitig verwalteten KMS-Schlüssels gelöscht.
Der `--key-id`-Parameter identifiziert den KMS-Schlüssel im Befehl. In diesem Beispiel wird ein Schlüssel-ID-Wert verwendet, Sie können jedoch entweder die Schlüssel-ID oder den Schlüssel-ARN des KMS-Schlüssels verwenden. Der Parameter `--description` mit einem leeren Zeichenfolgenwert ('') löscht die vorhandene Beschreibung.
```
aws kms update-key-description \
--key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
--description ''
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben. Verwenden Sie den Befehl „describe-key“, um die Beschreibung eines KMS-Schlüssels anzuzeigen.
Weitere Informationen finden Sie [UpdateKeyDescription](https://docs.aws.amazon.com/cli/latest/reference/kms/update-key-description.html)in der *API-Referenz für den AWS Key Management Service*.
+ Einzelheiten zur API finden Sie [UpdateKeyDescription](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/update-key-description.html)unter *AWS CLI Befehlsreferenz*.
### `verify-mac`
Das folgende Codebeispiel zeigt die Verwendung`verify-mac`.
**AWS CLI**
**Beispiel 1: So überprüfen Sie einen HMAC**
Der folgende Befehl `verify-mac` generiert einen HMAC für eine bestimmte Nachricht, HMAC-KMS-Schlüssel und den MAC-Algorithmus. Ein Wert von 'true' im MacValid Wert in der Antwort gibt an, dass der HMAC gültig ist.
In AWS CLI v2 muss der Wert des `message` Parameters Base64-codiert sein. Oder Sie können die Nachricht in einer Datei speichern und das `fileb://` Präfix verwenden, das die AWS CLI anweist, Binärdaten aus der Datei zu lesen.
Der von Ihnen angegebene MAC kann nicht Base64-codiert sein. Hilfe zum Entschlüsseln der MAC-Adresse, die der Befehl `generate-mac` zurückgibt, finden Sie in den Beispielen für den Befehl `generate-mac`.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem AWS Konto. Die Schlüssel-ID muss einen HMAC-KMS-Schlüssel mit der Schlüsselverwendung von `GENERATE_VERIFY_MAC` darstellen.
```
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
```
Ausgabe:
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"MacValid": true,
"MacAlgorithm": "HMAC_SHA_384"
}
```
Weitere Informationen zur Verwendung von HMAC-KMS-Schlüsseln in AWS KMS finden Sie unter [HMAC-Schlüssel in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/hmac.html) im *AWS Key Management Service Developer Guide*.
+ Einzelheiten zur API finden Sie [VerifyMac](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/verify-mac.html)in der *AWS CLI Befehlsreferenz*.
### `verify`
Das folgende Codebeispiel zeigt die Verwendung`verify`.
**AWS CLI**
**So überprüfen Sie eine digitale Signatur**
Mit dem folgenden Befehl für `verify` wird eine kryptografische Signatur für eine kurze, Base64-kodierte Nachricht überprüft. Die Schlüssel-ID, die Nachricht, der Nachrichtentyp und der Signaturalgorithmus müssen mit denen identisch sein, die zum Signieren der Nachricht verwendet wurden.
In AWS CLI v2 muss der Wert des `message` Parameters Base64-codiert sein. Oder Sie können die Nachricht in einer Datei speichern und das `fileb://` Präfix verwenden, das die AWS CLI anweist, Binärdaten aus der Datei zu lesen.
Die von Ihnen angegebene Signatur kann nicht Base64-codiert sein. Hilfe zum Entschlüsseln der Signatur, die der Befehl `sign` zurückgibt, finden Sie in den Beispielen für den Befehl `sign`.
Die Ausgabe des Befehls enthält ein boolesches `SignatureValid`-Feld, das angibt, dass die Signatur verifiziert wurde. Wenn die Signaturüberprüfung fehlschlägt, schlägt auch der Befehl `verify` fehl.
Bevor Sie diesen Befehl ausführen, ersetzen Sie die Beispielschlüssel-ID durch eine gültige Schlüssel-ID aus Ihrem AWS Konto.
```
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
```
Ausgabe:
```
{
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"SignatureValid": true,
"SigningAlgorithm": "RSASSA_PKCS1_V1_5_SHA_256"
}
```
Weitere Informationen zur Verwendung asymmetrischer KMS-Schlüssel in AWS KMS finden Sie unter [Using asymmetric keys](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) im *AWS Key Management Service Developer Guide*.
+ API-Details finden Sie unter [Verify](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/verify.html) in der *AWS CLI -Befehlsreferenz*.