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.
# Schlüsselringe
[Unterstützte Programmiersprachenimplementierungen verwenden *Schlüsselringe* zur Verschlüsselung von Umschlägen.](concepts.md#envelope-encryption) Schlüsselbunde generieren, verschlüsseln und entschlüsseln Datenschlüssel. Schlüsselbunde bestimmen die Quelle der eindeutigen Datenschlüssel, die jede Nachricht schützen, und der [Umschließungsschlüssel, die diesen Datenschlüssel](concepts.md#master-key) verschlüsseln. Sie geben bei der Verschlüsselung einen Schlüsselbund und bei der Entschlüsselung denselben oder einen anderen Schlüsselbund an. Sie können die vom SDK bereitgestellten Schlüsselbunde verwenden oder Ihren eigenen kompatiblen, benutzerdefinierten Schlüsselbunde schreiben.
Sie können jeden Schlüsselbund einzeln verwenden oder Schlüsselbunde in einen [Multi-Schlüsselbund](use-multi-keyring.md) kombinieren. Obwohl die meisten Schlüsselbunde Datenschlüssel generieren, verschlüsseln und entschlüsseln können, können Sie einen Schlüsselbund erstellen, der nur eine bestimmte Operation ausführt, wie z. B. einen Schlüsselbund, der nur Datenschlüssel generiert. Dieser Schlüsselbund kann dann in Kombination mit anderen verwendet werden.
Wir empfehlen Ihnen, einen Schlüsselbund zu verwenden, der Ihre Wrapping-Schlüssel schützt und kryptografische Operationen innerhalb einer sicheren Grenze ausführt, wie z. B. den AWS KMS Schlüsselbund, der diesen Never Never Leave () AWS KMS keys unverschlüsselt verwendet. [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)AWS KMS Sie können auch einen Schlüsselbund schreiben, bei dem Schlüssel zum Umschließen von Schlüsseln verwendet werden, die in Ihren Hardware-Sicherheitsmodulen (HSMs) gespeichert oder durch andere Master-Key-Dienste geschützt sind. Weitere Informationen finden Sie im Thema [Schlüsselbundschnittstelle](https://github.com/awslabs/aws-encryption-sdk-specification/blob/master/framework/keyring-interface.md) in der *AWS Encryption SDK -Spezifikation*.
Schlüsselringe spielen die Rolle der [Hauptschlüssel und [Hauptschlüsselanbieter](concepts.md#master-key-provider)](concepts.md#master-key), die in anderen Programmiersprachenimplementierungen verwendet werden. Wenn Sie verschiedene Sprachimplementierungen von verwenden, um Ihre Daten AWS Encryption SDK zu verschlüsseln und zu entschlüsseln, stellen Sie sicher, dass Sie kompatible Schlüsselringe und Hauptschlüsselanbieter verwenden. Details hierzu finden Sie unter [Schlüsselbund-Kompatibilität](#keyring-compatibility).
In diesem Thema wird erklärt, wie Sie die Schlüsselbundfunktion von verwenden AWS Encryption SDK und wie Sie einen Schlüsselbund auswählen.
## Funktionsweise von Schlüsselbunden
Wenn Sie Daten verschlüsseln, AWS Encryption SDK fragt der den Schlüsselbund nach Verschlüsselungsmaterial. Der Schlüsselbund gibt einen Klartext-Datenschlüssel und eine Kopie des Datenschlüssels zurück, der durch die einzelnen Schlüssel im Schlüsselbund verschlüsselt wird. Der AWS Encryption SDK verwendet den Klartext-Schlüssel, um die Daten zu verschlüsseln, und zerstört dann den Klartext-Datenschlüssel. Anschließend wird eine [verschlüsselte Nachricht AWS Encryption SDK zurückgegeben, die die verschlüsselten](concepts.md#message) Datenschlüssel und die verschlüsselten Daten enthält.
![\[Verschlüsselung mit einem Schlüsselbund mit mehreren Wrapping-Schlüsseln.\]](http://docs.aws.amazon.com/de_de/encryption-sdk/latest/developer-guide/images/keyring-encrypt.png)
Wenn Sie Daten entschlüsseln, können Sie denselben Schlüsselbund verwenden, den Sie zum Verschlüsseln der Daten verwendet haben, oder einen anderen. Um die Daten zu entschlüsseln, muss ein Entschlüsselungsschlüsselbund mindestens einen Umschließungsschlüssel im Schlüsselbund enthalten (oder Zugriff darauf haben).
Der AWS Encryption SDK übergibt die verschlüsselten Datenschlüssel aus der verschlüsselten Nachricht an den Schlüsselbund und fordert den Schlüsselbund auf, einen davon zu entschlüsseln. Der Schlüsselbund verwendet seine Umhüllungsschlüssel zum Entschlüsseln eines der verschlüsselten Datenschlüssel und gibt einen Klartext-Datenschlüssel zurück. Das AWS Encryption SDK entschlüsselt die Daten mithilfe des Klartext-Datenschlüssels. Wenn keiner der Umhüllungsschlüssel im Schlüsselbund einen der verschlüsselten Datenschlüssel entschlüsseln kann, schlägt der Entschlüsselungsvorgang fehl.
![\[Entschlüsseln mit einem Schlüsselbund.\]](http://docs.aws.amazon.com/de_de/encryption-sdk/latest/developer-guide/images/keyring-decrypt.png)
Sie können einen einzelnen Schlüsselbund verwenden oder Schlüsselbunde desselben Typs oder eines anderen Typs in einem [Multi-Schlüsselbund](use-multi-keyring.md) kombinieren. Wenn Sie Daten verschlüsseln, gibt der Multi-Schlüsselbund eine Kopie des Datenschlüssels zurück, der von allen Umhüllungsschlüsseln in allen Schlüsselbunden verschlüsselt wurde, aus denen der Multi-Schlüsselbund besteht. Sie können die Daten mithilfe eines Schlüsselbundes entschlüsseln, wobei jeder der Schlüssel im Mehrfachschlüsselbund eingeschlossen ist.
## Schlüsselbund-Kompatibilität
Obwohl die verschiedenen Sprachimplementierungen von einige architektonische Unterschiede AWS Encryption SDK aufweisen, sind sie vollständig kompatibel und unterliegen sprachlichen Einschränkungen. Sie können Ihre Daten mit einer Sprachimplementierung verschlüsseln und mit jeder anderen Sprachimplementierung entschlüsseln. Sie müssen jedoch dieselben oder entsprechende Wrapping-Schlüssel verwenden, um Ihre Datenschlüssel zu verschlüsseln und zu entschlüsseln. Informationen zu Spracheinschränkungen finden Sie im Thema zu den einzelnen Sprachimplementierungen, z. B. [Kompatibilität der AWS-Verschlüsselungs-SDK for JavaScript](javascript-compatibility.md) im AWS-Verschlüsselungs-SDK for JavaScript Thema.
Schlüsselringe werden in den folgenden Programmiersprachen unterstützt:
+ AWS-Verschlüsselungs-SDK for C
+ AWS-Verschlüsselungs-SDK for JavaScript
+ AWS Encryption SDK für .NET
+ Version 3. *x* der AWS-Verschlüsselungs-SDK for Java
+ Ausführung 4. *x* von AWS-Verschlüsselungs-SDK for Python, wenn es mit der optionalen Abhängigkeit der [Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) verwendet wird.
+ AWS Encryption SDK für Rust
+ AWS Encryption SDK für Go
### Unterschiedliche Anforderungen für Verschlüsselungsschlüsselringe
In anderen AWS Encryption SDK Sprachimplementierungen als dem AWS-Verschlüsselungs-SDK for C müssen alle Schlüssel in einem Verschlüsselungsschlüsselbund (oder einem Masterschlüsselbund) oder einem Masterschlüsselanbieter in der Lage sein, den Datenschlüssel zu verschlüsseln. Wenn ein Umschließungsschlüssel nicht verschlüsselt werden kann, schlägt die Verschlüsselungsmethode fehl. Daher muss der Anrufer über die [erforderlichen Berechtigungen](use-kms-keyring.md#kms-keyring-permissions) für alle Schlüssel im Schlüsselbund verfügen. Wenn Sie einen Discovery-Schlüsselbund verwenden, um Daten allein oder in einem Mehrfachschlüsselbund zu verschlüsseln, schlägt der Verschlüsselungsvorgang fehl.
Die Ausnahme ist der AWS-Verschlüsselungs-SDK for C, bei dem der Verschlüsselungsvorgang einen standardmäßigen Erkennungsschlüsselbund ignoriert, aber fehlschlägt, wenn Sie einen Erkennungsschlüsselbund mit mehreren Regionen angeben, allein oder in einem Schlüsselbund mit mehreren Schlüsselbunden.
### Kompatible Schlüsselbunde und Masterschlüssel-Anbieter
Die folgende Tabelle zeigt, welche Hauptschlüssel und Hauptschlüsselanbieter mit den mitgelieferten Schlüsselbunden kompatibel sind. AWS Encryption SDK Geringfügige Inkompatibilitäten aufgrund von Spracheinschränkungen werden im Thema über die Sprachimplementierung beschrieben.
| Schlüsselbund: | Hauptschlüsselanbieter: |
| --- | --- |
| [AWS KMS Schlüsselring](use-kms-keyring.md) | [KMSMasterSchlüssel (Java)](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/kms/KmsMasterKey.html) [KMSMasterKeyProvider (Java)](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/kms/KmsMasterKeyProvider.html) [KMSMasterSchlüssel (Python)](https://aws-encryption-sdk-python.readthedocs.io/en/latest/generated/aws_encryption_sdk.key_providers.kms.html) [KMSMasterKeyProvider (Python)](https://aws-encryption-sdk-python.readthedocs.io/en/latest/generated/aws_encryption_sdk.key_providers.kms.html#aws_encryption_sdk.key_providers.kms.KMSMasterKeyProvider) Die AWS-Verschlüsselungs-SDK for Python und enthalten AWS-Verschlüsselungs-SDK for Java keinen Hauptschlüssel oder Hauptschlüsselanbieter, was dem [AWS KMS regionalen Discovery-Schlüsselbund](use-kms-keyring.md#kms-keyring-regional) entspricht. |
| [AWS KMS Hierarchischer Schlüsselbund](use-hierarchical-keyring.md) | Wird von den folgenden Programmiersprachen und Versionen unterstützt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/encryption-sdk/latest/developer-guide/choose-keyring.html) |
| [AWS KMS ECDH-Schlüsselanhänger](use-kms-ecdh-keyring.md) | Wird von den folgenden Programmiersprachen und Versionen unterstützt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/encryption-sdk/latest/developer-guide/choose-keyring.html) |
| [Unformatierter AES-Schlüsselbund](use-raw-aes-keyring.md) | Wenn sie mit symmetrischen Verschlüsselungsschlüsseln verwendet werden:[JceMasterKey](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/jce/JceMasterKey.html)(Java)[RawMasterKey](https://aws-encryption-sdk-python.readthedocs.io/en/latest/generated/aws_encryption_sdk.key_providers.raw.html#aws_encryption_sdk.key_providers.raw.RawMasterKey)(Python) |
| [Unformatierter RSA-Schlüsselbund](use-raw-rsa-keyring.md) | Wenn sie mit asymmetrischen Verschlüsselungsschlüsseln verwendet werden:[JceMasterKey](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/jce/JceMasterKey.html)(Java)[RawMasterKey](https://aws-encryption-sdk-python.readthedocs.io/en/latest/generated/aws_encryption_sdk.key_providers.raw.html#aws_encryption_sdk.key_providers.raw.RawMasterKey)(Python) Der Raw RSA-Schlüsselbund unterstützt keine asymmetrischen KMS-Schlüssel. Wenn Sie asymmetrische RSA-KMS-Schlüssel verwenden möchten, Version 4. *x* und höher von AWS Encryption SDK for .NET unterstützen AWS KMS Schlüsselringe, die symmetrische Verschlüsselung (`SYMMETRIC_DEFAULT`) oder asymmetrisches RSA verwenden. AWS KMS keys |
| [Roher ECDH-Schlüsselbund](use-raw-ecdh-keyring.md) | Wird von den folgenden Programmiersprachen und Versionen unterstützt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/encryption-sdk/latest/developer-guide/choose-keyring.html) |
# AWS KMS Schlüsselringe
Ein AWS KMS Schlüsselbund wird verwendet, [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)um Datenschlüssel zu generieren, zu verschlüsseln und zu entschlüsseln. AWS Key Management Service (AWS KMS) schützt Ihre KMS-Schlüssel und führt kryptografische Operationen innerhalb der FIPS-Grenze durch. Wir empfehlen, wann immer möglich einen AWS KMS Schlüsselbund oder einen Schlüsselbund mit ähnlichen Sicherheitseigenschaften zu verwenden.
Alle Programmiersprachenimplementierungen, die Schlüsselringe unterstützen, unterstützen Schlüsselbunde, die AWS KMS KMS-Schlüssel mit symmetrischer Verschlüsselung verwenden. Die folgenden Programmiersprachenimplementierungen unterstützen auch AWS KMS Schlüsselringe, die asymmetrische RSA-KMS-Schlüssel verwenden:
+ Version 3. *x* der AWS-Verschlüsselungs-SDK for Java
+ Ausführung 4. *x* und höher von AWS Encryption SDK für .NET
+ Version 4. *x* von AWS-Verschlüsselungs-SDK for Python, wenn es mit der optionalen Abhängigkeit der [Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) verwendet wird.
+ Version 1. *x* von der AWS Encryption SDK für Rust
+ Version 0.1. *x* oder höher von AWS Encryption SDK for Go
Wenn Sie versuchen, in einer anderen Sprachimplementierung einen asymmetrischen KMS-Schlüssel in einen Verschlüsselungsschlüsselbund aufzunehmen, schlägt der Verschlüsselungsaufruf fehl. Wenn Sie ihn in einen Schlüsselbund für die Entschlüsselung aufnehmen, wird er ignoriert.
[Ab Version 2.3 können Sie einen Schlüssel AWS KMS mit mehreren Regionen in einem AWS KMS Schlüsselbund oder einem Hauptschlüsselanbieter verwenden. ](about-versions.md#version2.3)*x* der Version AWS Encryption SDK und Version 3.0. *x* der AWS Encryption CLI. Einzelheiten und Beispiele zur Verwendung des multi-Region-aware Symbols finden Sie unter[Verwenden Sie mehrere Regionen AWS KMS keys](configure.md#config-mrks). Informationen zu Schlüsseln für mehrere Regionen finden Sie unter [Verwenden von Schlüsseln für mehrere Regionen](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) im *AWS Key Management Service Entwicklerhandbuch*.
**Anmerkung**
Alle Erwähnungen von *KMS-Schlüsselanhängern im AWS Encryption SDK beziehen sich auf Schlüsselringe*. AWS KMS
AWS KMS Bei Schlüsselanhängern gibt es zwei Arten von Wickelschlüsseln:
+ **Generatorschlüssel**: Generiert einen Klartext-Datenschlüssel und verschlüsselt ihn. Ein Schlüsselbund, der Daten verschlüsselt, muss einen Generatorschlüssel haben.
+ **Zusätzliche Schlüssel**: Verschlüsselt den Klartext-Datenschlüssel, den der Generatorschlüssel generiert hat. AWS KMS Schlüsselbunde können null oder mehr zusätzliche Schlüssel haben.
Sie müssen über einen Generatorschlüssel verfügen, um Nachrichten zu verschlüsseln. Wenn ein AWS KMS Schlüsselbund nur einen KMS-Schlüssel hat, wird dieser Schlüssel verwendet, um den Datenschlüssel zu generieren und zu verschlüsseln. Bei der Entschlüsselung ist der Generatorschlüssel optional, und die Unterscheidung zwischen Generatorschlüsseln und zusätzlichen Schlüsseln wird ignoriert.
Wie alle Schlüsselanhänger können AWS KMS Schlüsselringe unabhängig voneinander oder in einem [Mehrfachschlüsselbund mit anderen Schlüsselanhängern desselben](use-multi-keyring.md) oder eines anderen Typs verwendet werden.
**Topics**
+ [AWS KMS Erforderliche Berechtigungen für Schlüsselanhänger](#kms-keyring-permissions)
+ [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id)
+ [Einen Schlüsselbund erstellen AWS KMS](#kms-keyring-encrypt)
+ [Verwenden eines Discovery-Schlüsselbunds AWS KMS](#kms-keyring-discovery)
+ [Verwenden Sie einen AWS KMS regionalen Discovery-Schlüsselbund](#kms-keyring-regional)
## AWS KMS Erforderliche Berechtigungen für Schlüsselanhänger
Das benötigt AWS Encryption SDK kein AWS-Konto und es hängt auch nicht von einem ab. AWS-Service Um einen AWS KMS Schlüsselbund verwenden zu können, benötigen Sie jedoch eine AWS-Konto und die folgenden Mindestberechtigungen für AWS KMS keys den Schlüsselbund.
+ Um mit einem AWS KMS Schlüsselbund zu verschlüsseln, benötigen Sie die [kms: GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) -Berechtigung für den Generatorschlüssel. Sie benötigen die [kms:Encrypt-Berechtigung für alle zusätzlichen](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) Schlüssel im Schlüsselbund. AWS KMS
+ Um mit einem AWS KMS Schlüsselbund zu entschlüsseln, benötigen Sie die [kms:Decrypt-Berechtigung](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) für mindestens einen Schlüssel im Schlüsselbund. AWS KMS
+ Um mit einem Mehrfachschlüsselbund zu verschlüsseln, der aus Schlüsselbunden besteht, benötigen Sie die kms-Berechtigung für den AWS KMS Generatorschlüssel im Generator-Schlüsselbund[. GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) Sie benötigen die [kms:Encrypt-Berechtigung](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) für alle anderen Schlüssel in allen anderen Schlüsselbunden. AWS KMS
+ Um mit einem asymmetrischen AWS KMS RSA-Schlüsselbund zu verschlüsseln, benötigen Sie [kms: GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) oder [kms:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) nicht, da Sie bei der Erstellung des Schlüsselbunds das Material der öffentlichen Schlüssel angeben müssen, das Sie für die Verschlüsselung verwenden möchten. Bei der Verschlüsselung mit diesem Schlüsselbund werden keine Anrufe getätigt. AWS KMS [Um mit einem asymmetrischen AWS KMS RSA-Schlüsselbund zu entschlüsseln, benötigen Sie die kms:Decrypt-Berechtigung.](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
*Ausführliche Informationen zu den Berechtigungen für finden Sie unter [KMS-Schlüsselzugriff AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html) und -berechtigungen im Entwicklerhandbuch.AWS Key Management Service *
## Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund
Ein AWS KMS Schlüsselbund kann einen oder mehrere enthalten. AWS KMS keys Um AWS KMS key in einem AWS KMS Schlüsselbund eine anzugeben, verwenden Sie eine unterstützte AWS KMS Schlüssel-ID. Die Schlüsselbezeichner, die Sie zur Identifizierung eines AWS KMS key in einem Schlüsselbund verwenden können, variieren je nach Vorgang und Sprachimplementierung. *Einzelheiten zu den Schlüsselbezeichnern für einen AWS KMS key finden Sie unter [Schlüsselkennungen](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) im Entwicklerhandbuch.AWS Key Management Service *
Es hat sich bewährt, die spezifischste Schlüssel-ID zu verwenden, die für Ihre Aufgabe praktikabel ist.
+ In einem Verschlüsselungsschlüsselbund für können Sie einen [Schlüssel-ARN oder [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) verwenden AWS-Verschlüsselungs-SDK for C, um KMS-Schlüssel zu identifizieren. In allen anderen Sprachimplementierungen können Sie eine [Schlüssel-ID, einen [Schlüssel-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id), einen [Aliasnamen oder einen [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) verwenden, um Daten zu verschlüsseln.
+ In einem Entschlüsselungsschlüsselbund müssen Sie einen Schlüssel-ARN verwenden, um AWS KMS keys zu identifizieren. Diese Anforderung gilt für alle Sprachenimplementierungen des AWS Encryption SDK. Details hierzu finden Sie unter [Auswahl von Schlüsseln zum Umbrechen](configure.md#config-keys).
+ In einem Schlüsselbund, der für die Verschlüsselung und Entschlüsselung verwendet wird, müssen Sie einen Schlüssel-ARN verwenden, um AWS KMS keys zu identifizieren. Diese Anforderung gilt für alle Sprachenimplementierungen des AWS Encryption SDK.
Wenn Sie einen Aliasnamen oder Alias-ARN für einen KMS-Schlüssel in einem Verschlüsselungsschlüsselbund angeben, speichert der Verschlüsselungsvorgang den Schlüssel-ARN, der derzeit mit dem Alias verknüpft ist, in den Metadaten des verschlüsselten Datenschlüssels. Der Alias wird nicht gespeichert. Änderungen am Alias wirken sich nicht auf den KMS-Schlüssel aus, der zum Entschlüsseln Ihrer verschlüsselten Datenschlüssel verwendet wird.
## Einen Schlüsselbund erstellen AWS KMS
Sie können jeden AWS KMS Schlüsselbund mit einem AWS KMS key oder mehreren Schlüsselbändern AWS KMS keys im selben oder einem anderen AWS-Konten und konfigurieren. AWS-Regionen Dabei AWS KMS keys muss es sich um einen KMS-Schlüssel mit symmetrischer Verschlüsselung (SYMMETRIC\$1DEFAULT) oder um einen asymmetrischen RSA-KMS-Schlüssel handeln. [Sie können auch einen KMS-Schlüssel mit symmetrischer Verschlüsselung für mehrere Regionen verwenden.](configure.md#config-mrks) [Sie können einen oder mehrere AWS KMS Schlüsselbunde in einem Mehrfachschlüsselbund verwenden.](use-multi-keyring.md)
Sie können einen AWS KMS Schlüsselbund erstellen, der Daten ver- und entschlüsselt, oder Sie können AWS KMS Schlüsselbunde speziell zum Verschlüsseln oder Entschlüsseln erstellen. Wenn Sie einen AWS KMS Schlüsselbund zum Verschlüsseln von Daten erstellen, müssen Sie einen *Generatorschlüssel angeben. Dieser wird verwendet, um einen Klartext-Datenschlüssel* zu generieren und AWS KMS key diesen zu verschlüsseln. Der Datenschlüssel hat mathematisch nichts mit dem KMS-Schlüssel zu tun. Wenn Sie möchten, können Sie dann weitere angeben, AWS KMS keys die denselben Klartext-Datenschlüssel verschlüsseln. Um ein durch diesen Schlüsselbund geschütztes verschlüsseltes Feld zu entschlüsseln, muss der von Ihnen verwendete Entschlüsselungsschlüsselbund mindestens einen der im Schlüsselbund AWS KMS keys definierten Werte enthalten, oder nein. AWS KMS keys[(Ein AWS KMS Schlüsselbund ohne AWS KMS keys wird als Discovery-Schlüsselbund bezeichnet.)AWS KMS](#kms-keyring-discovery)
In anderen AWS Encryption SDK Sprachimplementierungen als dem müssen alle Schlüssel AWS-Verschlüsselungs-SDK for C, die in einen Verschlüsselungsschlüsselbund oder einen Mehrfachschlüsselbund eingeschlossen werden, in der Lage sein, den Datenschlüssel zu verschlüsseln. Wenn ein Wrapping-Schlüssel nicht verschlüsselt werden kann, schlägt die Verschlüsselungsmethode fehl. Daher muss der Anrufer über die [erforderlichen Berechtigungen](#kms-keyring-permissions) für alle Schlüssel im Schlüsselbund verfügen. Wenn Sie einen Discovery-Schlüsselbund verwenden, um Daten allein oder in einem Mehrfachschlüsselbund zu verschlüsseln, schlägt der Verschlüsselungsvorgang fehl. Die Ausnahme ist der AWS-Verschlüsselungs-SDK for C, bei dem der Verschlüsselungsvorgang einen standardmäßigen Erkennungsschlüsselbund ignoriert, aber fehlschlägt, wenn Sie einen Erkennungsschlüsselbund mit mehreren Regionen angeben, allein oder in einem Schlüsselbund mit mehreren Schlüsselbunden.
In den folgenden Beispielen wird ein AWS KMS Schlüsselbund mit einem Generatorschlüssel und einem zusätzlichen Schlüssel erstellt. Sowohl der Generatorschlüssel als auch der Zusatzschlüssel sind KMS-Schlüssel mit symmetrischer Verschlüsselung. In diesen Beispielen wird der [Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) verwendet ARNs, um die KMS-Schlüssel zu identifizieren. Dies ist eine bewährte Methode für AWS KMS Schlüsselringe, die zur Verschlüsselung verwendet werden, und eine Voraussetzung für AWS KMS Schlüsselringe, die zur Entschlüsselung verwendet werden. Details hierzu finden Sie unter [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id).
------
#### [ C ]
Um einen AWS KMS key in einem Verschlüsselungsschlüsselbund in der zu identifizieren AWS-Verschlüsselungs-SDK for C, geben Sie einen [Schlüssel-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) oder [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) an. In einem Entschlüsselungsschlüsselbund müssen Sie einen Schlüssel-ARN verwenden. Details hierzu finden Sie unter [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id).
Ein vollständiges Beispiel finden Sie unter [string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/string.cpp).
```
const char * generator_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
const char * additional_key = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
struct aws_cryptosdk_keyring *kms_encrypt_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(generator_key,{additional_key});
```
------
#### [ C\$1 / .NET ]
Verwenden Sie die Methode, um einen Schlüsselbund mit einem oder mehreren KMS-Schlüsseln im AWS Encryption SDK für.NET zu erstellen. `CreateAwsKmsMultiKeyring()` In diesem Beispiel werden zwei AWS KMS Schlüssel verwendet. Verwenden Sie nur den `Generator` Parameter, um einen KMS-Schlüssel anzugeben. Der `KmsKeyIds` Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.
Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des `Generator` Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (`us-west-2`), AWS Encryption SDK wird ein AWS KMS Standardclient für die `us-west-2` Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die `CreateAwsKmsKeyring()` Methode.
Wenn Sie im für.NET einen Schlüsselbund AWS KMS key AWS Encryption SDK für die Verschlüsselung angeben, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine [Schlüssel-ID, einen [Schlüssel-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id), einen [Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) oder einen [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id)
Im folgenden Beispiel wird Version 4 verwendet. *x* von AWS Encryption SDK für .NET und die `CreateAwsKmsKeyring()` Methode zum Anpassen des AWS KMS Clients.
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
string generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List additionalKeys = new List { "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321" };
// Instantiate the keyring input object
var createEncryptKeyringInput = new CreateAwsKmsMultiKeyringInput
{
Generator = generatorKey,
KmsKeyIds = additionalKeys
};
var kmsEncryptKeyring = mpl.CreateAwsKmsMultiKeyring(createEncryptKeyringInput);
```
------
#### [ JavaScript Browser ]
Wenn Sie in der einen Schlüsselbund AWS KMS key für die Verschlüsselung angeben AWS-Verschlüsselungs-SDK for JavaScript, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine [Schlüssel-ID, einen [Schlüssel-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id), einen [Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) oder einen [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id)
Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) anzugeben,`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`. Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
Ein vollständiges Beispiel finden Sie unter [kms\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/kms_simple.ts) im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const clientProvider = getClient(KMS, { credentials })
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
const additionalKey = 'alias/exampleAlias'
const keyring = new KmsKeyringBrowser({
clientProvider,
generatorKeyId,
keyIds: [additionalKey]
})
```
------
#### [ JavaScript Node.js ]
Wenn Sie in der einen Schlüsselbund AWS KMS key für die Verschlüsselung angeben AWS-Verschlüsselungs-SDK for JavaScript, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine [Schlüssel-ID, einen [Schlüssel-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id), einen [Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) oder einen [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id)
Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) anzugeben,`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`. Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
Ein vollständiges Beispiel finden Sie unter [kms\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_simple.ts) im Repository unter. AWS-Verschlüsselungs-SDK for JavaScript GitHub
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
const additionalKey = 'alias/exampleAlias'
const keyring = new KmsKeyringNode({
generatorKeyId,
keyIds: [additionalKey]
})
```
------
#### [ Java ]
Verwenden Sie die Methode, um einen Schlüsselbund mit einem oder mehreren Schlüsseln zu erstellen. AWS KMS `CreateAwsKmsMultiKeyring()` In diesem Beispiel werden zwei KMS-Schlüssel verwendet. Verwenden Sie nur den `generator` Parameter, um einen KMS-Schlüssel anzugeben. Der `kmsKeyIds` Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.
Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des `Generator` Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (`us-west-2`), AWS Encryption SDK wird ein AWS KMS Standardclient für die `us-west-2` Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die `CreateAwsKmsKeyring()` Methode.
Wenn Sie in der einen Schlüsselbund AWS KMS key für die Verschlüsselung angeben AWS-Verschlüsselungs-SDK for Java, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine [Schlüssel-ID, einen [Schlüssel-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id), einen [Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) oder einen [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id)
Ein vollständiges Beispiel finden Sie unter [BasicEncryptionKeyringExample.java](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/keyrings/BasicEncryptionKeyringExample.java) im AWS-Verschlüsselungs-SDK for Java Repository unter. GitHub
```
// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder().build();
final MaterialProviders materialProviders = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
String generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List additionalKey = Collections.singletonList("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321");
// Create the keyring
final CreateAwsKmsMultiKeyringInput keyringInput = CreateAwsKmsMultiKeyringInput.builder()
.generator(generatorKey)
.kmsKeyIds(additionalKey)
.build();
final IKeyring kmsKeyring = materialProviders.CreateAwsKmsMultiKeyring(keyringInput);
```
------
#### [ Python ]
Verwenden Sie die Methode, um einen Schlüsselbund mit einem oder mehreren AWS KMS Schlüsseln zu erstellen. `create_aws_kms_multi_keyring()` In diesem Beispiel werden zwei KMS-Schlüssel verwendet. Verwenden Sie nur den `generator` Parameter, um einen KMS-Schlüssel anzugeben. Der `kms_key_ids` Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.
Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des `generator` Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (`us-west-2`), AWS Encryption SDK wird ein AWS KMS Standardclient für die `us-west-2` Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die `create_aws_kms_keyring()` Methode.
Wenn Sie in der einen Schlüsselbund AWS KMS key für die Verschlüsselung angeben AWS-Verschlüsselungs-SDK for Python, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine [Schlüssel-ID, einen [Schlüssel-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id), einen [Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) oder einen [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id)
Im folgenden Beispiel wird der AWS Encryption SDK Client mit der [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) instanziiert. `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Ein vollständiges Beispiel finden Sie unter [aws\$1kms\$1multi\$1keyring\$1example.py](https://github.com/aws/aws-encryption-sdk-python/tree/master/examples/src/aws_kms_multi_keyring_example.py) im AWS-Verschlüsselungs-SDK for Python Repository unter. GitHub
```
# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS keyring
kms_multi_keyring_input: CreateAwsKmsMultiKeyringInput = CreateAwsKmsMultiKeyringInput(
generator="arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
kms_key_ids="arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
)
kms_multi_keyring: IKeyring = mat_prov.create_aws_kms_multi_keyring(
input=kms_multi_keyring_input
)
```
------
#### [ Rust ]
Verwenden Sie die `create_aws_kms_multi_keyring()` Methode, um einen Schlüsselbund mit einem oder mehreren AWS KMS Schlüsseln zu erstellen. In diesem Beispiel werden zwei KMS-Schlüssel verwendet. Verwenden Sie nur den `generator` Parameter, um einen KMS-Schlüssel anzugeben. Der `kms_key_ids` Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.
Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des `generator` Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (`us-west-2`), AWS Encryption SDK wird ein AWS KMS Standardclient für die `us-west-2` Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die `create_aws_kms_keyring()` Methode.
Wenn Sie im AWS KMS key for Rust einen Schlüsselbund für eine Verschlüsselung angeben, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine [Schlüssel-ID, einen [Schlüssel-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id), einen [Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) oder einen [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). AWS Encryption SDK Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id)
Im folgenden Beispiel wird der AWS Encryption SDK Client mit der [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) instanziiert. `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Ein vollständiges Beispiel finden Sie unter [aws\$1kms\$1keyring\$1example.rs](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples/keyring/aws_kms_keyring_example.rs) im Rust-Verzeichnis des Repositorys auf. aws-encryption-sdk GitHub
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create an AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Optional: Create an encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create the AWS KMS keyring
let kms_keyring = mpl
.create_aws_kms_keyring()
.kms_key_id(kms_key_id)
.kms_client(kms_client)
.send()
.await?;
kms_multi_keyring: IKeyring = mpl.create_aws_kms_multi_keyring(
input=kms_multi_keyring_input
)
```
------
#### [ Go ]
Verwenden Sie die Methode, um einen Schlüsselbund mit einem oder mehreren Schlüsseln zu erstellen. AWS KMS `create_aws_kms_multi_keyring()` In diesem Beispiel werden zwei KMS-Schlüssel verwendet. Verwenden Sie nur den `generator` Parameter, um einen KMS-Schlüssel anzugeben. Der `kms_key_ids` Parameter, der zusätzliche KMS-Schlüssel angibt, ist optional.
Die Eingabe für diesen Schlüsselbund benötigt keinen AWS KMS Client. Stattdessen AWS Encryption SDK verwendet der den AWS KMS Standardclient für jede Region, die durch einen KMS-Schlüssel im Schlüsselbund repräsentiert wird. Befindet sich der KMS-Schlüssel, der durch den Wert des `generator` Parameters identifiziert wird, beispielsweise in der Region USA West (Oregon) (`us-west-2`), AWS Encryption SDK wird ein AWS KMS Standardclient für die `us-west-2` Region erstellt. Wenn Sie den AWS KMS Client anpassen müssen, verwenden Sie die `create_aws_kms_keyring()` Methode.
Wenn Sie in AWS KMS key for Go einen Schlüsselbund für eine Verschlüsselung angeben, können Sie eine beliebige gültige Schlüssel-ID verwenden: eine [Schlüssel-ID, einen [Schlüssel-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id), einen [Aliasnamen](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) oder einen [Alias-ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). AWS Encryption SDK Hilfe zur Identifizierung von AWS KMS keys in einem AWS KMS Schlüsselbund finden Sie unter. [Identifizierung AWS KMS keys in einem AWS KMS Schlüsselbund](#kms-keyring-id)
Im folgenden Beispiel wird der AWS Encryption SDK Client mit der [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) instanziiert. `REQUIRE_ENCRYPT_REQUIRE_DECRYPT`
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create the AWS KMS keyring
awsKmsMultiKeyringInput := mpltypes.CreateAwsKmsMultiKeyringInput{
Generator: "&arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
KmsKeyIds: []string{"arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"},
}
awsKmsMultiKeyring, err := matProv.CreateAwsKmsMultiKeyring(context.Background(), awsKmsMultiKeyringInput)
```
------
Das unterstützt AWS Encryption SDK auch AWS KMS Schlüsselringe, die asymmetrische RSA-KMS-Schlüssel verwenden. Asymmetrische AWS KMS RSA-Schlüsselringe können nur ein key pair enthalten.
Um mit einem asymmetrischen AWS KMS RSA-Schlüsselbund zu verschlüsseln, benötigen Sie [kms: GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) oder [kms:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) nicht, da Sie bei der Erstellung des Schlüsselbunds das Material der öffentlichen Schlüssel angeben müssen, das Sie für die Verschlüsselung verwenden möchten. Bei der Verschlüsselung mit diesem Schlüsselbund werden keine Anrufe getätigt. AWS KMS [Um mit einem asymmetrischen AWS KMS RSA-Schlüsselbund zu entschlüsseln, benötigen Sie die kms:Decrypt-Berechtigung.](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
**Anmerkung**
Um einen AWS KMS Schlüsselbund zu erstellen, der asymmetrische RSA-KMS-Schlüssel verwendet, müssen Sie eine der folgenden Programmiersprachenimplementierungen verwenden:
Version 3. *x* der AWS-Verschlüsselungs-SDK for Java
Ausführung 4. *x* und höher von AWS Encryption SDK für .NET
Version 4. *x* von AWS-Verschlüsselungs-SDK for Python, wenn es mit der optionalen Abhängigkeit der [Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) verwendet wird.
Version 1. *x* von der AWS Encryption SDK für Rust
Version 0.1. *x* oder höher von AWS Encryption SDK for Go
In den folgenden Beispielen `CreateAwsKmsRsaKeyring` wird die Methode verwendet, um einen AWS KMS Schlüsselbund mit einem asymmetrischen RSA-KMS-Schlüssel zu erstellen. Um einen asymmetrischen AWS KMS RSA-Schlüsselbund zu erstellen, geben Sie die folgenden Werte an.
+ `kmsClient`: einen neuen Client erstellen AWS KMS
+ `kmsKeyID`: der Schlüssel-ARN, der Ihren asymmetrischen RSA-KMS-Schlüssel identifiziert
+ `publicKey`: eine Datei ByteBuffer aus einer UTF-8-codierten PEM-Datei, die den öffentlichen Schlüssel des Schlüssels darstellt, an den Sie übergeben haben `kmsKeyID`
+ `encryptionAlgorithm`: Der Verschlüsselungsalgorithmus muss oder sein `RSAES_OAEP_SHA_256` `RSAES_OAEP_SHA_1`
------
#### [ C\$1 / .NET ]
Um einen asymmetrischen AWS KMS RSA-Schlüsselbund zu erstellen, müssen Sie den öffentlichen Schlüssel und den privaten Schlüssel ARN aus Ihrem asymmetrischen RSA-KMS-Schlüssel angeben. Der öffentliche Schlüssel muss PEM-codiert sein. Im folgenden Beispiel wird ein AWS KMS Schlüsselbund mit einem asymmetrischen RSA-Schlüsselpaar erstellt.
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
var publicKey = new MemoryStream(Encoding.UTF8.GetBytes(AWS KMS RSA public key));
// Instantiate the keyring input object
var createKeyringInput = new CreateAwsKmsRsaKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = AWS KMS RSA private key ARN,
PublicKey = publicKey,
EncryptionAlgorithm = EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256
};
// Create the keyring
var kmsRsaKeyring = mpl.CreateAwsKmsRsaKeyring(createKeyringInput);
```
------
#### [ Java ]
Um einen asymmetrischen AWS KMS RSA-Schlüsselbund zu erstellen, müssen Sie den öffentlichen Schlüssel und den privaten Schlüssel ARN aus Ihrem asymmetrischen RSA-KMS-Schlüssel angeben. Der öffentliche Schlüssel muss PEM-codiert sein. Im folgenden Beispiel wird ein AWS KMS Schlüsselbund mit einem asymmetrischen RSA-Schlüsselpaar erstellt.
```
// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder()
// Specify algorithmSuite without asymmetric signing here
//
// ALG_AES_128_GCM_IV12_TAG16_NO_KDF("0x0014"),
// ALG_AES_192_GCM_IV12_TAG16_NO_KDF("0x0046"),
// ALG_AES_256_GCM_IV12_TAG16_NO_KDF("0x0078"),
// ALG_AES_128_GCM_IV12_TAG16_HKDF_SHA256("0x0114"),
// ALG_AES_192_GCM_IV12_TAG16_HKDF_SHA256("0x0146"),
// ALG_AES_256_GCM_IV12_TAG16_HKDF_SHA256("0x0178")
.withEncryptionAlgorithm(CryptoAlgorithm.ALG_AES_256_GCM_IV12_TAG16_HKDF_SHA256)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
// Create a KMS RSA keyring.
// This keyring takes in:
// - kmsClient
// - kmsKeyId: Must be an ARN representing an asymmetric RSA KMS key
// - publicKey: A ByteBuffer of a UTF-8 encoded PEM file representing the public
// key for the key passed into kmsKeyId
// - encryptionAlgorithm: Must be either RSAES_OAEP_SHA_256 or RSAES_OAEP_SHA_1
final CreateAwsKmsRsaKeyringInput createAwsKmsRsaKeyringInput =
CreateAwsKmsRsaKeyringInput.builder()
.kmsClient(KmsClient.create())
.kmsKeyId(rsaKeyArn)
.publicKey(publicKey)
.encryptionAlgorithm(EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256)
.build();
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);
```
------
#### [ Python ]
Um einen asymmetrischen AWS KMS RSA-Schlüsselbund zu erstellen, müssen Sie den öffentlichen Schlüssel und den privaten Schlüssel ARN aus Ihrem asymmetrischen RSA-KMS-Schlüssel angeben. Der öffentliche Schlüssel muss PEM-codiert sein. Im folgenden Beispiel wird ein AWS KMS Schlüsselbund mit einem asymmetrischen RSA-Schlüsselpaar erstellt.
```
# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS keyring
keyring_input: CreateAwsKmsRsaKeyringInput = CreateAwsKmsRsaKeyringInput(
public_key="public_key",
kms_key_id="kms_key_id",
encryption_algorithm="RSAES_OAEP_SHA_256",
kms_client=kms_client
)
kms_rsa_keyring: IKeyring = mat_prov.create_aws_kms_rsa_keyring(
input=keyring_input
)
```
------
#### [ Rust ]
Um einen asymmetrischen AWS KMS RSA-Schlüsselbund zu erstellen, müssen Sie den öffentlichen Schlüssel und den privaten Schlüssel ARN aus Ihrem asymmetrischen RSA-KMS-Schlüssel angeben. Der öffentliche Schlüssel muss PEM-codiert sein. Im folgenden Beispiel wird ein AWS KMS Schlüsselbund mit einem asymmetrischen RSA-Schlüsselpaar erstellt.
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create an AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Optional: Create an encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create the AWS KMS keyring
let kms_rsa_keyring = mpl
.create_aws_kms_rsa_keyring()
.kms_key_id(kms_key_id)
.public_key(aws_smithy_types::Blob::new(public_key))
.encryption_algorithm(aws_sdk_kms::types::EncryptionAlgorithmSpec::RsaesOaepSha256)
.kms_client(kms_client)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create the AWS KMS keyring
awsKmsRSAKeyringInput := mpltypes.CreateAwsKmsRsaKeyringInput{
KmsClient: kmsClient,
KmsKeyId: kmsKeyID,
PublicKey: kmsPublicKey,
EncryptionAlgorithm: kmstypes.EncryptionAlgorithmSpecRsaesOaepSha256,
}
awsKmsRSAKeyring, err := matProv.CreateAwsKmsRsaKeyring(context.Background(), awsKmsRSAKeyringInput)
if err != nil {
panic(err)
}
```
------
## Verwenden eines Discovery-Schlüsselbunds AWS KMS
Beim Entschlüsseln empfiehlt es sich, die [Umschließungsschlüssel](best-practices.md) anzugeben, die sie verwenden AWS Encryption SDK können. Um dieser bewährten Methode zu folgen, sollten Sie einen Schlüsselbund für die AWS KMS Entschlüsselung verwenden, der die Anzahl der AWS KMS Umschließungsschlüssel auf die von Ihnen angegebenen beschränkt. Sie können jedoch auch einen *AWS KMS Discovery-Schlüsselbund erstellen, d. h. einen Schlüsselbund*, der keine AWS KMS Schlüssel zum Umschließen von Schlüsseln festlegt.
Der AWS Encryption SDK bietet einen AWS KMS Standard-Discovery-Schlüsselbund und einen Discovery-Schlüsselbund für Schlüssel mit mehreren Regionen. AWS KMS Hinweise zur Verwendung von Regionsschlüsseln mit dem finden Sie unter. AWS Encryption SDK[Verwenden Sie mehrere Regionen AWS KMS keys](configure.md#config-mrks)
Da er keine Umschließungsschlüssel angibt, kann ein Discovery-Schlüsselbund keine Daten verschlüsseln. Wenn Sie einen Discovery-Schlüsselbund verwenden, um Daten allein oder in einem Mehrfachschlüsselbund zu verschlüsseln, schlägt der Verschlüsselungsvorgang fehl. Die Ausnahme ist der AWS-Verschlüsselungs-SDK for C, bei dem der Verschlüsselungsvorgang einen standardmäßigen Erkennungsschlüsselbund ignoriert, aber fehlschlägt, wenn Sie einen Erkennungsschlüsselbund mit mehreren Regionen angeben, allein oder in einem Schlüsselbund mit mehreren Schlüsselbunden.
Bei der Entschlüsselung können Sie mithilfe eines Discovery-Schlüsselbunds die AWS Encryption SDK Entschlüsselung eines beliebigen verschlüsselten Datenschlüssels unter Verwendung des verschlüsselten Schlüssels anfordern AWS KMS , unabhängig davon, wem dieser gehört oder wer Zugriff AWS KMS key darauf hat. AWS KMS key Der Anruf ist nur erfolgreich, wenn der Anrufer über die entsprechende Berechtigung verfügt. `kms:Decrypt` AWS KMS key
**Wichtig**
Wenn Sie einen AWS KMS Discovery-Schlüsselbund in einen [Mehrschlüsselbund für die Entschlüsselung aufnehmen, setzt der Discovery-Schlüsselbund](use-multi-keyring.md) alle KMS-Schlüsseleinschränkungen außer Kraft, die durch andere Schlüsselbunde im Mehrfachschlüsselbund festgelegt wurden. Der Mehrfachschlüsselbund verhält sich wie sein am wenigsten restriktiver Schlüsselbund. Ein AWS KMS Discovery-Schlüsselbund hat keine Auswirkung auf die Verschlüsselung, wenn er alleine oder in einem Mehrfachschlüsselbund verwendet wird.
Der AWS Encryption SDK bietet der Einfachheit halber einen AWS KMS Discovery-Schlüsselbund. Wir empfehlen jedoch aus folgenden Gründen, dass Sie nach Möglichkeit einen beschränkteren Schlüsselbund verwenden.
+ **Authentizität** — Ein AWS KMS Discovery-Schlüsselbund kann jeden Schlüsselbund verwenden AWS KMS key , der zum Verschlüsseln eines Datenschlüssels in der verschlüsselten Nachricht verwendet wurde, nur damit der Anrufer berechtigt ist, diesen Schlüssel zum Entschlüsseln zu verwenden. AWS KMS key Dies ist möglicherweise nicht der AWS KMS key , den der Anrufer verwenden möchte. Beispielsweise könnte einer der verschlüsselten Datenschlüssel unter einer weniger sicheren Methode verschlüsselt worden sein AWS KMS key , die jeder verwenden kann.
+ **Latenz und Leistung** — Ein AWS KMS Discovery-Schlüsselbund ist möglicherweise merklich langsamer als andere Schlüsselbunde, da er AWS Encryption SDK versucht, alle verschlüsselten Datenschlüssel zu entschlüsseln, einschließlich der Schlüssel, die AWS KMS keys in anderen Regionen verschlüsselt wurden, AWS-Konten und der Anrufer nicht berechtigt ist, diese für AWS KMS keys die Entschlüsselung zu verwenden.
[Wenn Sie einen Discovery-Schlüsselbund verwenden, empfehlen wir die Verwendung eines [*Discovery-Filters*](configure.md#config-discovery), um die KMS-Schlüssel, die verwendet werden können, auf diejenigen in bestimmten Partitionen zu beschränken. AWS-Konten](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) Discovery-Filter werden in den Versionen 1.7 unterstützt. *x* und später von AWS Encryption SDK. Hilfe bei der Suche nach Ihrer Konto-ID und Partition finden Sie unter [Ihre AWS-Konto Identifikatoren](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html) und das [ARN-Format](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arns-syntax) in der *Allgemeine AWS-Referenz*.
Der folgende Code instanziiert einen AWS KMS Discovery-Schlüsselbund mit einem Erkennungsfilter, der die KMS-Schlüssel, die er verwenden AWS Encryption SDK kann, auf diejenigen in der `aws` Partition und im Beispielkonto 111122223333 beschränkt.
Bevor Sie diesen Code verwenden, ersetzen Sie die Beispiel AWS-Konto - und Partitionswerte durch gültige Werte für Ihre Partition und. AWS-Konto Wenn sich Ihre KMS-Schlüssel in China Regionen befinden, verwenden Sie den `aws-cn` Partitionswert. Wenn sich Ihre KMS-Schlüssel befinden AWS GovCloud (US) Regions, verwenden Sie den `aws-us-gov` Partitionswert. Verwenden Sie für alle anderen AWS-Regionen den `aws` Partitionswert.
------
#### [ C ]
Ein vollständiges Beispiel finden Sie unter [ kms\$1discovery.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/kms_discovery.cpp).
```
std::shared_ptr discovery_filter(
KmsKeyring::DiscoveryFilter::Builder("aws")
.AddAccount("111122223333")
.Build());
struct aws_cryptosdk_keyring *kms_discovery_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
.BuildDiscovery(discovery_filter));
```
------
#### [ C\$1 / .NET ]
Im folgenden Beispiel wird Version 4 verwendet. *x* von AWS Encryption SDK für .NET.
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
List account = new List { "111122223333" };
// In a discovery keyring, you specify an AWS KMS client and a discovery filter,
// but not a AWS KMS key
var kmsDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
DiscoveryFilter = new DiscoveryFilter()
{
AccountIds = account,
Partition = "aws"
}
};
var kmsDiscoveryKeyring = mpl.CreateAwsKmsDiscoveryKeyring(kmsDiscoveryKeyringInput);
```
------
#### [ JavaScript Browser ]
JavaScriptIn müssen Sie die Discovery-Eigenschaft explizit angeben.
Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) anzugeben`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`. Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
```
import {
KmsKeyringBrowser,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-browser'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const clientProvider = getClient(KMS, { credentials })
const discovery = true
const keyring = new KmsKeyringBrowser(clientProvider, {
discovery,
discoveryFilter: { accountIDs: [111122223333], partition: 'aws' }
})
```
------
#### [ JavaScript Node.js ]
JavaScriptIn müssen Sie die Discovery-Eigenschaft explizit angeben.
Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) anzugeben`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`. Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const discovery = true
const keyring = new KmsKeyringNode({
discovery,
discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})
```
------
#### [ Java ]
```
// Create discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
.partition("aws")
.accountIds(111122223333)
.build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
.discoveryFilter(discoveryFilter)
.build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ Python ]
```
# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS discovery keyring
discovery_keyring_input: CreateAwsKmsDiscoveryKeyringInput = CreateAwsKmsDiscoveryKeyringInput(
kms_client=kms_client,
discovery_filter=DiscoveryFilter(
account_ids=[aws_account_id],
partition="aws"
)
)
discovery_keyring: IKeyring = mat_prov.create_aws_kms_discovery_keyring(
input=discovery_keyring_input
)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create a AWS KMS client.
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.account_ids(vec![aws_account_id.to_string()])
.partition("aws".to_string())
.build()?;
// Create the AWS KMS discovery keyring
let discovery_keyring = mpl
.create_aws_kms_discovery_keyring()
.kms_client(kms_client.clone())
.discovery_filter(discovery_filter)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create discovery filter
discoveryFilter := mpltypes.DiscoveryFilter{
AccountIds: []string{kmsKeyAccountID},
Partition: "aws",
}
awsKmsDiscoveryKeyringInput := mpltypes.CreateAwsKmsDiscoveryKeyringInput{
KmsClient: kmsClient,
DiscoveryFilter: &discoveryFilter,
}
awsKmsDiscoveryKeyring, err := matProv.CreateAwsKmsDiscoveryKeyring(context.Background(), awsKmsDiscoveryKeyringInput)
if err != nil {
panic(err)
}
```
------
## Verwenden Sie einen AWS KMS regionalen Discovery-Schlüsselbund
Ein *AWS KMS Regional Discovery-Schlüsselbund* ist ein Schlüsselbund, der ARNs die KMS-Schlüssel nicht spezifiziert. Stattdessen ermöglicht es die Entschlüsselung AWS Encryption SDK , wobei insbesondere nur die KMS-Schlüssel verwendet werden. AWS-Regionen
Bei der Entschlüsselung mit einem AWS KMS regionalen Discovery-Schlüsselbund werden alle verschlüsselten Datenschlüssel AWS Encryption SDK entschlüsselt, die unter einem AWS KMS key der angegebenen Zeichen verschlüsselt wurden. AWS-Region Um erfolgreich zu sein, muss der Aufrufer über `kms:Decrypt` Berechtigungen für mindestens einen der angegebenen Schlüssel verfügen AWS-Region , AWS KMS keys der einen Datenschlüssel verschlüsselt hat.
Wie andere Discovery-Schlüsselringe hat auch der regionale Discovery-Schlüsselbund keine Auswirkung auf die Verschlüsselung. Er funktioniert nur beim Entschlüsseln verschlüsselter Nachrichten. Wenn Sie einen Regional Discovery-Schlüsselbund in einem Mehrfachschlüsselbund verwenden, der zum Verschlüsseln und Entschlüsseln verwendet wird, ist dieser nur beim Entschlüsseln wirksam. Wenn Sie einen Schlüsselbund für die Erkennung mehrerer Regionen verwenden, um Daten allein oder in einem Schlüsselbund zu verschlüsseln, schlägt der Verschlüsselungsvorgang fehl.
**Wichtig**
Wenn Sie einen AWS KMS regionalen Discovery-Schlüsselbund in einen Schlüsselbund für die Entschlüsselung mit mehreren Schlüsseln aufnehmen, setzt der regionale [Discovery-Schlüsselbund alle KMS-Schlüsseleinschränkungen außer Kraft, die durch andere Schlüsselbunde im Mehrfachschlüsselbund](use-multi-keyring.md) festgelegt wurden. Der Mehrfachschlüsselbund verhält sich wie sein am wenigsten restriktiver Schlüsselbund. Ein AWS KMS Discovery-Schlüsselbund hat keine Auswirkung auf die Verschlüsselung, wenn er alleine oder in einem Mehrfachschlüsselbund verwendet wird.
Der regionale Discovery-Schlüsselbund bei AWS-Verschlüsselungs-SDK for C Versuchen, nur mit KMS-Schlüsseln in der angegebenen Region zu entschlüsseln. Wenn Sie einen Discovery-Schlüsselbund in AWS-Verschlüsselungs-SDK for JavaScript und AWS Encryption SDK für.NET verwenden, konfigurieren Sie die Region auf dem Client. AWS KMS Bei diesen AWS Encryption SDK Implementierungen AWS KMS werden KMS-Schlüssel nicht nach Region gefiltert, allerdings schlägt eine Entschlüsselungsanforderung für KMS-Schlüssel außerhalb der angegebenen Region fehl.
Wenn Sie einen Discovery-Schlüsselbund verwenden, empfehlen wir die Verwendung eines *Discovery-Filters*, um die bei der Entschlüsselung verwendeten KMS-Schlüssel auf die in den angegebenen Partitionen verwendeten KMS-Schlüssel zu beschränken. AWS-Konten Discovery-Filter werden in den Versionen 1.7 unterstützt. *x* und später von AWS Encryption SDK.
Der folgende Code erstellt beispielsweise einen AWS KMS regionalen Discovery-Schlüsselbund mit einem Discovery-Filter. Dieser Schlüsselbund beschränkt die Anzahl der AWS Encryption SDK KMS-Schlüssel im Konto 111122223333 in der Region USA West (Oregon) (us-west-2).
------
#### [ C ]
Weitere Informationen zum Anzeigen dieses Schlüsselbunds und der `create_kms_client`-Methode in einem funktionierenden Beispiel finden Sie unter [kms\$1discovery.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/kms_discovery.cpp).
```
std::shared_ptr discovery_filter(
KmsKeyring::DiscoveryFilter::Builder("aws")
.AddAccount("111122223333")
.Build());
struct aws_cryptosdk_keyring *kms_regional_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
.WithKmsClient(create_kms_client(Aws::Region::US_WEST_2)).BuildDiscovery(discovery_filter));
```
------
#### [ C\$1 / .NET ]
AWS Encryption SDK Für .NET gibt es keinen eigenen Schlüsselbund für die regionale Erkennung. Sie können jedoch verschiedene Techniken verwenden, um die bei der Entschlüsselung verwendeten KMS-Schlüssel auf eine bestimmte Region zu beschränken.
Die effizienteste Methode, die Regionen in einem Discovery-Schlüsselbund einzuschränken, ist die Verwendung eines multi-Region-aware Discovery-Schlüsselbunds, auch wenn Sie die Daten nur mit Schlüsseln aus einer Region verschlüsselt haben. Wenn Schlüssel mit nur einer Region gefunden werden, verwendet der multi-Region-aware Schlüsselbund keine Funktionen für mehrere Regionen.
Der von der `CreateAwsKmsMrkDiscoveryKeyring()` Methode zurückgegebene Schlüsselbund filtert KMS-Schlüssel vor dem Aufruf nach Region. AWS KMS Sie sendet AWS KMS nur dann eine Entschlüsselungsanforderung an, wenn der verschlüsselte Datenschlüssel mit einem KMS-Schlüssel in der Region verschlüsselt wurde, die durch den `Region` Parameter im Objekt angegeben wurde. `CreateAwsKmsMrkDiscoveryKeyringInput`
In den folgenden Beispielen wird Version 4 verwendet. *x* von AWS Encryption SDK für .NET.
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
List account = new List { "111122223333" };
// Create the discovery filter
var filter = DiscoveryFilter = new DiscoveryFilter
{
AccountIds = account,
Partition = "aws"
};
var regionalDiscoveryKeyringInput = new CreateAwsKmsMrkDiscoveryKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
Region = RegionEndpoint.USWest2,
DiscoveryFilter = filter
};
var kmsRegionalDiscoveryKeyring = mpl.CreateAwsKmsMrkDiscoveryKeyring(regionalDiscoveryKeyringInput);
```
Sie können KMS-Schlüssel auch auf einen bestimmten Wert beschränken, AWS-Region indem Sie eine Region in Ihrer Instanz des AWS KMS Clients angeben ([AmazonKeyManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/KeyManagementService/TKeyManagementServiceClient.html)). Diese Konfiguration ist jedoch weniger effizient und potenziell kostspieliger als die Verwendung eines multi-Region-aware Discovery-Schlüsselbunds. Anstatt KMS-Schlüssel vor dem Aufrufen nach Region zu filtern AWS KMS, ruft AWS KMS for.NET jeden verschlüsselten Datenschlüssel auf (bis er einen entschlüsselt) und beschränkt sich darauf, die verwendeten KMS-Schlüssel auf AWS KMS die angegebene Region zu beschränken. AWS Encryption SDK
Im folgenden Beispiel wird Version 4 verwendet. *x* von AWS Encryption SDK für .NET.
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
List account = new List { "111122223333" };
// Create the discovery filter,
// but not a AWS KMS key
var createRegionalDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
DiscoveryFilter = new DiscoveryFilter()
{
AccountIds = account,
Partition = "aws"
}
};
var kmsRegionalDiscoveryKeyring = mlp.CreateAwsKmsDiscoveryKeyring(createRegionalDiscoveryKeyringInput);
```
------
#### [ JavaScript Browser ]
Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) anzugeben,`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`. Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const clientProvider = getClient(KMS, { credentials })
const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringBrowser(clientProvider, {
discovery,
discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})
```
------
#### [ JavaScript Node.js ]
Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) anzugeben,`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`. Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
Einen Überblick über diesen Schlüsselbund und die `limitRegions` Funktion finden Sie in einem funktionierenden Beispiel unter [kms\$1regional\$1discovery.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_regional_discovery.ts).
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringNode({
clientProvider,
discovery,
discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})
```
------
#### [ Java ]
```
// Create the discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
.partition("aws")
.accountIds(111122223333)
.build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
.discoveryFilter(discoveryFilter)
.regions("us-west-2")
.build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ Python ]
```
# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS regional discovery keyring
regional_discovery_keyring_input: CreateAwsKmsMrkDiscoveryKeyringInput = \
CreateAwsKmsMrkDiscoveryKeyringInput(
kms_client=kms_client,
region=mrk_replica_decrypt_region,
discovery_filter=DiscoveryFilter(
account_ids=[111122223333],
partition="aws"
)
)
regional_discovery_keyring: IKeyring = mat_prov.create_aws_kms_mrk_discovery_keyring(
input=regional_discovery_keyring_input
)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Optional: Create an encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create an AWS KMS client
let decrypt_kms_config = aws_sdk_kms::config::Builder::from(&sdk_config)
.region(Region::new(mrk_replica_decrypt_region.clone()))
.build();
let decrypt_kms_client = aws_sdk_kms::Client::from_conf(decrypt_kms_config);
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.account_ids(vec![aws_account_id.to_string()])
.partition("aws".to_string())
.build()?;
// Create the regional discovery keyring
let discovery_keyring = mpl
.create_aws_kms_mrk_discovery_keyring()
.kms_client(decrypt_kms_client)
.region(mrk_replica_decrypt_region)
.discovery_filter(discovery_filter)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Create discovery filter
discoveryFilter := mpltypes.DiscoveryFilter{
AccountIds: []string{awsAccountID},
Partition: "aws",
}
// Create the regional discovery keyring
awsKmsMrkDiscoveryInput := mpltypes.CreateAwsKmsMrkDiscoveryKeyringInput{
KmsClient: kmsClient,
Region: alternateRegionMrkKeyRegion,
DiscoveryFilter: &discoveryFilter,
}
awsKmsMrkDiscoveryKeyring, err := matProv.CreateAwsKmsMrkDiscoveryKeyring(context.Background(), awsKmsMrkDiscoveryInput)
if err != nil {
panic(err)
}
```
------
Die exportiert AWS-Verschlüsselungs-SDK for JavaScript auch eine Funktion für Node.js und den Browser. `excludeRegions` Diese Funktion erstellt einen AWS KMS Regional Discovery-Schlüsselbund, der bestimmte Regionen AWS KMS keys auslässt. Im folgenden Beispiel wird ein AWS KMS regionaler Discovery-Schlüsselbund erstellt, der AWS KMS keys im Konto 111122223333 in allen Konten AWS-Region außer US East (Nord-Virginia) (us-east-1) verwendet werden kann.
Für AWS-Verschlüsselungs-SDK for C gibt es keine analoge Methode, aber Sie können eine implementieren, indem Sie eine benutzerdefinierte Methode erstellen. [ClientSupplier](https://github.com/aws/aws-encryption-sdk-c/blob/master/aws-encryption-sdk-cpp/include/aws/cryptosdk/cpp/kms_keyring.h#L157)
Dieses Beispiel zeigt den Code für Node.js.
```
const discovery = true
const clientProvider = excludeRegions(['us-east-1'], getKmsClient)
const keyring = new KmsKeyringNode({
clientProvider,
discovery,
discoveryFilter: { accountIDs: [111122223333], partition: 'aws' }
})
```
# AWS KMS Hierarchische Schlüsselanhänger
Mit dem AWS KMS hierarchischen Schlüsselbund können Sie Ihre kryptografischen Materialien mit einem KMS-Schlüssel mit symmetrischer Verschlüsselung schützen, ohne AWS KMS jedes Mal anrufen zu müssen, wenn Sie Daten ver- oder entschlüsseln. Es ist eine gute Wahl für Anwendungen, bei denen die Anzahl der Aufrufe minimiert werden muss AWS KMS, und für Anwendungen, die kryptografisches Material wiederverwenden können, ohne ihre Sicherheitsanforderungen zu verletzen.
Der hierarchische Schlüsselbund ist eine Lösung zum Zwischenspeichern von kryptografischem Material, die die Anzahl der AWS KMS Aufrufe reduziert, indem AWS KMS geschützte *Branch-Schlüssel* verwendet werden, die in einer Amazon DynamoDB-Tabelle gespeichert sind, und anschließend das bei Verschlüsselungs- und Entschlüsselungsvorgängen verwendete Zweigschlüsselmaterial lokal zwischengespeichert wird. Die DynamoDB-Tabelle dient als Schlüsselspeicher für die Verwaltung und den Schutz von Zweigschlüsseln. Sie speichert den aktiven Branch-Schlüssel und alle vorherigen Versionen des Branch-Schlüssels. Der *aktive* Zweigschlüssel ist die neueste Version des Zweigschlüssels. Der hierarchische Schlüsselbund verwendet einen eindeutigen Datenschlüssel, um jede Nachricht zu verschlüsseln, verschlüsselt jeden Datenverschlüsselungsschlüssel für jede Verschlüsselungsanforderung und verschlüsselt jeden Datenverschlüsselungsschlüssel mit einem eindeutigen Umschließungsschlüssel, der vom aktiven Branch-Schlüssel abgeleitet wird. Der hierarchische Schlüsselbund hängt von der Hierarchie ab, die zwischen aktiven Zweigschlüsseln und ihren abgeleiteten Umschließungsschlüsseln eingerichtet wurde.
Der hierarchische Schlüsselbund verwendet in der Regel jede Version des Zweigschlüssels, um mehrere Anfragen zu erfüllen. Sie kontrollieren jedoch, in welchem Umfang aktive Zweigschlüssel wiederverwendet werden, und bestimmen, wie oft der aktive Zweigschlüssel rotiert wird. Die aktive Version des Abzweigschlüssels bleibt aktiv, bis Sie [ihn drehen](rotate-branch-key.md). Frühere Versionen des aktiven Zweigschlüssels werden nicht zur Ausführung von Verschlüsselungsvorgängen verwendet, sie können jedoch weiterhin abgefragt und bei Entschlüsselungsvorgängen verwendet werden.
Wenn Sie den hierarchischen Schlüsselbund instanziieren, erstellt er einen lokalen Cache. Sie geben ein [Cache-Limit](#cache-limit) an, das die maximale Zeitspanne definiert, für die die Branch-Schlüsselmaterialien im lokalen Cache gespeichert werden, bevor sie ablaufen und aus dem Cache entfernt werden. Der hierarchische Schlüsselbund führt einen AWS KMS Aufruf durch, um den Zweigschlüssel zu entschlüsseln und die Zweigschlüsselmaterialien zusammenzustellen, wenn a zum ersten Mal in einem Vorgang angegeben `branch-key-id` wird. Anschließend werden die Materialien der Verzweigungsschlüssel im lokalen Cache gespeichert und für alle Verschlüsselungs- und Entschlüsselungsvorgänge, die dies spezifizieren, wiederverwendet, bis das Cache-Limit abläuft. `branch-key-id` Das Speichern von Zweigschlüsselmaterialien im lokalen Cache reduziert die Anzahl der Aufrufe. AWS KMS Stellen Sie sich zum Beispiel ein Cache-Limit von 15 Minuten vor. Wenn Sie 10.000 Verschlüsselungsvorgänge innerhalb dieses Cache-Limits ausführen, müsste der [herkömmliche AWS KMS Schlüsselbund](use-kms-keyring.md) 10.000 AWS KMS Aufrufe tätigen, um 10.000 Verschlüsselungsvorgänge zu erfüllen. Wenn Sie einen aktiven Schlüsselbund haben`branch-key-id`, muss der hierarchische Schlüsselbund nur einen AWS KMS Aufruf tätigen, um 10.000 Verschlüsselungsvorgänge abzuwickeln.
Der lokale Cache trennt Verschlüsselungsmaterialien von Entschlüsselungsmaterialien. Die Verschlüsselungsmaterialien werden aus dem aktiven Zweigschlüssel zusammengesetzt und für alle Verschlüsselungsvorgänge wiederverwendet, bis das Cache-Limit abgelaufen ist. Die Entschlüsselungsmaterialien werden aus der Zweigschlüssel-ID und der Version zusammengestellt, die in den Metadaten des verschlüsselten Felds identifiziert wurden, und sie werden für alle Entschlüsselungsvorgänge im Zusammenhang mit der Branch-Schlüssel-ID und -version wiederverwendet, bis das Cache-Limit abläuft. Im lokalen Cache können mehrere Versionen desselben Zweigschlüssels gleichzeitig gespeichert werden. Wenn der lokale Cache für die Verwendung von konfiguriert ist[branch key ID supplier](#branch-key-id-supplier), kann er auch Zweigschlüsselmaterial von mehreren aktiven Zweigschlüsseln gleichzeitig speichern.
**Anmerkung**
Alle Erwähnungen des Begriffs „*Hierarchischer Schlüsselbund*“ in der AWS Encryption SDK beziehen sich auf den AWS KMS hierarchischen Schlüsselbund.
**Kompatibilität mit Programmiersprachen**
Der hierarchische Schlüsselbund wird von den folgenden Programmiersprachen und Versionen unterstützt:
+ Version 3. *x* der AWS-Verschlüsselungs-SDK for Java
+ Ausführung 4. *x* und höher von AWS Encryption SDK für .NET
+ Version 4. *x* von AWS-Verschlüsselungs-SDK for Python, wenn es mit der optionalen MPL-Abhängigkeit verwendet wird.
+ Version 1. *x* von der AWS Encryption SDK für Rust
+ Version 0.1. *x* oder höher von AWS Encryption SDK for Go
**Topics**
+ [Funktionsweise](#how-hierarchical-keyring-works)
+ [Voraussetzungen](#hierarchical-keyring-prereqs)
+ [Erforderliche Berechtigungen](#hierarchical-keyring-permissions)
+ [Wählen Sie einen Cache](#hierarchical-keyring-caches)
+ [Erstellen Sie einen hierarchischen Schlüsselbund](#initialize-hierarchical-keyring)
## Funktionsweise
In den folgenden exemplarischen Vorgehensweisen wird beschrieben, wie der hierarchische Schlüsselbund Verschlüsselungs- und Entschlüsselungsmaterialien zusammenstellt. Außerdem werden die verschiedenen Aufrufe beschrieben, die der Schlüsselbund für Verschlüsselungs- und Entschlüsselungsvorgänge vornimmt. [Technische Einzelheiten zur Ableitung von Schlüsseln und zur Verschlüsselung von Klartext-Datenschlüsseln finden Sie unter Technische Details zum hierarchischen Schlüsselbund.AWS KMS](hierarchical-keyring-details.md)
**Verschlüsseln und signieren**
In der folgenden exemplarischen Vorgehensweise wird beschrieben, wie der hierarchische Schlüsselbund Verschlüsselungsmaterialien zusammenstellt und daraus einen eindeutigen Umschließungsschlüssel ableitet.
1. Die Verschlüsselungsmethode fragt den hierarchischen Schlüsselbund nach Verschlüsselungsmaterialien. Der Schlüsselbund generiert einen Klartext-Datenschlüssel und überprüft dann, ob sich im lokalen Cache gültiges Verzweigungsmaterial für die Generierung des Wrapping-Schlüssels befindet. **Wenn gültiges Schlüsselmaterial für die Zweige vorhanden ist, fährt der Schlüsselbund mit Schritt 4 fort.**
1. Wenn kein gültiges Material für Zweigschlüssel vorhanden ist, fragt der hierarchische Schlüsselbund den Schlüsselspeicher nach dem aktiven Zweigschlüssel ab.
1. Der Schlüsselspeicher ruft AWS KMS zur Entschlüsselung des aktiven Zweigschlüssels auf und gibt den aktiven Zweigschlüssel im Klartext zurück. Daten, die den aktiven Zweigschlüssel identifizieren, werden serialisiert, um zusätzliche authentifizierte Daten (AAD) beim Entschlüsselungsaufruf von bereitzustellen. AWS KMS
1. Der Schlüsselspeicher gibt den Klartext-Zweigschlüssel und die ihn identifizierenden Daten zurück, z. B. die Version des Zweigschlüssels.
1. Der hierarchische Schlüsselbund stellt die Schlüsselmaterialien der Zweige zusammen (die Version mit dem Zweigschlüssel im Klartext und der Zweigschlüsselversion) und speichert eine Kopie davon im lokalen Cache.
1. Der hierarchische Schlüsselbund leitet aus dem Klartext-Verzweigungsschlüssel und einem 16-Byte-Zufallssalz einen eindeutigen Umbruchschlüssel ab. Er verwendet den abgeleiteten Umschließungsschlüssel, um eine Kopie des Klartext-Datenschlüssels zu verschlüsseln.
Die Verschlüsselungsmethode verwendet die Verschlüsselungsmaterialien, um die Daten zu verschlüsseln. Weitere Informationen finden Sie unter [So werden AWS Encryption SDK Daten verschlüsselt.](how-it-works.md#encrypt-workflow)
**Entschlüsseln und verifizieren**
In der folgenden exemplarischen Vorgehensweise wird beschrieben, wie der hierarchische Schlüsselbund Entschlüsselungsmaterialien zusammenstellt und den verschlüsselten Datenschlüssel entschlüsselt.
1. Die Entschlüsselungsmethode identifiziert den verschlüsselten Datenschlüssel aus der verschlüsselten Nachricht und leitet ihn an den hierarchischen Schlüsselbund weiter.
1. Der hierarchische Schlüsselbund deserialisiert Daten, die den verschlüsselten Datenschlüssel identifizieren, einschließlich der Version des Zweigschlüssels, des 16-Byte-Salts und anderer Informationen, die beschreiben, wie der Datenschlüssel verschlüsselt wurde.
Weitere Informationen finden Sie unter [AWS KMS Technische Details zum hierarchischen Schlüsselbund](hierarchical-keyring-details.md).
1. **Mit dem hierarchischen Schlüsselbund wird geprüft, ob sich im lokalen Cache gültiges Zweigschlüsselmaterial befindet, das mit der in Schritt 2 identifizierten Version des Zweigschlüssels übereinstimmt.** **Wenn gültiges Schlüsselmaterial für die Zweige vorhanden ist, fährt der Schlüsselbund mit Schritt 6 fort.**
1. **Wenn kein gültiges Material für Zweigschlüssel vorhanden ist, fragt der hierarchische Schlüsselbund den Schlüsselspeicher nach dem Zweigschlüssel ab, der mit der in Schritt 2 identifizierten Version des Zweigschlüssels übereinstimmt.**
1. Der Schlüsselspeicher ruft AWS KMS zur Entschlüsselung des Zweigschlüssels auf und gibt den aktiven Zweigschlüssel im Klartext zurück. Daten, die den aktiven Zweigschlüssel identifizieren, werden serialisiert, um zusätzliche authentifizierte Daten (AAD) beim Entschlüsselungsaufruf von bereitzustellen. AWS KMS
1. Der Schlüsselspeicher gibt den Klartext-Zweigschlüssel und die ihn identifizierenden Daten zurück, z. B. die Version des Zweigschlüssels.
1. Der hierarchische Schlüsselbund stellt die Schlüsselmaterialien der Zweige zusammen (die Version mit dem Zweigschlüssel im Klartext und der Zweigschlüsselversion) und speichert eine Kopie davon im lokalen Cache.
1. Der hierarchische Schlüsselbund verwendet die zusammengestellten Zweigschlüsselmaterialien und das in **Schritt 2** identifizierte 16-Byte-Salt, um den eindeutigen Wrapping-Schlüssel zu reproduzieren, mit dem der Datenschlüssel verschlüsselt wurde.
1. Der hierarchische Schlüsselbund verwendet den reproduzierten Wrapping-Schlüssel, um den Datenschlüssel zu entschlüsseln, und gibt den Klartext-Datenschlüssel zurück.
Die Entschlüsselungsmethode verwendet die Entschlüsselungsmaterialien und den Klartext-Datenschlüssel, um die verschlüsselte Nachricht zu entschlüsseln. Weitere Informationen finden Sie unter [So AWS Encryption SDK entschlüsselt der](how-it-works.md#decrypt-workflow) eine verschlüsselte Nachricht.
## Voraussetzungen
Bevor Sie einen hierarchischen Schlüsselbund erstellen und verwenden, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind.
+ Sie oder Ihr Schlüsselspeicheradministrator haben [einen Schlüsselspeicher](create-keystore.md) und [mindestens einen aktiven Zweigschlüssel erstellt](create-branch-keys.md).
+ Sie haben [Ihre Schlüsselspeicheraktionen konfiguriert](keystore-actions.md#config-keystore-actions).
**Anmerkung**
Wie Sie Ihre Schlüsselspeicher-Aktionen konfigurieren, bestimmt, welche Operationen Sie ausführen können und welche KMS-Schlüssel der hierarchische Schlüsselbund verwenden kann. Weitere Informationen finden Sie unter [Schlüsselspeicher-Aktionen](keystore-actions.md).
+ Sie verfügen über die erforderlichen AWS KMS Berechtigungen, um auf den Schlüsselspeicher und die Zweigschlüssel zuzugreifen und diese zu verwenden. Weitere Informationen finden Sie unter [Erforderliche Berechtigungen](#hierarchical-keyring-permissions).
+ Sie haben die unterstützten Cachetypen überprüft und den Cachetyp konfiguriert, der Ihren Anforderungen am besten entspricht. Weitere Informationen finden Sie unter [Wählen Sie einen Cache](#hierarchical-keyring-caches).
## Erforderliche Berechtigungen
Der benötigt AWS Encryption SDK keinen AWS-Konto und hängt auch nicht von einem ab AWS-Service. Um einen hierarchischen Schlüsselbund verwenden zu können, benötigen Sie jedoch mindestens die folgenden Mindestberechtigungen für die symmetrische (n) Verschlüsselung AWS KMS key(en) in Ihrem Schlüsselspeicher. AWS-Konto
+ [Um Daten mit dem hierarchischen Schlüsselbund zu ver- und entschlüsseln, benötigen Sie kms:Decrypt.](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html)
Weitere Informationen zur Steuerung des Zugriffs auf Ihre Filialschlüssel und Ihren Schlüsselspeicher finden Sie unter[Implementieren der geringsten Berechtigungen](keystore-least-privilege.md).
## Wählen Sie einen Cache
Durch den hierarchischen Schlüsselbund wird die Anzahl der Aufrufe reduziert, AWS KMS indem die bei Verschlüsselungs- und Entschlüsselungsvorgängen verwendeten Filialschlüsselmaterialien lokal zwischengespeichert werden. Bevor Sie [Ihren hierarchischen Schlüsselbund erstellen](#initialize-hierarchical-keyring), müssen Sie entscheiden, welche Art von Cache Sie verwenden möchten. Sie können den Standard-Cache verwenden oder den Cache an Ihre Bedürfnisse anpassen.
Der hierarchische Schlüsselbund unterstützt die folgenden Cachetypen:
+ [Standard-Cache](#cache-default)
+ [MultiThreaded Cache](#cache-multithreaded)
+ [StormTracking Zwischenspeicher](#cache-stormtracking)
+ [Gemeinsam genutzter Cache](#cache-shared)
**Wichtig**
Alle unterstützten Cachetypen sind für die Unterstützung von Multithread-Umgebungen konzipiert.
In Kombination mit dem unterstützt der AWS-Verschlüsselungs-SDK for Python hierarchische Schlüsselbund jedoch keine Multithread-Umgebungen. [Weitere Informationen finden Sie in der [Python-Datei README.rst](https://github.com/aws/aws-cryptographic-material-providers-library/blob/main/AwsCryptographicMaterialProviders/runtimes/python/README.rst) im -library-Repository unteraws-cryptographic-material-providers.](https://github.com/aws/aws-cryptographic-material-providers-library/tree/main) GitHub
### Standard-Cache
Für die meisten Benutzer erfüllt der Standard-Cache ihre Threading-Anforderungen. Der Standard-Cache ist so konzipiert, dass er Umgebungen mit hohem Multithreading-Anteil unterstützt. Wenn ein Eintrag für Branch-Schlüssel-Materialien abläuft, verhindert der Standard-Cache den Aufruf mehrerer Threads, AWS KMS indem ein Thread 10 Sekunden im Voraus darüber informiert wird, dass der Eintrag für Branch-Schlüssel-Materialien abläuft. Dadurch wird sichergestellt, dass nur ein Thread eine Anfrage AWS KMS zur Aktualisierung des Caches sendet.
Standard und StormTracking Caches unterstützen dasselbe Threading-Modell, aber Sie müssen nur die Eingangskapazität angeben, um den Standard-Cache verwenden zu können. Für detailliertere Cache-Anpassungen verwenden Sie den. [StormTracking Zwischenspeicher](#cache-stormtracking)
Sofern Sie nicht die Anzahl der Materialeinträge für Branch Key anpassen möchten, die im lokalen Cache gespeichert werden können, müssen Sie bei der Erstellung des hierarchischen Schlüsselbunds keinen Cachetyp angeben. Wenn Sie keinen Cachetyp angeben, verwendet der hierarchische Schlüsselbund den Standard-Cachetyp und legt die Eintragskapazität auf 1000 fest.
Um den Standard-Cache anzupassen, geben Sie die folgenden Werte an:
+ **Eintragskapazität**: Schränkt die Anzahl der Einträge für wichtige Materialien der Branche ein, die im lokalen Cache gespeichert werden können.
------
#### [ Java ]
```
.cache(CacheType.builder()
.Default(DefaultCache.builder()
.entryCapacity(100)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType defaultCache = new CacheType
{
Default = new DefaultCache{EntryCapacity = 100}
};
```
------
#### [ Python ]
```
default_cache = CacheTypeDefault(
value=DefaultCache(
entry_capacity=100
)
)
```
------
#### [ Rust ]
```
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity(100)
.build()?,
);
```
------
#### [ Go ]
```
cache := mpltypes.CacheTypeMemberDefault{
Value: mpltypes.DefaultCache{
EntryCapacity: 100,
},
}
```
------
### MultiThreaded Cache
Der MultiThreaded Cache kann sicher in Multithread-Umgebungen verwendet werden, bietet jedoch keine Funktionen zur Minimierung AWS KMS von Amazon DynamoDB DynamoDB-Aufrufen. Daher werden alle Threads gleichzeitig benachrichtigt, wenn ein Eintrag für wichtige Materialien in einer Branche abläuft. Dies kann zu mehreren AWS KMS Aufrufen führen, um den Cache zu aktualisieren.
Um den MultiThreaded Cache zu verwenden, geben Sie die folgenden Werte an:
+ **Eintragskapazität**: Beschränkt die Anzahl der Einträge für Branch-Schlüsselmaterialien, die im lokalen Cache gespeichert werden können.
+ **Größe des Endstücks des Eintrags**: Definiert die Anzahl der Einträge, die beschnitten werden müssen, wenn die Eingangskapazität erreicht ist.
------
#### [ Java ]
```
.cache(CacheType.builder()
.MultiThreaded(MultiThreadedCache.builder()
.entryCapacity(100)
.entryPruningTailSize(1)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType multithreadedCache = new CacheType
{
MultiThreaded = new MultiThreadedCache
{
EntryCapacity = 100,
EntryPruningTailSize = 1
}
};
```
------
#### [ Python ]
```
multithreaded_cache = CacheTypeMultiThreaded(
value=MultiThreadedCache(
entry_capacity=100,
entry_pruning_tail_size=1
)
)
```
------
#### [ Rust ]
```
CacheType::MultiThreaded(
MultiThreadedCache::builder()
.entry_capacity(100)
.entry_pruning_tail_size(1)
.build()?)
```
------
#### [ Go ]
```
var entryPruningTailSize int32 = 1
cache := mpltypes.CacheTypeMemberMultiThreaded{
Value: mpltypes.MultiThreadedCache{
EntryCapacity: 100,
EntryPruningTailSize: &entryPruningTailSize,
},
}
```
------
### StormTracking Zwischenspeicher
Der StormTracking Cache ist so konzipiert, dass er Umgebungen mit vielen Threads unterstützt. Wenn ein Eintrag für Branch-Schlüssel-Materialien abläuft, verhindert der StormTracking Cache den Aufruf mehrerer Threads, AWS KMS indem ein Thread im Voraus darüber informiert wird, dass der Eintrag für Branch-Schlüssel-Materialien abläuft. Dadurch wird sichergestellt, dass nur ein Thread eine Anfrage AWS KMS zur Aktualisierung des Caches sendet.
Um den StormTracking Cache zu verwenden, geben Sie die folgenden Werte an:
+ **Eintragskapazität**: Beschränkt die Anzahl der Einträge für Branch-Schlüsselmaterialien, die im lokalen Cache gespeichert werden können.
Standardwert: 1000 Einträge
+ **Größe des Eintrags zum Beschneiden**: Definiert die Anzahl der Einträge für wichtige Materialien in der Branche, die gleichzeitig beschnitten werden sollen.
Standardwert: 1 Eintrag
+ **Übergangszeit**: Definiert die Anzahl der Sekunden vor Ablauf, nach der versucht wird, die wichtigsten Materialien der Branche zu aktualisieren.
Standardwert: 10 Sekunden
+ **Verlängerungsintervall**: Definiert die Anzahl der Sekunden zwischen Versuchen, die Schlüsselmaterialien der Filiale zu aktualisieren.
Standardwert: 1 Sekunde
+ **Fan-out**: Definiert die Anzahl der gleichzeitigen Versuche, die wichtigsten Materialien der Filiale zu aktualisieren.
Standardwert: 20 Versuche
+ **In Flight Time to Live (TTL)**: Definiert die Anzahl der Sekunden, bis beim Versuch, die Schlüsselmaterialien der Filiale zu aktualisieren, ein Timeout auftritt. Jedes Mal, wenn der Cache als Antwort auf eine zurückkehrt `NoSuchEntry``GetCacheEntry`, gilt dieser Verzweigungsschlüssel als aktiv, *bis* derselbe Schlüssel zusammen mit einem `PutCache` Eintrag geschrieben wird.
Standardwert: 10 Sekunden
+ **Sleep**: Definiert die Anzahl der Millisekunden, die ein Thread in den Ruhezustand versetzen soll, wenn der `fanOut` Wert überschritten wird.
Standardwert: 20 Millisekunden
------
#### [ Java ]
```
.cache(CacheType.builder()
.StormTracking(StormTrackingCache.builder()
.entryCapacity(100)
.entryPruningTailSize(1)
.gracePeriod(10)
.graceInterval(1)
.fanOut(20)
.inFlightTTL(10)
.sleepMilli(20)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType stormTrackingCache = new CacheType
{
StormTracking = new StormTrackingCache
{
EntryCapacity = 100,
EntryPruningTailSize = 1,
FanOut = 20,
GraceInterval = 1,
GracePeriod = 10,
InFlightTTL = 10,
SleepMilli = 20
}
};
```
------
#### [ Python ]
```
storm_tracking_cache = CacheTypeStormTracking(
value=StormTrackingCache(
entry_capacity=100,
entry_pruning_tail_size=1,
fan_out=20,
grace_interval=1,
grace_period=10,
in_flight_ttl=10,
sleep_milli=20
)
)
```
------
#### [ Rust ]
```
CacheType::StormTracking(
StormTrackingCache::builder()
.entry_capacity(100)
.entry_pruning_tail_size(1)
.grace_period(10)
.grace_interval(1)
.fan_out(20)
.in_flight_ttl(10)
.sleep_milli(20)
.build()?)
```
------
#### [ Go ]
```
var entryPruningTailSize int32 = 1
cache := mpltypes.CacheTypeMemberStormTracking{
Value: mpltypes.StormTrackingCache{
EntryCapacity: 100,
EntryPruningTailSize: &entryPruningTailSize,
GraceInterval: 1,
GracePeriod: 10,
FanOut: 20,
InFlightTTL: 10,
SleepMilli: 20,
},
}
```
------
### Gemeinsam genutzter Cache
Standardmäßig erstellt der hierarchische Schlüsselbund jedes Mal, wenn Sie den Schlüsselbund instanziieren, einen neuen lokalen Cache. Der Shared Cache kann jedoch dabei helfen, Speicherplatz zu sparen, indem er es Ihnen ermöglicht, einen Cache für mehrere hierarchische Schlüsselbunde gemeinsam zu nutzen. Anstatt für jeden hierarchischen Schlüsselbund, den Sie instanziieren, einen neuen Cache für kryptografisches Material zu erstellen, speichert der Shared Cache nur einen Cache im Arbeitsspeicher, der von allen hierarchischen Schlüsselbunden verwendet werden kann, die auf ihn verweisen. Der gemeinsam genutzte Cache trägt zur Optimierung der Speichernutzung bei, indem verhindert wird, dass kryptografisches Material in mehreren Schlüsselbunden doppelt vorhanden ist. Stattdessen können die hierarchischen Schlüsselbunde auf denselben zugrunde liegenden Cache zugreifen, wodurch der Gesamtspeicherbedarf reduziert wird.
Wenn Sie Ihren Shared Cache erstellen, definieren Sie immer noch den Cachetyp. Sie können einen [Standard-Cache](#cache-default)[MultiThreaded Cache](#cache-multithreaded), oder [StormTracking Zwischenspeicher](#cache-stormtracking) als Cachetyp angeben oder einen beliebigen kompatiblen benutzerdefinierten Cache ersetzen.
**Partitionen**
Ein einziger gemeinsam genutzter Cache kann von mehreren hierarchischen Schlüsselbunden verwendet werden. **Wenn Sie einen hierarchischen Schlüsselbund mit einem gemeinsam genutzten Cache erstellen, können Sie eine optionale Partitions-ID definieren.** Die Partitions-ID unterscheidet, welcher hierarchische Schlüsselbund in den Cache schreibt. Wenn zwei hierarchische Schlüsselbunde auf dieselbe Partitions-ID und dieselbe Zweigschlüssel-ID verweisen[logical key store name](create-keystore.md#logical-key-store-name), teilen sich die beiden Schlüsselbunde dieselben Cache-Einträge im Cache. Wenn Sie zwei hierarchische Schlüsselbunde mit demselben Shared Cache, aber unterschiedlicher Partition IDs erstellen, greift jeder Schlüsselbund nur auf die Cache-Einträge von der eigenen zugewiesenen Partition innerhalb des Shared Caches zu. Die Partitionen dienen als logische Unterteilungen innerhalb des gemeinsam genutzten Caches, sodass jeder hierarchische Schlüsselbund unabhängig auf seiner eigenen zugewiesenen Partition betrieben werden kann, ohne die in der anderen Partition gespeicherten Daten zu beeinträchtigen.
Wenn Sie beabsichtigen, die Cache-Einträge in einer Partition wiederzuverwenden oder gemeinsam zu nutzen, müssen Sie Ihre eigene Partitions-ID definieren. Wenn Sie die Partitions-ID an Ihren hierarchischen Schlüsselbund übergeben, kann der Schlüsselbund die Cache-Einträge wiederverwenden, die bereits im Shared Cache vorhanden sind, anstatt die Branch-Schlüsselmaterialien erneut abrufen und autorisieren zu müssen. Wenn Sie keine Partitions-ID angeben, wird dem Schlüsselbund bei jeder Instanziierung des hierarchischen Schlüsselbunds automatisch eine eindeutige Partitions-ID zugewiesen.
Die folgenden Verfahren veranschaulichen, wie ein gemeinsam genutzter Cache mit dem [Standard-Cachetyp erstellt und an einen hierarchischen](#cache-default) Schlüsselbund übergeben wird.
1. Erstellen Sie einen `CryptographicMaterialsCache` (CMC) mithilfe der [Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL).
------
#### [ Java ]
```
// Instantiate the MPL
final MaterialProviders matProv =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
// Create a CacheType object for the Default cache
final CacheType cache =
CacheType.builder()
.Default(DefaultCache.builder().entryCapacity(100).build())
.build();
// Create a CMC using the default cache
final CreateCryptographicMaterialsCacheInput cryptographicMaterialsCacheInput =
CreateCryptographicMaterialsCacheInput.builder()
.cache(cache)
.build();
final ICryptographicMaterialsCache sharedCryptographicMaterialsCache =
matProv.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ C\$1 / .NET ]
```
// Instantiate the MPL
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create a CacheType object for the Default cache
var cache = new CacheType { Default = new DefaultCache{EntryCapacity = 100} };
// Create a CMC using the default cache
var cryptographicMaterialsCacheInput = new CreateCryptographicMaterialsCacheInput {Cache = cache};
var sharedCryptographicMaterialsCache = materialProviders.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ Python ]
```
# Instantiate the MPL
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create a CacheType object for the default cache
cache: CacheType = CacheTypeDefault(
value=DefaultCache(
entry_capacity=100,
)
)
# Create a CMC using the default cache
cryptographic_materials_cache_input = CreateCryptographicMaterialsCacheInput(
cache=cache,
)
shared_cryptographic_materials_cache = mat_prov.create_cryptographic_materials_cache(
cryptographic_materials_cache_input
)
```
------
#### [ Rust ]
```
// Instantiate the MPL
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create a CacheType object for the default cache
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity(100)
.build()?,
);
// Create a CMC using the default cache
let shared_cryptographic_materials_cache: CryptographicMaterialsCacheRef = mpl.
create_cryptographic_materials_cache()
.cache(cache)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
)
// Instantiate the MPL
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create a CacheType object for the default cache
cache := mpltypes.CacheTypeMemberDefault{
Value: mpltypes.DefaultCache{
EntryCapacity: 100,
},
}
// Create a CMC using the default cache
cmcCacheInput := mpltypes.CreateCryptographicMaterialsCacheInput{
Cache: &cache,
}
sharedCryptographicMaterialsCache, err := matProv.CreateCryptographicMaterialsCache(context.Background(), cmcCacheInput)
if err != nil {
panic(err)
}
```
------
1. Erstellen Sie ein `CacheType` Objekt für den Shared Cache.
Übergeben `sharedCryptographicMaterialsCache` Sie das, was Sie in **Schritt 1** erstellt haben, an das neue `CacheType` Objekt.
------
#### [ Java ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
final CacheType sharedCache =
CacheType.builder()
.Shared(sharedCryptographicMaterialsCache)
.build();
```
------
#### [ C\$1 / .NET ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
var sharedCache = new CacheType { Shared = sharedCryptographicMaterialsCache };
```
------
#### [ Python ]
```
# Create a CacheType object for the shared_cryptographic_materials_cache
shared_cache: CacheType = CacheTypeShared(
value=shared_cryptographic_materials_cache
)
```
------
#### [ Rust ]
```
// Create a CacheType object for the shared_cryptographic_materials_cache
let shared_cache: CacheType = CacheType::Shared(shared_cryptographic_materials_cache);
```
------
#### [ Go ]
```
// Create a CacheType object for the shared_cryptographic_materials_cache
shared_cache := mpltypes.CacheTypeMemberShared{sharedCryptographicMaterialsCache}
```
------
1. Übergeben Sie das `sharedCache` Objekt aus **Schritt 2** an Ihren hierarchischen Schlüsselbund.
Wenn Sie einen hierarchischen Schlüsselbund mit einem gemeinsam genutzten Cache erstellen, können Sie optional a definieren, um Cache-Einträge für mehrere hierarchische Schlüsselbunde gemeinsam `partitionID` zu nutzen. Wenn Sie keine Partitions-ID angeben, weist der hierarchische Schlüsselbund dem Schlüsselbund automatisch eine eindeutige Partitions-ID zu.
**Anmerkung**
Ihre hierarchischen Schlüsselbunde verwenden dieselben Cacheeinträge in einem gemeinsam genutzten Cache, wenn Sie zwei oder mehr Schlüsselbunde erstellen, die auf dieselbe Partitions-ID und Verzweigungsschlüssel-ID verweisen. [logical key store name](create-keystore.md#logical-key-store-name) Wenn Sie nicht möchten, dass sich mehrere Schlüsselbunde dieselben Cache-Einträge teilen, müssen Sie für jeden hierarchischen Schlüsselbund eine eindeutige Partitions-ID verwenden.
Im folgenden Beispiel wird ein hierarchischer Schlüsselbund mit einem und einem [branch key ID supplier](#branch-key-id-supplier) [Cache-Limit](#cache-limit) von 600 Sekunden erstellt. Weitere Informationen zu den Werten, die in der folgenden hierarchischen Schlüsselbundkonfiguration definiert sind, finden Sie unter. [Erstellen Sie einen hierarchischen Schlüsselbund](#initialize-hierarchical-keyring)
------
#### [ Java ]
```
// Create the Hierarchical keyring
final CreateAwsKmsHierarchicalKeyringInput keyringInput =
CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(sharedCache)
.partitionID(partitionID)
.build();
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create the Hierarchical keyring
var createKeyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
Cache = sharedCache,
TtlSeconds = 600,
PartitionId = partitionID
};
var keyring = materialProviders.CreateAwsKmsHierarchicalKeyring(createKeyringInput);
```
------
#### [ Python ]
```
# Create the Hierarchical keyring
keyring_input: CreateAwsKmsHierarchicalKeyringInput = CreateAwsKmsHierarchicalKeyringInput(
key_store=keystore,
branch_key_id_supplier=branch_key_id_supplier,
ttl_seconds=600,
cache=shared_cache,
partition_id=partition_id
)
hierarchical_keyring: IKeyring = mat_prov.create_aws_kms_hierarchical_keyring(
input=keyring_input
)
```
------
#### [ Rust ]
```
// Create the Hierarchical keyring
let keyring1 = mpl
.create_aws_kms_hierarchical_keyring()
.key_store(key_store1)
.branch_key_id(branch_key_id.clone())
// CryptographicMaterialsCacheRef is an Rc (Reference Counted), so if you clone it to
// pass it to different Hierarchical Keyrings, it will still point to the same
// underlying cache, and increment the reference count accordingly.
.cache(shared_cache.clone())
.ttl_seconds(600)
.partition_id(partition_id.clone())
.send()
.await?;
```
------
#### [ Go ]
```
// Create the Hierarchical keyring
hkeyringInput := mpltypes.CreateAwsKmsHierarchicalKeyringInput{
KeyStore: keyStore1,
BranchKeyId: &branchKeyId,
TtlSeconds: 600,
Cache: &shared_cache,
PartitionId: &partitionId,
}
keyring, err := matProv.CreateAwsKmsHierarchicalKeyring(context.Background(), hkeyringInput)
if err != nil {
panic(err)
}
```
------
## Erstellen Sie einen hierarchischen Schlüsselbund
Um einen hierarchischen Schlüsselbund zu erstellen, müssen Sie die folgenden Werte angeben:
+ **Ein Name für den Schlüsselspeicher**
Der Name der DynamoDB-Tabelle, die Sie oder Ihr Schlüsselspeicheradministrator als Schlüsselspeicher erstellt haben.
+
**Ein Cache-Limit für die Gültigkeitsdauer (Time to Live, TTL)**
Die Zeitspanne in Sekunden, in der ein Eintrag für Branch-Schlüsselmaterialien im lokalen Cache verwendet werden kann, bevor er abläuft. Das Cache-Limit TTL bestimmt, wie oft der Client anruft, AWS KMS um die Verwendung der Branch-Schlüssel zu autorisieren. Dieser Wert muss größer als null sein. Nach Ablauf des Cache-Limits TTL wird der Eintrag nicht mehr bearbeitet und aus dem lokalen Cache entfernt.
+ **Eine Schlüssel-ID für eine Zweigstelle**
Sie können den entweder statisch konfigurieren`branch-key-id`, der einen einzelnen aktiven Zweigschlüssel in Ihrem Schlüsselspeicher identifiziert, oder einen Lieferanten für die Zweigschlüssel-ID angeben.
Der *Anbieter der Zweigschlüssel-ID* bestimmt anhand der im Verschlüsselungskontext gespeicherten Felder, welcher Filialschlüssel zum Entschlüsseln eines Datensatzes erforderlich ist.
Wir empfehlen dringend, für Mehrmandantendatenbanken, bei denen jeder Mandant über einen eigenen Branch-Schlüssel verfügt, einen Branch-Schlüssel-ID-Anbieter zu verwenden. Sie können den Anbieter für die Branch-Schlüssel-ID verwenden, um einen benutzerfreundlichen Namen für Ihren Branch-Schlüssel IDs zu erstellen, damit Sie die richtige Branch-Schlüssel-ID für einen bestimmten Mandanten leicht erkennen können. Mit dem Anzeigenamen können Sie beispielsweise auf einen Zweigschlüssel als `tenant1` statt auf verweisen`b3f61619-4d35-48ad-a275-050f87e15122`.
Für Entschlüsselungsvorgänge können Sie entweder einen einzelnen hierarchischen Schlüsselbund statisch konfigurieren, um die Entschlüsselung auf einen einzelnen Mandanten zu beschränken, oder Sie können den Branch-Schlüssel-ID-Anbieter verwenden, um zu ermitteln, welcher Mandant für die Entschlüsselung eines Datensatzes verantwortlich ist.
+ **(Optional) Ein Cache**
Wenn Sie Ihren Cachetyp oder die Anzahl der Einträge für Branch-Schlüsselmaterialien, die im lokalen Cache gespeichert werden können, anpassen möchten, geben Sie den Cachetyp und die Eintragskapazität an, wenn Sie den Schlüsselbund initialisieren.
Der hierarchische Schlüsselbund unterstützt die folgenden Cachetypen: Standard, MultiThreaded, StormTracking und Shared. Weitere Informationen und Beispiele zur Definition der einzelnen Cachetypen finden Sie unter. [Wählen Sie einen Cache](#hierarchical-keyring-caches)
Wenn Sie keinen Cache angeben, verwendet der hierarchische Schlüsselbund automatisch den Standard-Cachetyp und legt die Eintragskapazität auf 1000 fest.
+ **(Optional) Eine Partitions-ID**
Wenn Sie die angeben[Gemeinsam genutzter Cache](#cache-shared), können Sie optional eine Partitions-ID definieren. Die Partitions-ID unterscheidet, welcher hierarchische Schlüsselbund in den Cache schreibt. Wenn Sie beabsichtigen, die Cache-Einträge in einer Partition wiederzuverwenden oder gemeinsam zu nutzen, müssen Sie Ihre eigene Partitions-ID definieren. Sie können eine beliebige Zeichenfolge für die Partitions-ID angeben. Wenn Sie keine Partitions-ID angeben, wird dem Schlüsselbund bei der Erstellung automatisch eine eindeutige Partitions-ID zugewiesen.
Weitere Informationen finden Sie unter [Partitions](#shared-cache-partitions).
**Anmerkung**
Ihre hierarchischen Schlüsselbunde verwenden dieselben Cache-Einträge in einem gemeinsam genutzten Cache, wenn Sie zwei oder mehr Schlüsselbunde erstellen, die auf dieselbe Partitions-ID und Verzweigungsschlüssel-ID verweisen. [logical key store name](create-keystore.md#logical-key-store-name) Wenn Sie nicht möchten, dass sich mehrere Schlüsselbunde dieselben Cache-Einträge teilen, müssen Sie für jeden hierarchischen Schlüsselbund eine eindeutige Partitions-ID verwenden.
+ **(Optional) Eine Liste von Grant-Tokens**
Wenn Sie den Zugriff auf den KMS-Schlüssel in Ihrem hierarchischen Schlüsselbund mit [Grants](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) steuern, müssen Sie bei der Initialisierung des Schlüsselbunds alle erforderlichen Grant-Token angeben.
### Erstellen Sie einen hierarchischen Schlüsselbund mit einer statischen Zweigschlüssel-ID
Die folgenden Beispiele zeigen, wie Sie einen hierarchischen Schlüsselbund mit einer statischen Zweigschlüssel-ID, der[Standard-Cache](#cache-default), und einem Cache-Limit von 600 Sekunden erstellen.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(branchKeyStoreName)
.branchKeyId(branch-key-id)
.ttlSeconds(600)
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyId = branch-key-id,
TtlSeconds = 600
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Python ]
```
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
keyring_input: CreateAwsKmsHierarchicalKeyringInput = CreateAwsKmsHierarchicalKeyringInput(
key_store=keystore,
branch_key_id=branch_key_id,
ttl_seconds=600
)
hierarchical_keyring: IKeyring = mat_prov.create_aws_kms_hierarchical_keyring(
input=keyring_input
)
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.key_store(key_store.clone())
.branch_key_id(branch_key_id)
.ttl_seconds(600)
.send()
.await?;
```
------
#### [ Go ]
```
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
hkeyringInput := mpltypes.CreateAwsKmsHierarchicalKeyringInput{
KeyStore: keyStore,
BranchKeyId: &branchKeyID,
TtlSeconds: 600,
}
hKeyRing, err := matProv.CreateAwsKmsHierarchicalKeyring(context.Background(), hkeyringInput)
if err != nil {
panic(err)
}
```
------
### Erstellen Sie einen hierarchischen Schlüsselbund mit einem Lieferanten für die Zweigschlüssel-ID
Die folgenden Verfahren zeigen, wie Sie einen hierarchischen Schlüsselbund mit einem Branchenschlüssel-ID-Lieferanten erstellen.
1. Erstellen Sie einen Lieferanten für die Zweigschlüssel-ID
Im folgenden Beispiel werden benutzerfreundliche Namen für zwei Branch-Schlüssel und Aufrufe `CreateDynamoDbEncryptionBranchKeyIdSupplier` zur Erstellung eines Branch-Schlüssel-ID-Lieferanten erstellt.
------
#### [ Java ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier implements IDynamoDbKeyBranchKeyIdSupplier {
private static String branchKeyIdForTenant1;
private static String branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this.branchKeyIdForTenant1 = tenant1Id;
this.branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
final DynamoDbEncryption ddbEnc = DynamoDbEncryption.builder()
.DynamoDbEncryptionConfig(DynamoDbEncryptionConfig.builder().build())
.build();
final BranchKeyIdSupplier branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
CreateDynamoDbEncryptionBranchKeyIdSupplierInput.builder()
.ddbKeyBranchKeyIdSupplier(new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2))
.build()).branchKeyIdSupplier();
```
------
#### [ C\$1 / .NET ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier : DynamoDbKeyBranchKeyIdSupplierBase {
private String _branchKeyIdForTenant1;
private String _branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this._branchKeyIdForTenant1 = tenant1Id;
this._branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
var ddbEnc = new DynamoDbEncryption(new DynamoDbEncryptionConfig());
var branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
new CreateDynamoDbEncryptionBranchKeyIdSupplierInput
{
DdbKeyBranchKeyIdSupplier = new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2)
}).BranchKeyIdSupplier;
```
------
#### [ Python ]
```
# Create branch key ID supplier that maps the branch key ID to a friendly name
branch_key_id_supplier: IBranchKeyIdSupplier = ExampleBranchKeyIdSupplier(
tenant_1_id=branch_key_id_a,
tenant_2_id=branch_key_id_b,
)
```
------
#### [ Rust ]
```
// Create branch key ID supplier that maps the branch key ID to a friendly name
let branch_key_id_supplier = ExampleBranchKeyIdSupplier::new(
&branch_key_id_a,
&branch_key_id_b
);
```
------
#### [ Go ]
```
// Create branch key ID supplier that maps the branch key ID to a friendly name
keySupplier := branchKeySupplier{branchKeyA: branchKeyA, branchKeyB: branchKeyB}
```
------
1. Erstellen Sie einen hierarchischen Schlüsselbund
In den folgenden Beispielen wird ein hierarchischer Schlüsselbund mit dem in **Schritt 1** erstellten Branch-Schlüssel-ID-Lieferanten, einem Cache-Limit von 600 Sekunden und einer maximalen Cachegröße von 1000 initialisiert.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(CacheType.builder() //OPTIONAL
.Default(DefaultCache.builder()
.entryCapacity(100)
.build())
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600,
Cache = new CacheType
{
Default = new DefaultCache { EntryCapacity = 100 }
}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Python ]
```
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
keyring_input: CreateAwsKmsHierarchicalKeyringInput = CreateAwsKmsHierarchicalKeyringInput(
key_store=keystore,
branch_key_id_supplier=branch_key_id_supplier,
ttl_seconds=600,
cache=CacheTypeDefault(
value=DefaultCache(
entry_capacity=100
)
),
)
hierarchical_keyring: IKeyring = mat_prov.create_aws_kms_hierarchical_keyring(
input=keyring_input
)
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.key_store(key_store.clone())
.branch_key_id_supplier(branch_key_id_supplier)
.ttl_seconds(600)
.send()
.await?;
```
------
#### [ Go ]
```
hkeyringInput := mpltypes.CreateAwsKmsHierarchicalKeyringInput{
KeyStore: keyStore,
BranchKeyIdSupplier: &keySupplier,
TtlSeconds: 600,
}
hKeyRing, err := matProv.CreateAwsKmsHierarchicalKeyring(context.Background(), hkeyringInput)
if err != nil {
panic(err)
}
```
------
# AWS KMS ECDH-Schlüsselanhänger
Ein AWS KMS ECDH-Schlüsselbund verwendet eine asymmetrische Schlüsselvereinbarung, [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/key-types.html)um einen gemeinsamen symmetrischen Wrapping-Schlüssel zwischen zwei Parteien abzuleiten. Zunächst verwendet der Schlüsselbund den Schlüsselvereinbarungsalgorithmus Elliptic Curve Diffie-Hellman (ECDH), um ein gemeinsames Geheimnis aus dem privaten Schlüssel im KMS-Schlüsselpaar des Absenders und dem öffentlichen Schlüssel des Empfängers abzuleiten. Anschließend leitet der Schlüsselbund anhand des gemeinsamen geheimen Schlüssels den gemeinsamen Wrapping-Schlüssel ab, der Ihre Datenverschlüsselungsschlüssel schützt. Die Schlüsselableitungsfunktion, die (`KDF_CTR_HMAC_SHA384`) AWS Encryption SDK verwendet, um den gemeinsamen Wrapping-Schlüssel abzuleiten, entspricht den [NIST-Empfehlungen](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf) für die Schlüsselableitung.
Die Funktion zur Schlüsselableitung gibt 64 Byte an Schlüsselmaterial zurück. Um sicherzustellen, dass beide Parteien das richtige Schlüsselmaterial verwenden, AWS Encryption SDK verwendet der die ersten 32 Byte als Commitment-Schlüssel und die letzten 32 Byte als gemeinsamen Wrapping-Schlüssel. Wenn der Schlüsselbund beim Entschlüsseln nicht denselben Commitment-Schlüssel und denselben gemeinsamen Wrapping-Schlüssel reproduzieren kann, die im Chiffretext der Nachrichtenkopfzeile gespeichert sind, schlägt der Vorgang fehl. Wenn Sie beispielsweise Daten mit einem Schlüsselbund verschlüsseln, der mit **Alices** privatem Schlüssel und **Bobs öffentlichem Schlüssel konfiguriert ist**, reproduziert ein Schlüsselbund, der mit **Bobs privatem Schlüssel und Alices** **öffentlichem Schlüssel konfiguriert ist**, denselben Commitment-Schlüssel und gemeinsamen Wrapping-Schlüssel und kann die Daten entschlüsseln. Wenn Bobs öffentlicher Schlüssel nicht von einem KMS-Schlüsselpaar stammt, kann Bob einen [Raw ECDH-Schlüsselbund](use-raw-ecdh-keyring.md) erstellen, um die Daten zu entschlüsseln.
Der AWS KMS ECDH-Schlüsselbund verschlüsselt Daten mit einem symmetrischen Schlüssel unter Verwendung von AES-GCM. Der Datenschlüssel wird dann mit dem abgeleiteten gemeinsamen Wrapping-Schlüssel unter Verwendung von AES-GCM umhüllt. [Jeder AWS KMS ECDH-Schlüsselbund kann nur einen gemeinsamen Wrapping-Schlüssel haben, aber Sie können mehrere AWS KMS ECDH-Schlüsselanhänger, einzeln oder zusammen mit anderen Schlüsselbunden, in einen Mehrfachschlüsselbund aufnehmen.](use-multi-keyring.md)
**Kompatibilität mit Programmiersprachen**
Der AWS KMS ECDH-Schlüsselbund wurde in Version 1.5.0 der [Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) eingeführt und wird von den folgenden Programmiersprachen und Versionen unterstützt:
+ Version 3. *x* der AWS-Verschlüsselungs-SDK for Java
+ Ausführung 4. *x* und höher von AWS Encryption SDK für .NET
+ Version 4. *x* von AWS-Verschlüsselungs-SDK for Python, wenn es mit der optionalen MPL-Abhängigkeit verwendet wird.
+ Version 1. *x* von der AWS Encryption SDK für Rust
+ Version 0.1. *x* oder höher von AWS Encryption SDK for Go
**Topics**
+ [Erforderliche Berechtigungen für AWS KMS ECDH-Schlüsselanhänger](#kms-ecdh-permissions)
+ [Einen ECDH-Schlüsselbund AWS KMS erstellen](#kms-ecdh-create)
+ [Einen AWS KMS ECDH-Discovery-Schlüsselbund erstellen](#kms-ecdh-discovery)
## Erforderliche Berechtigungen für AWS KMS ECDH-Schlüsselanhänger
Für das AWS Encryption SDK ist kein AWS Konto erforderlich und es ist auch nicht von einem Dienst abhängig. AWS Um einen AWS KMS ECDH-Schlüsselbund verwenden zu können, benötigen Sie jedoch ein AWS Konto und die folgenden Mindestberechtigungen für AWS KMS keys den Schlüsselbund. Die Berechtigungen variieren je nachdem, welches Schlüsselvereinbarungsschema Sie verwenden.
+ Um Daten mithilfe des `KmsPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschemas zu verschlüsseln und zu entschlüsseln, benötigen Sie [kms: GetPublicKey und [kms: DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html)](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) auf dem asymmetrischen *KMS-Schlüsselpaar des Absenders*. Wenn Sie den DER-codierten öffentlichen Schlüssel des Absenders direkt angeben, wenn Sie Ihren Schlüsselbund instanziieren, benötigen Sie nur die [kms: DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) -Berechtigung für das asymmetrische KMS-Schlüsselpaar des Absenders.
+ Um Daten mithilfe des `KmsPublicKeyDiscovery` Schlüsselvereinbarungsschemas zu entschlüsseln, benötigen Sie die GetPublicKey Berechtigungen [kms: DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) und [kms:](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) für das angegebene asymmetrische KMS-Schlüsselpaar.
## Einen ECDH-Schlüsselbund AWS KMS erstellen
Um einen AWS KMS ECDH-Schlüsselbund zu erstellen, der Daten ver- und entschlüsselt, müssen Sie das Schlüsselvereinbarungsschema verwenden. `KmsPrivateKeyToStaticPublicKey` Um einen AWS KMS ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema zu initialisieren, geben Sie die folgenden `KmsPrivateKeyToStaticPublicKey` Werte an:
+ **ID des Absenders AWS KMS key **
Muss ein von NIST empfohlenes asymmetrisches KMS-Schlüsselpaar mit elliptischer Kurve (ECC) mit einem Wert von identifizieren. `KeyUsage` `KEY_AGREEMENT` Der private Schlüssel des Absenders wird verwendet, um den gemeinsamen geheimen Schlüssel abzuleiten.
+ **(Optional) Der öffentliche Schlüssel des Absenders**
[Muss ein DER-codierter öffentlicher X.509-Schlüssel sein, auch bekannt als `SubjectPublicKeyInfo` (SPKI), wie in RFC 5280 definiert.](https://tools.ietf.org/html/rfc5280)
Die AWS KMS [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)Operation gibt den öffentlichen Schlüssel eines asymmetrischen KMS-Schlüsselpaars im erforderlichen DER-codierten Format zurück.
Um die Anzahl der AWS KMS Anrufe zu reduzieren, die Ihr Schlüsselbund tätigt, können Sie den öffentlichen Schlüssel des Absenders direkt angeben. Wenn kein Wert für den öffentlichen Schlüssel des Absenders angegeben wird, ruft der Schlüsselbund auf, AWS KMS um den öffentlichen Schlüssel des Absenders abzurufen.
+ **Der öffentliche Schlüssel des Empfängers**
[Sie müssen den DER-codierten öffentlichen X.509-Schlüssel des Empfängers, auch bekannt als `SubjectPublicKeyInfo` (SPKI), wie in RFC 5280 definiert, angeben.](https://tools.ietf.org/html/rfc5280)
Die AWS KMS [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)Operation gibt den öffentlichen Schlüssel eines asymmetrischen KMS-Schlüsselpaars im erforderlichen DER-codierten Format zurück.
+ **Kurvenspezifikation**
Identifiziert die Spezifikation für elliptische Kurven in den angegebenen Schlüsselpaaren. Sowohl die Schlüsselpaare des Absenders als auch des Empfängers müssen dieselbe Kurvenspezifikation haben.
Zulässige Werte: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
+ **(Optional) Eine Liste von Grant-Tokens**
Wenn Sie den Zugriff auf den KMS-Schlüssel in Ihrem AWS KMS ECDH-Schlüsselbund mit [Grants](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) steuern, müssen Sie bei der Initialisierung des Schlüsselbunds alle erforderlichen Grant-Token angeben.
------
#### [ C\$1 / .NET ]
Im folgenden Beispiel wird ein AWS KMS ECDH-Schlüsselbund mit dem KMS-Schlüssel des Absenders, dem öffentlichen Schlüssel des Absenders und dem öffentlichen Schlüssel des Empfängers erstellt. In diesem Beispiel wird der optionale `SenderPublicKey` Parameter verwendet, um den öffentlichen Schlüssel des Absenders bereitzustellen. Wenn Sie den öffentlichen Schlüssel des Absenders nicht angeben, ruft der Schlüsselbund auf, AWS KMS um den öffentlichen Schlüssel des Absenders abzurufen. Sowohl die Schlüsselpaare des Absenders als auch des Empfängers befinden sich auf der `ECC_NIST_P256` Kurve.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Must be DER-encoded X.509 public keys
var BobPublicKey = new MemoryStream(new byte[] { });
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the AWS KMS ECDH static keyring
var staticConfiguration = new KmsEcdhStaticConfigurations
{
KmsPrivateKeyToStaticPublicKey = new KmsPrivateKeyToStaticPublicKeyInput
{
SenderKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
SenderPublicKey = BobPublicKey,
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = staticConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
Im folgenden Beispiel wird ein AWS KMS ECDH-Schlüsselbund mit dem KMS-Schlüssel des Absenders, dem öffentlichen Schlüssel des Absenders und dem öffentlichen Schlüssel des Empfängers erstellt. In diesem Beispiel wird der optionale `senderPublicKey` Parameter verwendet, um den öffentlichen Schlüssel des Absenders bereitzustellen. Wenn Sie den öffentlichen Schlüssel des Absenders nicht angeben, ruft der Schlüsselbund auf, AWS KMS um den öffentlichen Schlüssel des Absenders abzurufen. Sowohl die Schlüsselpaare des Absenders als auch des Empfängers befinden sich auf der `ECC_NIST_P256` Kurve.
```
// Retrieve public keys
// Must be DER-encoded X.509 public keys
ByteBuffer BobPublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab");
ByteBuffer AlicePublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321");
// Create the AWS KMS ECDH static keyring
final CreateAwsKmsEcdhKeyringInput senderKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPrivateKeyToStaticPublicKey(
KmsPrivateKeyToStaticPublicKeyInput.builder()
.senderKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab")
.senderPublicKey(BobPublicKey)
.recipientPublicKey(AlicePublicKey)
.build()).build()).build();
```
------
#### [ Python ]
Im folgenden Beispiel wird ein AWS KMS ECDH-Schlüsselbund mit dem KMS-Schlüssel des Absenders, dem öffentlichen Schlüssel des Absenders und dem öffentlichen Schlüssel des Empfängers erstellt. In diesem Beispiel wird der optionale `senderPublicKey` Parameter verwendet, um den öffentlichen Schlüssel des Absenders bereitzustellen. Wenn Sie den öffentlichen Schlüssel des Absenders nicht angeben, ruft der Schlüsselbund auf, AWS KMS um den öffentlichen Schlüssel des Absenders abzurufen. Sowohl die Schlüsselpaare des Absenders als auch des Empfängers befinden sich auf der `ECC_NIST_P256` Kurve.
```
import boto3
from aws_cryptographic_materialproviders.mpl.models import (
CreateAwsKmsEcdhKeyringInput,
KmsEcdhStaticConfigurationsKmsPrivateKeyToStaticPublicKey,
KmsPrivateKeyToStaticPublicKeyInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Retrieve public keys
# Must be DER-encoded X.509 public keys
bob_public_key = get_public_key_bytes("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab")
alice_public_key = get_public_key_bytes("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321")
# Create the AWS KMS ECDH static keyring
sender_keyring_input = CreateAwsKmsEcdhKeyringInput(
kms_client = boto3.client('kms', region_name="us-west-2"),
curve_spec = ECDHCurveSpec.ECC_NIST_P256,
key_agreement_scheme = KmsEcdhStaticConfigurationsKmsPrivateKeyToStaticPublicKey(
KmsPrivateKeyToStaticPublicKeyInput(
sender_kms_identifier = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
sender_public_key = bob_public_key,
recipient_public_key = alice_public_key,
)
)
)
keyring = mat_prov.create_aws_kms_ecdh_keyring(sender_keyring_input)
```
------
#### [ Rust ]
Im folgenden Beispiel wird ein AWS KMS ECDH-Schlüsselbund mit dem KMS-Schlüssel des Absenders, dem öffentlichen Schlüssel des Absenders und dem öffentlichen Schlüssel des Empfängers erstellt. In diesem Beispiel wird der optionale `sender_public_key` Parameter verwendet, um den öffentlichen Schlüssel des Absenders bereitzustellen. Wenn Sie den öffentlichen Schlüssel des Absenders nicht angeben, ruft der Schlüsselbund auf, AWS KMS um den öffentlichen Schlüssel des Absenders abzurufen.
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create the AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Optional: Create your encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Retrieve public keys
// Must be DER-encoded X.509 keys
let public_key_file_content_sender = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_SENDER))?;
let parsed_public_key_file_content_sender = parse(public_key_file_content_sender)?;
let public_key_sender_utf8_bytes = parsed_public_key_file_content_sender.contents();
let public_key_file_content_recipient = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_RECIPIENT))?;
let parsed_public_key_file_content_recipient = parse(public_key_file_content_recipient)?;
let public_key_recipient_utf8_bytes = parsed_public_key_file_content_recipient.contents();
// Create KmsPrivateKeyToStaticPublicKeyInput
let kms_ecdh_static_configuration_input =
KmsPrivateKeyToStaticPublicKeyInput::builder()
.sender_kms_identifier(arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab)
// Must be a UTF8 DER-encoded X.509 public key
.sender_public_key(public_key_sender_utf8_bytes)
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let kms_ecdh_static_configuration = KmsEcdhStaticConfigurations::KmsPrivateKeyToStaticPublicKey(kms_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create AWS KMS ECDH keyring
let kms_ecdh_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client)
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_static_configuration)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Retrieve public keys
// Must be DER-encoded X.509 keys
publicKeySender, err := utils.LoadPublicKeyFromPEM(kmsEccPublicKeyFileNameSender)
if err != nil {
panic(err)
}
publicKeyRecipient, err := utils.LoadPublicKeyFromPEM(kmsEccPublicKeyFileNameRecipient)
if err != nil {
panic(err)
}
// Create KmsPrivateKeyToStaticPublicKeyInput
kmsEcdhStaticConfigurationInput := mpltypes.KmsPrivateKeyToStaticPublicKeyInput{
RecipientPublicKey: publicKeyRecipient,
SenderKmsIdentifier: arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
SenderPublicKey: publicKeySender,
}
kmsEcdhStaticConfiguration := &mpltypes.KmsEcdhStaticConfigurationsMemberKmsPrivateKeyToStaticPublicKey{
Value: kmsEcdhStaticConfigurationInput,
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create AWS KMS ECDH keyring
awsKmsEcdhKeyringInput := mpltypes.CreateAwsKmsEcdhKeyringInput{
CurveSpec: ecdhCurveSpec,
KeyAgreementScheme: kmsEcdhStaticConfiguration,
KmsClient: kmsClient,
}
awsKmsEcdhKeyring, err := matProv.CreateAwsKmsEcdhKeyring(context.Background(), awsKmsEcdhKeyringInput)
if err != nil {
panic(err)
}
```
------
## Einen AWS KMS ECDH-Discovery-Schlüsselbund erstellen
Beim Entschlüsseln empfiehlt es sich, die Schlüssel anzugeben, die sie verwenden können. AWS Encryption SDK Um dieser bewährten Methode zu folgen, verwenden Sie einen AWS KMS ECDH-Schlüsselbund mit dem `KmsPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema. Sie können jedoch auch einen AWS KMS ECDH-Discovery-Schlüsselbund erstellen, d. h. einen AWS KMS ECDH-Schlüsselbund, der jede Nachricht entschlüsseln kann, bei der der öffentliche Schlüssel des angegebenen KMS-Schlüsselpaars mit dem öffentlichen Schlüssel des *Empfängers* übereinstimmt, der im Nachrichtenchiffretext gespeichert ist.
**Wichtig**
Wenn Sie Nachrichten mithilfe des `KmsPublicKeyDiscovery` Schlüsselvereinbarungsschemas entschlüsseln, akzeptieren Sie alle öffentlichen Schlüssel, unabhängig davon, wem sie gehören.
Um einen AWS KMS ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema zu initialisieren, geben Sie die `KmsPublicKeyDiscovery` folgenden Werte an:
+ **ID des Empfängers AWS KMS key **
Muss ein von NIST empfohlenes asymmetrisches KMS-Schlüsselpaar mit elliptischer Kurve (ECC) mit einem Wert von identifizieren. `KeyUsage` `KEY_AGREEMENT`
+ **Spezifikation der Kurve**
Identifiziert die elliptische Kurvenspezifikation im KMS-Schlüsselpaar des Empfängers.
Zulässige Werte: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
+ **(Optional) Eine Liste von Grant-Tokens**
Wenn Sie den Zugriff auf den KMS-Schlüssel in Ihrem AWS KMS ECDH-Schlüsselbund mit [Grants](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) steuern, müssen Sie bei der Initialisierung des Schlüsselbunds alle erforderlichen Grant-Token angeben.
------
#### [ C\$1 / .NET ]
Im folgenden Beispiel wird ein AWS KMS ECDH-Discovery-Schlüsselbund mit einem KMS-Schlüsselpaar auf der `ECC_NIST_P256` Kurve erstellt. Sie müssen über die DeriveSharedSecret Berechtigungen [kms: GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) und [kms:](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) für das angegebene KMS-Schlüsselpaar verfügen. Dieser Schlüsselbund kann jede Nachricht entschlüsseln, bei der der öffentliche Schlüssel des angegebenen KMS-Schlüsselpaars mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Nachrichtenchiffretext gespeichert ist.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create the AWS KMS ECDH discovery keyring
var discoveryConfiguration = new KmsEcdhStaticConfigurations
{
KmsPublicKeyDiscovery = new KmsPublicKeyDiscoveryInput
{
RecipientKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = discoveryConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
Im folgenden Beispiel wird ein AWS KMS ECDH-Discovery-Schlüsselbund mit einem KMS-Schlüsselpaar auf der `ECC_NIST_P256` Kurve erstellt. Sie müssen über die DeriveSharedSecret Berechtigungen [kms: GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) und [kms:](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) für das angegebene KMS-Schlüsselpaar verfügen. Dieser Schlüsselbund kann jede Nachricht entschlüsseln, bei der der öffentliche Schlüssel des angegebenen KMS-Schlüsselpaars mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Nachrichtenchiffretext gespeichert ist.
```
// Create the AWS KMS ECDH discovery keyring
final CreateAwsKmsEcdhKeyringInput recipientKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPublicKeyDiscovery(
KmsPublicKeyDiscoveryInput.builder()
.recipientKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321").build()
).build())
.build();
```
------
#### [ Python ]
Im folgenden Beispiel wird ein AWS KMS ECDH-Discovery-Schlüsselbund mit einem KMS-Schlüsselpaar auf der `ECC_NIST_P256` Kurve erstellt. Sie müssen über die DeriveSharedSecret Berechtigungen [kms: GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) und [kms:](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) für das angegebene KMS-Schlüsselpaar verfügen. Dieser Schlüsselbund kann jede Nachricht entschlüsseln, bei der der öffentliche Schlüssel des angegebenen KMS-Schlüsselpaars mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Nachrichtenchiffretext gespeichert ist.
```
import boto3
from aws_cryptographic_materialproviders.mpl.models import (
CreateAwsKmsEcdhKeyringInput,
KmsEcdhStaticConfigurationsKmsPublicKeyDiscovery,
KmsPublicKeyDiscoveryInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS ECDH discovery keyring
create_keyring_input = CreateAwsKmsEcdhKeyringInput(
kms_client = boto3.client('kms', region_name="us-west-2"),
curve_spec = ECDHCurveSpec.ECC_NIST_P256,
key_agreement_scheme = KmsEcdhStaticConfigurationsKmsPublicKeyDiscovery(
KmsPublicKeyDiscoveryInput(
recipient_kms_identifier = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321",
)
)
)
keyring = mat_prov.create_aws_kms_ecdh_keyring(create_keyring_input)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create the AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Optional: Create your encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Create KmsPublicKeyDiscoveryInput
let kms_ecdh_discovery_static_configuration_input =
KmsPublicKeyDiscoveryInput::builder()
.recipient_kms_identifier(ecc_recipient_key_arn)
.build()?;
let kms_ecdh_discovery_static_configuration = KmsEcdhStaticConfigurations::KmsPublicKeyDiscovery(kms_ecdh_discovery_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create AWS KMS ECDH discovery keyring
let kms_ecdh_discovery_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client.clone())
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_discovery_static_configuration)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Create KmsPublicKeyDiscoveryInput
kmsEcdhDiscoveryStaticConfigurationInput := mpltypes.KmsPublicKeyDiscoveryInput{
RecipientKmsIdentifier: eccRecipientKeyArn,
}
kmsEcdhDiscoveryStaticConfiguration := &mpltypes.KmsEcdhStaticConfigurationsMemberKmsPublicKeyDiscovery{
Value: kmsEcdhDiscoveryStaticConfigurationInput,
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create AWS KMS ECDH discovery keyring
awsKmsEcdhDiscoveryKeyringInput := mpltypes.CreateAwsKmsEcdhKeyringInput{
CurveSpec: ecdhCurveSpec,
KeyAgreementScheme: kmsEcdhDiscoveryStaticConfiguration,
KmsClient: kmsClient,
}
awsKmsEcdhDiscoveryKeyring, err := matProv.CreateAwsKmsEcdhKeyring(context.Background(), awsKmsEcdhDiscoveryKeyringInput)
if err != nil {
panic(err)
}
```
------
# Unformatierte AES-Schlüsselbunde
AWS Encryption SDK Damit können Sie einen symmetrischen AES-Schlüssel verwenden, den Sie als Umschließungsschlüssel angeben, der Ihren Datenschlüssel schützt. Sie müssen das Schlüsselmaterial generieren, speichern und schützen, vorzugsweise in einem Hardware-Sicherheitsmodul (HSM) oder einem Schlüsselverwaltungssystem. Verwenden Sie einen RAW-AES-Schlüsselbund, wenn Sie den Wrap-Schlüssel bereitstellen und die Datenschlüssel lokal oder offline verschlüsseln müssen.
Der Raw AES-Schlüsselbund verschlüsselt Daten mithilfe des AES-GCM-Algorithmus und eines Wrapping-Schlüssels, den Sie als Byte-Array angeben. [Sie können in jedem Raw-AES-Schlüsselbund nur einen Wrap-Schlüssel angeben, aber Sie können mehrere Raw AES-Schlüsselanhänger, allein oder zusammen mit anderen Schlüsselbunden, in einen Mehrfachschlüsselbund aufnehmen.](use-multi-keyring.md)
Der Raw-AES-Schlüsselbund entspricht der Klasse in der und der [JceMasterKey](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/jce/JceMasterKey.html)Klasse in der AWS-Verschlüsselungs-SDK for Java und interagiert mit ihnen, AWS-Verschlüsselungs-SDK for Python wenn sie mit AES-Verschlüsselungsschlüsseln verwendet werden. [RawMasterKey](https://aws-encryption-sdk-python.readthedocs.io/en/latest/generated/aws_encryption_sdk.key_providers.raw.html#aws_encryption_sdk.key_providers.raw.RawMasterKey) Sie können Ihrer Daten mit einer Programmiersprachen-Implementierung verschlüsseln und mit jeder beliebigen anderen Sprachenimplementierung unter Verwendung desselben Umhüllungsschlüssels entschlüsseln. Details hierzu finden Sie unter [Schlüsselbund-Kompatibilität](choose-keyring.md#keyring-compatibility).
**Wichtige Namespaces und Namen**
*Um den AES-Schlüssel in einem Schlüsselbund zu identifizieren, verwendet der Raw AES-Schlüsselbund einen *Schlüsselnamespace und einen Schlüsselnamen*, die Sie angeben.* Diese Werte sind nicht geheim. Sie erscheinen im Klartext in der Kopfzeile der [verschlüsselten Nachricht](concepts.md#message), die der Verschlüsselungsvorgang zurückgibt. Wir empfehlen, für Ihr HSM- oder Schlüsselverwaltungssystem einen Schlüsselnamespace und einen Schlüsselnamen zu verwenden, der den AES-Schlüssel in diesem System identifiziert.
**Anmerkung**
Der Schlüsselnamespace und der Schlüsselname entsprechen den Feldern *Provider-ID (oder *Provider**) und *Key-ID* in den Feldern und. `JceMasterKey` `RawMasterKey`
Die Felder AWS-Verschlüsselungs-SDK for C und AWS Encryption SDK für .NET reservieren den `aws-kms` Schlüsselnamespace-Wert für KMS-Schlüssel. Verwenden Sie diesen Namespace-Wert nicht in einem Raw AES- oder Raw RSA-Schlüsselbund mit diesen Bibliotheken.
Wenn Sie verschiedene Schlüsselringe zum Verschlüsseln und Entschlüsseln einer bestimmten Nachricht erstellen, sind die Namespace- und Namenswerte entscheidend. Wenn der Schlüsselnamespace und der Schlüsselname im Schlüsselbund für die Entschlüsselung nicht exakt und unter Berücksichtigung der Groß- und Kleinschreibung mit dem Schlüsselnamespace und dem Schlüsselnamen im Verschlüsselungsschlüsselbund übereinstimmen, wird der Schlüsselbund nicht verwendet, auch wenn die Schlüsselmaterial-Bytes identisch sind.
Sie könnten beispielsweise einen RAW-AES-Schlüsselbund mit Schlüsselnamespace und Schlüsselname definieren. `HSM_01` `AES_256_012` Anschließend verwenden Sie diesen Schlüsselbund, um einige Daten zu verschlüsseln. Um diese Daten zu entschlüsseln, erstellen Sie einen RAW-AES-Schlüsselbund mit demselben Schlüsselnamespace, demselben Schlüsselnamen und demselben Schlüsselmaterial.
Die folgenden Beispiele zeigen, wie Sie einen Raw AES-Schlüsselbund erstellen. Die `AESWrappingKey` Variable steht für das von Ihnen bereitgestellte Schlüsselmaterial.
------
#### [ C ]
Um einen Raw AES-Schlüsselbund in der zu instanziieren, verwenden Sie AWS-Verschlüsselungs-SDK for C. `aws_cryptosdk_raw_aes_keyring_new()` [Ein vollständiges Beispiel finden Sie unter raw\$1aes\$1keyring.c.](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/raw_aes_keyring.c)
```
struct aws_allocator *alloc = aws_default_allocator();
AWS_STATIC_STRING_FROM_LITERAL(wrapping_key_namespace, "HSM_01");
AWS_STATIC_STRING_FROM_LITERAL(wrapping_key_name, "AES_256_012");
struct aws_cryptosdk_keyring *raw_aes_keyring = aws_cryptosdk_raw_aes_keyring_new(
alloc, wrapping_key_namespace, wrapping_key_name, aes_wrapping_key, wrapping_key_len);
```
------
#### [ C\$1 / .NET ]
Verwenden Sie die Methode, um einen Raw-AES-Schlüsselbund für.NET zu erstellen. AWS Encryption SDK `materialProviders.CreateRawAesKeyring()` Ein vollständiges Beispiel finden Sie unter [Raw AESKeyring Example.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/RawAESKeyringExample.cs).
Im folgenden Beispiel wird Version 4 verwendet. *x* und höher von AWS Encryption SDK für .NET.
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
var keyNamespace = "HSM_01";
var keyName = "AES_256_012";
// This example uses the key generator in Bouncy Castle to generate the key material.
// In production, use key material from a secure source.
var aesWrappingKey = new MemoryStream(GeneratorUtilities.GetKeyGenerator("AES256").GenerateKey());
// Create the keyring that determines how your data keys are protected.
var createKeyringInput = new CreateRawAesKeyringInput
{
KeyNamespace = keyNamespace,
KeyName = keyName,
WrappingKey = aesWrappingKey,
WrappingAlg = AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
};
var keyring = materialProviders.CreateRawAesKeyring(createKeyringInput);
```
------
#### [ JavaScript Browser ]
Das AWS-Verschlüsselungs-SDK for JavaScript im Browser bezieht seine kryptografischen Primitive von der [WebCrypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)API. Bevor Sie den Schlüsselbund erstellen, müssen Sie ihn verwenden, `RawAesKeyringWebCrypto.importCryptoKey()` um das Rohschlüsselmaterial in das Backend zu importieren. WebCrypto Dadurch wird sichergestellt, dass der Schlüsselbund vollständig ist, obwohl alle Aufrufe asynchron sind. WebCrypto
Verwenden Sie dann die Methode, um einen Raw AES-Schlüsselbund zu instanziieren. `RawAesKeyringWebCrypto()` Sie müssen den AES-Wrapping-Algorithmus („Wrapping Suite“) auf der Grundlage der Länge Ihres Schlüsselmaterials angeben. Ein vollständiges Beispiel finden Sie unter [aes\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/aes_simple.ts) (Browser). JavaScript
[Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die Standard-Commitment-Richtlinie anzugeben.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
```
import {
RawAesWrappingSuiteIdentifier,
RawAesKeyringWebCrypto,
synchronousRandomValues,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-browser'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const keyNamespace = 'HSM_01'
const keyName = 'AES_256_012'
const wrappingSuite =
RawAesWrappingSuiteIdentifier.AES256_GCM_IV12_TAG16_NO_PADDING
/* Import the plaintext AES key into the WebCrypto backend. */
const aesWrappingKey = await RawAesKeyringWebCrypto.importCryptoKey(
rawAesKey,
wrappingSuite
)
const rawAesKeyring = new RawAesKeyringWebCrypto({
keyName,
keyNamespace,
wrappingSuite,
aesWrappingKey
})
```
------
#### [ JavaScript Node.js ]
Um einen Raw AES-Schlüsselbund in der Datei AWS-Verschlüsselungs-SDK for JavaScript für Node.js zu instanziieren, erstellen Sie eine Instanz der Klasse. ` RawAesKeyringNode` Sie müssen den AES-Wrapping-Algorithmus („Wrapping Suite“) auf der Grundlage der Länge Ihres Schlüsselmaterials angeben. Ein vollständiges Beispiel finden Sie unter [aes\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript//blob/master/modules/example-node/src/aes_simple.ts) (Node.js). JavaScript
[Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die Standard-Commitment-Richtlinie anzugeben.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
```
import {
RawAesKeyringNode,
buildClient,
CommitmentPolicy,
RawAesWrappingSuiteIdentifier,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const keyName = 'AES_256_012'
const keyNamespace = 'HSM_01'
const wrappingSuite =
RawAesWrappingSuiteIdentifier.AES256_GCM_IV12_TAG16_NO_PADDING
const rawAesKeyring = new RawAesKeyringNode({
keyName,
keyNamespace,
aesWrappingKey,
wrappingSuite,
})
```
------
#### [ Java ]
Um einen Raw AES-Schlüsselbund in der zu instanziieren, verwenden Sie AWS-Verschlüsselungs-SDK for Java. `matProv.CreateRawAesKeyring()`
```
final CreateRawAesKeyringInput keyringInput = CreateRawAesKeyringInput.builder()
.keyName("AES_256_012")
.keyNamespace("HSM_01")
.wrappingKey(AESWrappingKey)
.wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(keyringInput);
```
------
#### [ Python ]
[Das folgende Beispiel instanziiert den AWS Encryption SDK Client mit der Standard-Commitment-Richtlinie,.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Ein vollständiges Beispiel finden Sie unter [raw\$1aes\$1keyring\$1example.py](https://github.com/aws/aws-encryption-sdk-python/tree/master/examples/src/raw_aes_keyring_example.py) im AWS-Verschlüsselungs-SDK for Python Repository unter. GitHub
```
# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Define the key namespace and key name
key_name_space = "HSM_01"
key_name = "AES_256_012"
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create Raw AES keyring
keyring_input: CreateRawAesKeyringInput = CreateRawAesKeyringInput(
key_namespace=key_name_space,
key_name=key_name,
wrapping_key=AESWrappingKey,
wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
)
raw_aes_keyring: IKeyring = mat_prov.create_raw_aes_keyring(
input=keyring_input
)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Define the key namespace and key name
let key_namespace: &str = "HSM_01";
let key_name: &str = "AES_256_012";
// Optional: Create an encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create Raw AES keyring
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name(key_name)
.key_namespace(key_namespace)
.wrapping_key(aws_smithy_types::Blob::new(AESWrappingKey))
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
```
------
#### [ Go ]
```
import (
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
)
//Instantiate the AWS Encryption SDK client.
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Define the key namespace and key name
var keyNamespace = "A managed aes keys"
var keyName = "My 256-bit AES wrapping key"
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create Raw AES keyring
aesKeyRingInput := mpltypes.CreateRawAesKeyringInput{
KeyName: keyName,
KeyNamespace: keyNamespace,
WrappingKey: aesWrappingKey,
WrappingAlg: mpltypes.AesWrappingAlgAlgAes256GcmIv12Tag16,
}
aesKeyring, err := matProv.CreateRawAesKeyring(context.Background(), aesKeyRingInput)
if err != nil {
panic(err)
}
```
------
# Unformatierte RSA-Schlüsselbunde
Der Raw RSA-Schlüsselbund führt eine asymmetrische Verschlüsselung und Entschlüsselung von Datenschlüsseln im lokalen Speicher mit öffentlichen und privaten RSA-Schlüsseln durch, die Sie bereitstellen. Sie müssen den privaten Schlüssel generieren, speichern und schützen, vorzugsweise in einem Hardware-Sicherheitsmodul (HSM) oder einem Schlüsselverwaltungssystem. Die Verschlüsselungsfunktion verschlüsselt den Datenschlüssel unter dem öffentlichen RSA-Schlüssel. Die Entschlüsselungsfunktion entschlüsselt den Datenschlüssel mithilfe des privaten Schlüssels. Sie können aus mehreren [RSA-Padding-Modi](https://github.com/aws/aws-encryption-sdk-c/blob/master/include/aws/cryptosdk/cipher.h) auswählen.
Ein unformatierter RSA-Schlüsselbund, der verschlüsselt und entschlüsselt, muss ein asymmetrisches öffentliches und privates Schlüsselpaar enthalten. Sie können Daten jedoch mit einem Raw RSA Keyring verschlüsseln, der nur über einen öffentlichen Schlüssel verfügt, und Sie können Daten mit einem Raw RSA Schlüsselbund entschlüsseln, der nur über einen privaten Schlüssel verfügt. [Sie können einen beliebigen Raw RSA-Schlüsselbund in einen Mehrfachschlüsselbund aufnehmen.](use-multi-keyring.md) Wenn Sie einen Raw RSA-Schlüsselbund mit einem öffentlichen und einem privaten Schlüssel konfigurieren, stellen Sie sicher, dass sie Teil desselben key pair sind. In einigen Sprachimplementierungen von AWS Encryption SDK wird kein Raw RSA-Schlüsselbund mit Schlüsseln aus verschiedenen Paaren erstellt. Andere verlassen sich darauf, dass Sie überprüfen, ob Ihre Schlüssel von demselben key pair stammen.
Der Raw RSA Keyring entspricht in the und the [JceMasterKey](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/jce/JceMasterKey.html) AWS-Verschlüsselungs-SDK for Java in und arbeitet mit ihnen zusammen, AWS-Verschlüsselungs-SDK for Python wenn sie mit [RawMasterKey](https://aws-encryption-sdk-python.readthedocs.io/en/latest/generated/aws_encryption_sdk.key_providers.raw.html#aws_encryption_sdk.key_providers.raw.RawMasterKey)asymmetrischen RSA-Verschlüsselungsschlüsseln verwendet werden. Sie können Ihrer Daten mit einer Programmiersprachen-Implementierung verschlüsseln und mit jeder beliebigen anderen Sprachenimplementierung unter Verwendung desselben Umhüllungsschlüssels entschlüsseln. Details hierzu finden Sie unter [Schlüsselbund-Kompatibilität](choose-keyring.md#keyring-compatibility).
**Anmerkung**
Der Raw RSA-Schlüsselbund unterstützt keine asymmetrischen KMS-Schlüssel. Wenn Sie asymmetrische RSA-KMS-Schlüssel verwenden möchten, unterstützen die folgenden Programmiersprachen AWS KMS Schlüsselringe, die asymmetrische RSA verwenden: AWS KMS keys
Version 3. *x* der AWS-Verschlüsselungs-SDK for Java
Ausführung 4. *x* und höher von AWS Encryption SDK für .NET
Version 4. *x* von AWS-Verschlüsselungs-SDK for Python, wenn es mit der optionalen Abhängigkeit der [Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) verwendet wird.
Version 0.1. *x* oder höher von AWS Encryption SDK for Go
Wenn Sie Daten mit einem RSA-RSA-Schlüsselbund verschlüsseln, der den öffentlichen Schlüssel eines RSA-KMS-Schlüssels enthält, können AWS Encryption SDK weder AWS KMS der RSA-KMS-Schlüssel noch diesen entschlüsseln. Sie können den privaten Schlüssel eines AWS KMS asymmetrischen KMS-Schlüssels nicht in einen Raw RSA-Schlüsselbund exportieren. Der AWS KMS Decrypt-Vorgang kann die [verschlüsselte](concepts.md#message) Nachricht, die zurückgegeben wird, nicht entschlüsseln. AWS Encryption SDK
Achten Sie beim Erstellen eines RSA-Schlüsselbunds in der darauf AWS-Verschlüsselungs-SDK for C, dass Sie den *Inhalt* der PEM-Datei, die jeden Schlüssel enthält, als Null-terminierte C-Zeichenfolge angeben, nicht als Pfad oder Dateiname. Achten Sie beim Erstellen eines unformatierten RSA-Schlüsselbunds in JavaScript auf [mögliche Inkompatibilität](javascript-compatibility.md) mit anderen Sprachenimplementierungen.
**Namespaces und Namen**
*Um das RSA-Schlüsselmaterial in einem Schlüsselbund zu identifizieren, verwendet der RSA-RSA-Schlüsselbund einen *Schlüsselnamespace und einen Schlüsselnamen*, die Sie angeben.* Diese Werte sind nicht geheim. Sie erscheinen im Klartext in der Kopfzeile der [verschlüsselten Nachricht, die der Verschlüsselungsvorgang zurückgibt](concepts.md#message). Wir empfehlen, den Schlüsselnamespace und den Schlüsselnamen zu verwenden, die das RSA-Schlüsselpaar (oder seinen privaten Schlüssel) in Ihrem HSM oder Schlüsselverwaltungssystem identifizieren.
**Anmerkung**
Der Schlüsselnamespace und der Schlüsselname entsprechen den Feldern *Provider-ID (oder *Provider**) und *Key-ID* in den Feldern und. `JceMasterKey` `RawMasterKey`
Der AWS-Verschlüsselungs-SDK for C reserviert den `aws-kms` Schlüsselnamespace-Wert für KMS-Schlüssel. Verwenden Sie ihn nicht in einem Raw AES Keyring oder Raw RSA Keyring mit dem. AWS-Verschlüsselungs-SDK for C
Wenn Sie verschiedene Schlüsselbunde zum Verschlüsseln und Entschlüsseln einer bestimmten Nachricht erstellen, sind der Namespace und die Namenswerte entscheidend. Wenn der Schlüsselnamespace und der Schlüsselname im Entschlüsselungsschlüsselbund nicht exakt und unter Berücksichtigung der Groß- und Kleinschreibung für den Schlüsselnamespace und den Schlüsselnamen im Verschlüsselungsschlüsselbund übereinstimmen, wird der Entschlüsselungsschlüsselbund nicht verwendet, auch wenn die Schlüssel aus demselben key pair stammen.
Der Schlüsselnamespace und der Schlüsselname des Schlüsselmaterials in den Verschlüsselungs- und Entschlüsselungsschlüsselbunden müssen identisch sein, unabhängig davon, ob der Schlüsselbund den öffentlichen RSA-Schlüssel, den privaten RSA-Schlüssel oder beide Schlüssel im key pair enthält. Nehmen wir beispielsweise an, Sie verschlüsseln Daten mit einem RSA-Rohschlüsselbund für einen öffentlichen RSA-Schlüssel mit Schlüsselnamespace und Schlüsselname. `HSM_01` `RSA_2048_06` Um diese Daten zu entschlüsseln, erstellen Sie einen RSA-Rohschlüsselbund mit dem privaten Schlüssel (oder key pair) und demselben Schlüsselnamespace und Namen.
**Padding-Modus**
Sie müssen einen Füllmodus für RSA-Rohschlüsselringe angeben, die für die Verschlüsselung und Entschlüsselung verwendet werden, oder Funktionen Ihrer Sprachimplementierung verwenden, die ihn für Sie spezifizieren.
Der AWS Encryption SDK unterstützt die folgenden Füllmodi, die den Einschränkungen der jeweiligen Sprache unterliegen. Wir empfehlen einen [OAEP-Padding-Modus, insbesondere OAEP](https://tools.ietf.org/html/rfc8017#section-7.1) mit SHA-256 und mit SHA-256 Padding. MGF1 Der Padding-Modus wird nur aus Gründen der Abwärtskompatibilität unterstützt. [PKCS1](https://tools.ietf.org/html/rfc8017#section-7.2)
+ OAEP mit SHA-1 und mit SHA-1 Padding MGF1
+ OAEP mit SHA-256 und mit SHA-256-Padding MGF1
+ OAEP mit SHA-384 und mit SHA-384-Padding MGF1
+ OAEP mit SHA-512 und mit SHA-512-Padding MGF1
+ PKCS1 v1.5 Polsterung
Die folgenden Beispiele zeigen, wie Sie einen RSA-Rohschlüsselbund mit dem öffentlichen und privaten Schlüssel eines RSA-Schlüsselpaars und den OAEP mit SHA-256 und dem SHA-256-Padding-Modus erstellen. MGF1 Die Variablen und stellen das von Ihnen bereitgestellte Hauptmaterial dar. `RSAPublicKey` `RSAPrivateKey`
------
#### [ C ]
Um einen RSA-Schlüsselbund in Raw zu erstellen AWS-Verschlüsselungs-SDK for C, verwenden Sie. `aws_cryptosdk_raw_rsa_keyring_new`
Achten Sie beim Aufbau eines Raw RSA-Schlüsselbunds in der darauf AWS-Verschlüsselungs-SDK for C, dass Sie den *Inhalt* der PEM-Datei, die jeden Schlüssel enthält, als Null-terminierte C-Zeichenfolge angeben, nicht als Pfad oder Dateiname. [Ein vollständiges Beispiel finden Sie unter raw\$1rsa\$1keyring.c.](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/raw_rsa_keyring.c)
```
struct aws_allocator *alloc = aws_default_allocator();
AWS_STATIC_STRING_FROM_LITERAL(key_namespace, "HSM_01");
AWS_STATIC_STRING_FROM_LITERAL(key_name, "RSA_2048_06");
struct aws_cryptosdk_keyring *rawRsaKeyring = aws_cryptosdk_raw_rsa_keyring_new(
alloc,
key_namespace,
key_name,
private_key_from_pem,
public_key_from_pem,
AWS_CRYPTOSDK_RSA_OAEP_SHA256_MGF1);
```
------
#### [ C\$1 / .NET ]
Verwenden Sie die Methode, um einen Raw RSA-Schlüsselbund in für.NET zu instanziieren. AWS Encryption SDK `materialProviders.CreateRawRsaKeyring()` [Ein vollständiges Beispiel finden Sie unter Raw Example.cs. RSAKeyring](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/RawRSAKeyringExample.cs)
Das folgende Beispiel verwendet Version 4. *x* und höher von AWS Encryption SDK für .NET.
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
var keyNamespace = "HSM_01";
var keyName = "RSA_2048_06";
// Get public and private keys from PEM files
var publicKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePublicKey.pem"));
var privateKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePrivateKey.pem"));
// Create the keyring input
var createRawRsaKeyringInput = new CreateRawRsaKeyringInput
{
KeyNamespace = keyNamespace,
KeyName = keyName,
PaddingScheme = PaddingScheme.OAEP_SHA512_MGF1,
PublicKey = publicKey,
PrivateKey = privateKey
};
// Create the keyring
var rawRsaKeyring = materialProviders.CreateRawRsaKeyring(createRawRsaKeyringInput);
```
------
#### [ JavaScript Browser ]
Das AWS-Verschlüsselungs-SDK for JavaScript im Browser bezieht seine kryptografischen Primitive aus der [WebCrypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)Bibliothek. Bevor Sie den Schlüsselbund erstellen, müssen Sie ihn verwenden, `importPublicKey()` and/or `importPrivateKey()` um das Rohschlüsselmaterial in das Backend zu importieren. WebCrypto Dadurch wird sichergestellt, dass der Schlüsselbund vollständig ist, obwohl alle Aufrufe asynchron sind. WebCrypto Das Objekt, das die Importmethoden verwenden, beinhaltet den Wrapping-Algorithmus und seinen Padding-Modus.
Verwenden Sie nach dem Import des Schlüsselmaterials die `RawRsaKeyringWebCrypto()` Methode, um den Schlüsselbund zu instanziieren. Beachten Sie bei der Erstellung eines RSA-Schlüsselbundes in Raw die [mögliche JavaScript](javascript-compatibility.md) Inkompatibilität mit anderen Sprachimplementierungen.
[Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die Standard-Commitment-Richtlinie anzugeben,.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
Ein vollständiges Beispiel finden Sie unter [rsa\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/rsa_simple.ts) (Browser). JavaScript
```
import {
RsaImportableKey,
RawRsaKeyringWebCrypto,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-browser'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const privateKey = await RawRsaKeyringWebCrypto.importPrivateKey(
privateRsaJwKKey
)
const publicKey = await RawRsaKeyringWebCrypto.importPublicKey(
publicRsaJwKKey
)
const keyNamespace = 'HSM_01'
const keyName = 'RSA_2048_06'
const keyring = new RawRsaKeyringWebCrypto({
keyName,
keyNamespace,
publicKey,
privateKey,
})
```
------
#### [ JavaScript Node.js ]
Um einen RSA-Schlüsselbund in Node.js zu instanziieren, erstellen Sie eine neue Instanz der Klasse AWS-Verschlüsselungs-SDK for JavaScript . `RawRsaKeyringNode` Der `wrapKey` Parameter enthält den öffentlichen Schlüssel. Der `unwrapKey` Parameter enthält den privaten Schlüssel. Der `RawRsaKeyringNode` Konstruktor berechnet einen Standard-Füllmodus für Sie, obwohl Sie einen bevorzugten Füllmodus angeben können.
[Beachten Sie bei der Erstellung eines RSA-Schlüsselanhängers die mögliche Inkompatibilität mit JavaScript anderen Sprachimplementierungen.](javascript-compatibility.md)
[Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die Standard-Commitment-Richtlinie anzugeben,.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
Ein vollständiges Beispiel finden Sie unter [rsa\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/rsa_simple.ts) (Node.js). JavaScript
```
import {
RawRsaKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const keyNamespace = 'HSM_01'
const keyName = 'RSA_2048_06'
const keyring = new RawRsaKeyringNode({ keyName, keyNamespace, rsaPublicKey, rsaPrivateKey})
```
------
#### [ Java ]
```
final CreateRawRsaKeyringInput keyringInput = CreateRawRsaKeyringInput.builder()
.keyName("RSA_2048_06")
.keyNamespace("HSM_01")
.paddingScheme(PaddingScheme.OAEP_SHA256_MGF1)
.publicKey(RSAPublicKey)
.privateKey(RSAPrivateKey)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
IKeyring rawRsaKeyring = matProv.CreateRawRsaKeyring(keyringInput);
```
------
#### [ Python ]
[Im folgenden Beispiel wird der Client mit der Standard-Commitment-Richtlinie instanziiert AWS Encryption SDK .](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Ein vollständiges Beispiel finden Sie unter [raw\$1rsa\$1keyring\$1example.py](https://github.com/aws/aws-encryption-sdk-python/tree/master/examples/src/raw_rsa_keyring_example.py) im AWS-Verschlüsselungs-SDK for Python Repository unter. GitHub
```
# Define the key namespace and key name
key_name_space = "HSM_01"
key_name = "RSA_2048_06"
# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create Raw RSA keyring
keyring_input: CreateRawRsaKeyringInput = CreateRawRsaKeyringInput(
key_namespace=key_name_space,
key_name=key_name,
padding_scheme=PaddingScheme.OAEP_SHA256_MGF1,
public_key=RSAPublicKey,
private_key=RSAPrivateKey
)
raw_rsa_keyring: IKeyring = mat_prov.create_raw_rsa_keyring(
input=keyring_input
)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Optional: Create an encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Define the key namespace and key name
let key_namespace: &str = "HSM_01";
let key_name: &str = "RSA_2048_06";
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create Raw RSA keyring
let raw_rsa_keyring = mpl
.create_raw_rsa_keyring()
.key_name(key_name)
.key_namespace(key_namespace)
.padding_scheme(PaddingScheme::OaepSha256Mgf1)
.public_key(aws_smithy_types::Blob::new(RSAPublicKey))
.private_key(aws_smithy_types::Blob::new(RSAPrivateKey))
.send()
.await?;
```
------
#### [ Go ]
```
// Instantiate the material providers library
matProv, err := awscryptographymaterialproviderssmithygenerated.NewClient(awscryptographymaterialproviderssmithygeneratedtypes.MaterialProvidersConfig{})
// Create Raw RSA keyring
rsaKeyRingInput := awscryptographymaterialproviderssmithygeneratedtypes.CreateRawRsaKeyringInput{
KeyName: "rsa",
KeyNamespace: "rsa-keyring",
PaddingScheme: awscryptographymaterialproviderssmithygeneratedtypes.PaddingSchemePkcs1,
PublicKey: pem.EncodeToMemory(publicKeyBlock),
PrivateKey: pem.EncodeToMemory(privateKeyBlock),
}
rsaKeyring, err := matProv.CreateRawRsaKeyring(context.Background(), rsaKeyRingInput)
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Define the key namespace and key name
var keyNamespace = "HSM_01"
var keyName = "RSA_2048_06"
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create Raw RSA keyring
rsaKeyRingInput := mpltypes.CreateRawRsaKeyringInput{
KeyName: keyName,
KeyNamespace: keyNamespace,
PaddingScheme: mpltypes.PaddingSchemeOaepSha512Mgf1,
PublicKey: (RSAPublicKey),
PrivateKey: (RSAPrivateKey),
}
rsaKeyring, err := matProv.CreateRawRsaKeyring(context.Background(), rsaKeyRingInput)
if err != nil {
panic(err)
}
```
------
# Raw ECDH Schlüsselanhänger
Der Raw ECDH-Schlüsselbund verwendet die von Ihnen angegebenen Paare aus öffentlichem und privatem Schlüssel mit elliptischer Kurve, um einen gemeinsamen Wrapping-Schlüssel zwischen zwei Parteien abzuleiten. Zunächst leitet der Schlüsselbund mithilfe des privaten Schlüssels des Absenders, des öffentlichen Schlüssels des Empfängers und des Schlüsselvereinbarungsalgorithmus Elliptic Curve Diffie-Hellman (ECDH) ein gemeinsames Geheimnis ab. Anschließend leitet der Schlüsselbund anhand des gemeinsamen geheimen Schlüssels den gemeinsamen Wrapping-Schlüssel ab, der Ihre Datenverschlüsselungsschlüssel schützt. Die Schlüsselableitungsfunktion, die (`KDF_CTR_HMAC_SHA384`) AWS Encryption SDK verwendet, um den gemeinsamen Wrapping-Schlüssel abzuleiten, entspricht den [NIST-Empfehlungen](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf) für die Schlüsselableitung.
Die Funktion zur Schlüsselableitung gibt 64 Byte an Schlüsselmaterial zurück. Um sicherzustellen, dass beide Parteien das richtige Schlüsselmaterial verwenden, AWS Encryption SDK verwendet der die ersten 32 Byte als Commitment-Schlüssel und die letzten 32 Byte als gemeinsamen Wrapping-Schlüssel. Wenn der Schlüsselbund beim Entschlüsseln nicht denselben Commitment-Schlüssel und denselben gemeinsamen Wrapping-Schlüssel reproduzieren kann, die im Chiffretext der Nachrichtenkopfzeile gespeichert sind, schlägt der Vorgang fehl. Wenn Sie beispielsweise Daten mit einem Schlüsselbund verschlüsseln, der mit **Alices** privatem Schlüssel und **Bobs öffentlichem Schlüssel konfiguriert ist**, reproduziert ein Schlüsselbund, der mit **Bobs privatem Schlüssel und Alices** **öffentlichem Schlüssel konfiguriert ist**, denselben Commitment-Schlüssel und gemeinsamen Wrapping-Schlüssel und kann die Daten entschlüsseln. Wenn Bobs öffentlicher Schlüssel aus einem AWS KMS key Paar stammt, kann Bob einen [AWS KMS ECDH-Schlüsselbund](use-kms-ecdh-keyring.md) erstellen, um die Daten zu entschlüsseln.
Der Raw ECDH-Schlüsselbund verschlüsselt Daten mit einem symmetrischen Schlüssel unter Verwendung von AES-GCM. Der Datenschlüssel wird dann mit dem abgeleiteten gemeinsamen Wrapping-Schlüssel unter Verwendung von AES-GCM umhüllt. [Jeder Raw ECDH-Schlüsselbund kann nur einen gemeinsamen Wrap-Schlüssel haben, aber Sie können mehrere Raw ECDH-Schlüsselanhänger, einzeln oder zusammen mit anderen Schlüsselbunden, in einen Mehrfachschlüsselbund aufnehmen.](use-multi-keyring.md)
Sie sind dafür verantwortlich, Ihre privaten Schlüssel zu generieren, zu speichern und zu schützen, vorzugsweise in einem Hardware-Sicherheitsmodul (HSM) oder einem Schlüsselverwaltungssystem. Die Schlüsselpaare des Absenders und des Empfängers müssen sich auf derselben elliptischen Kurve befinden. Das AWS Encryption SDK unterstützt die folgenden Spezifikationen für elliptische Kurven:
+ `ECC_NIST_P256`
+ `ECC_NIST_P384`
+ `ECC_NIST_P512`
**Kompatibilität mit Programmiersprachen**
Der Raw ECDH-Schlüsselbund wurde in Version 1.5.0 der [Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) eingeführt und wird von den folgenden Programmiersprachen und Versionen unterstützt:
+ Version 3. *x* der AWS-Verschlüsselungs-SDK for Java
+ Ausführung 4. *x* und höher von AWS Encryption SDK für .NET
+ Version 4. *x* von AWS-Verschlüsselungs-SDK for Python, wenn es mit der optionalen MPL-Abhängigkeit verwendet wird.
+ Version 1. *x* von der AWS Encryption SDK für Rust
+ Version 0.1. *x* oder höher von AWS Encryption SDK for Go
## Einen RAW-ECDH-Schlüsselbund erstellen
Der Raw ECDH-Schlüsselbund unterstützt drei wichtige Vereinbarungsschemata:, und. `RawPrivateKeyToStaticPublicKey` `EphemeralPrivateKeyToStaticPublicKey` `PublicKeyDiscovery` Das von Ihnen gewählte Schlüsselvereinbarungsschema bestimmt, welche kryptografischen Operationen Sie ausführen können und wie die Schlüsselmaterialien zusammengestellt werden.
**Topics**
+ [RawPrivateKeyToStaticPublicKey](#raw-ecdh-RawPrivateKeyToStaticPublicKey)
+ [EphemeralPrivateKeyToStaticPublicKey](#raw-ecdh-EphemeralPrivateKeyToStaticPublicKey)
+ [PublicKeyDiscovery](#raw-ecdh-PublicKeyDiscovery)
### RawPrivateKeyToStaticPublicKey
Verwenden Sie das `RawPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema, um den privaten Schlüssel des Absenders und den öffentlichen Schlüssel des Empfängers im Schlüsselbund statisch zu konfigurieren. Dieses Schlüsselvereinbarungsschema kann Daten ver- und entschlüsseln.
Um einen RAW-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema zu initialisieren, `RawPrivateKeyToStaticPublicKey` geben Sie die folgenden Werte an:
+ **Der private Schlüssel des Absenders**
[Sie müssen den PEM-codierten privaten Schlüssel des Absenders (PKCS \$18 PrivateKeyInfo -Strukturen) gemäß der Definition in RFC 5958 angeben.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Der öffentliche Schlüssel des Empfängers**
[Sie müssen den DER-codierten öffentlichen X.509-Schlüssel des Empfängers, auch bekannt als `SubjectPublicKeyInfo` (SPKI), wie in RFC 5280 definiert, angeben.](https://tools.ietf.org/html/rfc5280)
Sie können den öffentlichen Schlüssel eines KMS-Schlüsselpaars mit asymmetrischer Schlüsselvereinbarung oder den öffentlichen Schlüssel eines außerhalb von AWS generierten key pair angeben.
+ **Spezifikation der Kurve**
Identifiziert die Spezifikation für elliptische Kurven in den angegebenen Schlüsselpaaren. Sowohl die Schlüsselpaare des Absenders als auch des Empfängers müssen dieselbe Kurvenspezifikation haben.
Zulässige Werte: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var BobPrivateKey = new MemoryStream(new byte[] { });
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH static keyring
var staticConfiguration = new RawEcdhStaticConfigurations()
{
RawPrivateKeyToStaticPublicKey = new RawPrivateKeyToStaticPublicKeyInput
{
SenderStaticPrivateKey = BobPrivateKey,
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = staticConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
Das folgende Java-Beispiel verwendet das `RawPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema, um den privaten Schlüssel des Absenders und den öffentlichen Schlüssel des Empfängers statisch zu konfigurieren. Beide Schlüsselpaare befinden sich auf der `ECC_NIST_P256` Kurve.
```
private static void StaticRawKeyring() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
KeyPair senderKeys = GetRawEccKey();
KeyPair recipient = GetRawEccKey();
// Create the Raw ECDH static keyring
final CreateRawEcdhKeyringInput rawKeyringInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.RawPrivateKeyToStaticPublicKey(
RawPrivateKeyToStaticPublicKeyInput.builder()
// Must be a PEM-encoded private key
.senderStaticPrivateKey(ByteBuffer.wrap(senderKeys.getPrivate().getEncoded()))
// Must be a DER-encoded X.509 public key
.recipientPublicKey(ByteBuffer.wrap(recipient.getPublic().getEncoded()))
.build()
)
.build()
).build();
final IKeyring staticKeyring = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```
------
#### [ Python ]
Das folgende Python-Beispiel verwendet das `RawEcdhStaticConfigurationsRawPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema, um den privaten Schlüssel des Absenders und den öffentlichen Schlüssel des Empfängers statisch zu konfigurieren. Beide Schlüsselpaare befinden sich auf der `ECC_NIST_P256` Kurve.
```
import boto3
from aws_cryptographic_materialproviders.mpl.models import (
CreateRawEcdhKeyringInput,
RawEcdhStaticConfigurationsRawPrivateKeyToStaticPublicKey,
RawPrivateKeyToStaticPublicKeyInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Must be a PEM-encoded private key
bob_private_key = get_private_key_bytes()
# Must be a DER-encoded X.509 public key
alice_public_key = get_public_key_bytes()
# Create the raw ECDH static keyring
raw_keyring_input = CreateRawEcdhKeyringInput(
curve_spec = ECDHCurveSpec.ECC_NIST_P256,
key_agreement_scheme = RawEcdhStaticConfigurationsRawPrivateKeyToStaticPublicKey(
RawPrivateKeyToStaticPublicKeyInput(
sender_static_private_key = bob_private_key,
recipient_public_key = alice_public_key,
)
)
)
keyring = mat_prov.create_raw_ecdh_keyring(raw_keyring_input)
```
------
#### [ Rust ]
Das folgende Python-Beispiel verwendet das `raw_ecdh_static_configuration` Schlüsselvereinbarungsschema, um den privaten Schlüssel des Absenders und den öffentlichen Schlüssel des Empfängers statisch zu konfigurieren. Beide Schlüsselpaare müssen sich auf derselben Kurve befinden.
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Optional: Create your encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Create keyring input
let raw_ecdh_static_configuration_input =
RawPrivateKeyToStaticPublicKeyInput::builder()
// Must be a UTF8 PEM-encoded private key
.sender_static_private_key(private_key_sender_utf8_bytes)
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let raw_ecdh_static_configuration = RawEcdhStaticConfigurations::RawPrivateKeyToStaticPublicKey(raw_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create raw ECDH static keyring
let raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(raw_ecdh_static_configuration)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Optional: Create your encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Create keyring input
rawEcdhStaticConfigurationInput := mpltypes.RawPrivateKeyToStaticPublicKeyInput{
SenderStaticPrivateKey: privateKeySender,
RecipientPublicKey: publicKeyRecipient,
}
rawECDHStaticConfiguration := &mpltypes.RawEcdhStaticConfigurationsMemberRawPrivateKeyToStaticPublicKey{
Value: rawEcdhStaticConfigurationInput,
}
rawEcdhKeyRingInput := mpltypes.CreateRawEcdhKeyringInput{
CurveSpec: ecdhCurveSpec,
KeyAgreementScheme: rawECDHStaticConfiguration,
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create raw ECDH static keyring
rawEcdhKeyring, err := matProv.CreateRawEcdhKeyring(context.Background(), rawEcdhKeyRingInput)
if err != nil {
panic(err)
}
```
------
### EphemeralPrivateKeyToStaticPublicKey
Mit dem Schlüsselvereinbarungsschema konfigurierte `EphemeralPrivateKeyToStaticPublicKey` Schlüsselringe erstellen lokal ein neues key pair und leiten für jeden Verschlüsselungsaufruf einen eindeutigen gemeinsamen Wrapping-Schlüssel ab.
Dieses Schlüsselvereinbarungsschema kann nur Nachrichten verschlüsseln. Um Nachrichten zu entschlüsseln, die mit dem `EphemeralPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema verschlüsselt wurden, müssen Sie ein Discovery-Schlüsselvereinbarungsschema verwenden, das mit dem öffentlichen Schlüssel desselben Empfängers konfiguriert ist. Zum Entschlüsseln können Sie einen RAW-ECDH-Schlüsselbund mit dem [`PublicKeyDiscovery`](#raw-ecdh-PublicKeyDiscovery)Schlüsselvereinbarungsalgorithmus verwenden, oder, falls der öffentliche Schlüssel des Empfängers aus einem KMS-Schlüsselpaar mit asymmetrischer Schlüsselvereinbarung stammt, können Sie einen AWS KMS ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema verwenden. [KmsPublicKeyDiscovery](use-kms-ecdh-keyring.md#kms-ecdh-discovery)
Um einen Raw-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema zu initialisieren, geben Sie die folgenden Werte an`EphemeralPrivateKeyToStaticPublicKey`:
+ **Der öffentliche Schlüssel des Empfängers**
[Sie müssen den DER-codierten öffentlichen X.509-Schlüssel des Empfängers, auch bekannt als `SubjectPublicKeyInfo` (SPKI), wie in RFC 5280 definiert, angeben.](https://tools.ietf.org/html/rfc5280)
Sie können den öffentlichen Schlüssel eines KMS-Schlüsselpaars mit asymmetrischer Schlüsselvereinbarung oder den öffentlichen Schlüssel eines außerhalb von AWS generierten key pair angeben.
+ **Spezifikation der Kurve**
Identifiziert die Spezifikation für elliptische Kurven im angegebenen öffentlichen Schlüssel.
Beim Verschlüsseln erstellt der Schlüsselbund ein neues key pair auf der angegebenen Kurve und verwendet den neuen privaten Schlüssel und den angegebenen öffentlichen Schlüssel, um einen gemeinsamen Wrapping-Schlüssel abzuleiten.
Zulässige Werte: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema erstellt. `EphemeralPrivateKeyToStaticPublicKey` Beim Verschlüsseln erstellt der Schlüsselbund lokal auf der angegebenen `ECC_NIST_P256` Kurve ein neues key pair.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH ephemeral keyring
var ephemeralConfiguration = new RawEcdhStaticConfigurations()
{
EphemeralPrivateKeyToStaticPublicKey = new EphemeralPrivateKeyToStaticPublicKeyInput
{
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = ephemeralConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem `EphemeralPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema erstellt. Beim Verschlüsseln erstellt der Schlüsselbund lokal auf der angegebenen `ECC_NIST_P256` Kurve ein neues key pair.
```
private static void EphemeralRawEcdhKeyring() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
ByteBuffer recipientPublicKey = getPublicKeyBytes();
// Create the Raw ECDH ephemeral keyring
final CreateRawEcdhKeyringInput ephemeralInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.EphemeralPrivateKeyToStaticPublicKey(
EphemeralPrivateKeyToStaticPublicKeyInput.builder()
.recipientPublicKey(recipientPublicKey)
.build()
)
.build()
).build();
final IKeyring ephemeralKeyring = materialProviders.CreateRawEcdhKeyring(ephemeralInput);
}
```
------
#### [ Python ]
Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem `RawEcdhStaticConfigurationsEphemeralPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema erstellt. Beim Verschlüsseln erstellt der Schlüsselbund lokal auf der angegebenen `ECC_NIST_P256` Kurve ein neues key pair.
```
import boto3
from aws_cryptographic_materialproviders.mpl.models import (
CreateRawEcdhKeyringInput,
RawEcdhStaticConfigurationsEphemeralPrivateKeyToStaticPublicKey,
EphemeralPrivateKeyToStaticPublicKeyInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Your get_public_key_bytes must return a DER-encoded X.509 public key
recipient_public_key = get_public_key_bytes()
# Create the raw ECDH ephemeral private key keyring
ephemeral_input = CreateRawEcdhKeyringInput(
curve_spec = ECDHCurveSpec.ECC_NIST_P256,
key_agreement_scheme = RawEcdhStaticConfigurationsEphemeralPrivateKeyToStaticPublicKey(
EphemeralPrivateKeyToStaticPublicKeyInput(
recipient_public_key = recipient_public_key,
)
)
)
keyring = mat_prov.create_raw_ecdh_keyring(ephemeral_input)
```
------
#### [ Rust ]
Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem `ephemeral_raw_ecdh_static_configuration` Schlüsselvereinbarungsschema erstellt. Beim Verschlüsseln erstellt der Schlüsselbund lokal auf der angegebenen Kurve ein neues key pair.
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Optional: Create your encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Load public key from UTF-8 encoded PEM files into a DER encoded public key.
let public_key_file_content = std::fs::read_to_string(Path::new(EXAMPLE_ECC_PUBLIC_KEY_FILENAME_RECIPIENT))?;
let parsed_public_key_file_content = parse(public_key_file_content)?;
let public_key_recipient_utf8_bytes = parsed_public_key_file_content.contents();
// Create EphemeralPrivateKeyToStaticPublicKeyInput
let ephemeral_raw_ecdh_static_configuration_input =
EphemeralPrivateKeyToStaticPublicKeyInput::builder()
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let ephemeral_raw_ecdh_static_configuration =
RawEcdhStaticConfigurations::EphemeralPrivateKeyToStaticPublicKey(ephemeral_raw_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create raw ECDH ephemeral private key keyring
let ephemeral_raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(ephemeral_raw_ecdh_static_configuration)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Optional: Create your encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Load public key from UTF-8 encoded PEM files into a DER encoded public key
publicKeyRecipient, err := LoadPublicKeyFromPEM(eccPublicKeyFileNameRecipient)
if err != nil {
panic(err)
}
// Create EphemeralPrivateKeyToStaticPublicKeyInput
ephemeralRawEcdhStaticConfigurationInput := mpltypes.EphemeralPrivateKeyToStaticPublicKeyInput{
RecipientPublicKey: publicKeyRecipient,
}
ephemeralRawECDHStaticConfiguration :=
mpltypes.RawEcdhStaticConfigurationsMemberEphemeralPrivateKeyToStaticPublicKey{
Value: ephemeralRawEcdhStaticConfigurationInput,
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create raw ECDH ephemeral private key keyring
rawEcdhKeyRingInput := mpltypes.CreateRawEcdhKeyringInput{
CurveSpec: ecdhCurveSpec,
KeyAgreementScheme: &ephemeralRawECDHStaticConfiguration,
}
ecdhKeyring, err := matProv.CreateRawEcdhKeyring(context.Background(), rawEcdhKeyRingInput)
if err != nil {
panic(err)
}
```
------
### PublicKeyDiscovery
Beim Entschlüsseln empfiehlt es sich, die Umschließungsschlüssel anzugeben, die sie verwenden können. AWS Encryption SDK Um dieser bewährten Methode zu folgen, verwenden Sie einen ECDH-Schlüsselbund, der sowohl den privaten Schlüssel eines Absenders als auch den öffentlichen Schlüssel des Empfängers angibt. Sie können jedoch auch einen Raw ECDH Discovery-Schlüsselbund erstellen, d. h. einen Raw ECDH-Schlüsselbund, der jede Nachricht entschlüsseln kann, bei der der angegebene öffentliche Schlüssel mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Chiffretext der Nachricht gespeichert ist. Dieses Schlüsselvereinbarungsschema kann nur Nachrichten entschlüsseln.
**Wichtig**
Wenn Sie Nachrichten mithilfe des `PublicKeyDiscovery` Schlüsselvereinbarungsschemas entschlüsseln, akzeptieren Sie alle öffentlichen Schlüssel, unabhängig davon, wem sie gehören.
Um einen Raw-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema zu initialisieren, geben Sie die `PublicKeyDiscovery` folgenden Werte an:
+ **Statischer privater Schlüssel des Empfängers**
[Sie müssen den PEM-codierten privaten Schlüssel des Empfängers (PKCS \$18 PrivateKeyInfo -Strukturen) gemäß der Definition in RFC 5958 angeben.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Spezifikation der Kurve**
Identifiziert die Spezifikation für elliptische Kurven im angegebenen privaten Schlüssel. Sowohl die Schlüsselpaare des Absenders als auch des Empfängers müssen dieselbe Kurvenspezifikation haben.
Zulässige Werte: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
Im folgenden Beispiel wird ein Raw ECDH-Schlüsselbund mit dem `PublicKeyDiscovery` Schlüsselvereinbarungsschema erstellt. Dieser Schlüsselbund kann jede Nachricht entschlüsseln, bei der der öffentliche Schlüssel des angegebenen privaten Schlüssels mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Chiffretext der Nachricht gespeichert ist.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var AlicePrivateKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH discovery keyring
var discoveryConfiguration = new RawEcdhStaticConfigurations()
{
PublicKeyDiscovery = new PublicKeyDiscoveryInput
{
RecipientStaticPrivateKey = AlicePrivateKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = discoveryConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema erstellt. `PublicKeyDiscovery` Dieser Schlüsselbund kann jede Nachricht entschlüsseln, bei der der öffentliche Schlüssel des angegebenen privaten Schlüssels mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Chiffretext der Nachricht gespeichert ist.
```
private static void RawEcdhDiscovery() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
KeyPair recipient = GetRawEccKey();
// Create the Raw ECDH discovery keyring
final CreateRawEcdhKeyringInput rawKeyringInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.PublicKeyDiscovery(
PublicKeyDiscoveryInput.builder()
// Must be a PEM-encoded private key
.recipientStaticPrivateKey(ByteBuffer.wrap(sender.getPrivate().getEncoded()))
.build()
)
.build()
).build();
final IKeyring publicKeyDiscovery = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```
------
#### [ Python ]
Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema erstellt. `RawEcdhStaticConfigurationsPublicKeyDiscovery` Dieser Schlüsselbund kann jede Nachricht entschlüsseln, bei der der öffentliche Schlüssel des angegebenen privaten Schlüssels mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Chiffretext der Nachricht gespeichert ist.
```
import boto3
from aws_cryptographic_materialproviders.mpl.models import (
CreateRawEcdhKeyringInput,
RawEcdhStaticConfigurationsPublicKeyDiscovery,
PublicKeyDiscoveryInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Your get_private_key_bytes must return a PEM-encoded private key
recipient_private_key = get_private_key_bytes()
# Create the raw ECDH discovery keyring
raw_keyring_input = CreateRawEcdhKeyringInput(
curve_spec = ECDHCurveSpec.ECC_NIST_P256,
key_agreement_scheme = RawEcdhStaticConfigurationsPublicKeyDiscovery(
PublicKeyDiscoveryInput(
recipient_static_private_key = recipient_private_key,
)
)
)
keyring = mat_prov.create_raw_ecdh_keyring(raw_keyring_input)
```
------
#### [ Rust ]
Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema erstellt. `discovery_raw_ecdh_static_configuration` Dieser Schlüsselbund kann jede Nachricht entschlüsseln, bei der der öffentliche Schlüssel des angegebenen privaten Schlüssels mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Chiffretext der Nachricht gespeichert ist.
```
// Instantiate the AWS Encryption SDK client and material providers library
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Optional: Create your encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Load keys from UTF-8 encoded PEM files.
let mut file = File::open(Path::new(EXAMPLE_ECC_PRIVATE_KEY_FILENAME_RECIPIENT))?;
let mut private_key_recipient_utf8_bytes = Vec::new();
file.read_to_end(&mut private_key_recipient_utf8_bytes)?;
// Create PublicKeyDiscoveryInput
let discovery_raw_ecdh_static_configuration_input =
PublicKeyDiscoveryInput::builder()
// Must be a UTF8 PEM-encoded private key
.recipient_static_private_key(private_key_recipient_utf8_bytes)
.build()?;
let discovery_raw_ecdh_static_configuration =
RawEcdhStaticConfigurations::PublicKeyDiscovery(discovery_raw_ecdh_static_configuration_input);
// Create raw ECDH discovery private key keyring
let discovery_raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(discovery_raw_ecdh_static_configuration)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Optional: Create your encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Load keys from UTF-8 encoded PEM files.
privateKeyRecipient, err := os.ReadFile(eccPrivateKeyFileNameRecipient)
if err != nil {
panic(err)
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create PublicKeyDiscoveryInput
discoveryRawEcdhStaticConfigurationInput := mpltypes.PublicKeyDiscoveryInput{
RecipientStaticPrivateKey: privateKeyRecipient,
}
discoveryRawEcdhStaticConfiguration := &mpltypes.RawEcdhStaticConfigurationsMemberPublicKeyDiscovery{
Value: discoveryRawEcdhStaticConfigurationInput,
}
// Create raw ECDH discovery private key keyring
discoveryRawEcdhKeyringInput := mpltypes.CreateRawEcdhKeyringInput{
CurveSpec: ecdhCurveSpec,
KeyAgreementScheme: discoveryRawEcdhStaticConfiguration,
}
discoveryRawEcdhKeyring, err := matProv.CreateRawEcdhKeyring(context.Background(), discoveryRawEcdhKeyringInput)
if err != nil {
panic(err)
}
```
------
# Multi-Schlüsselbunde
Sie können Schlüsselbunde zu einem Multi-Schlüsselbund kombinieren. Ein *Multi-Schlüsselbund* ist ein Schlüsselbund, der aus einem oder mehreren einzelnen Schlüsselbunden desselben oder eines anderen Typs besteht. Das hat den gleichen Effekt wie die Verwendung von mehreren Schlüsselbunden in einer Reihe. Wenn Sie einen Multi-Schlüsselbund verwenden, um Daten zu verschlüsseln, können alle Umhüllungsschlüssel in einem seiner Schlüsselbunde diese Daten entschlüsseln.
Wenn Sie einen Multi-Schlüsselbund erstellen, um Daten zu verschlüsseln, geben Sie einen der Schlüsselbunde als *Generator-Schlüsselbund* an. Alle anderen Schlüsselbunde werden als *untergeordnete Schlüsselbunde* bezeichnet. Der Generator-Schlüsselbund generiert und verschlüsselt den Klartext-Datenschlüssel. Anschließend verschlüsseln alle Umhüllungsschlüssel in den untergeordneten Schlüsselbunden den gleichen Klartext-Datenschlüssel. Der Multi-Schlüsselbund gibt den Klartext-Datenschlüssel und einen verschlüsselten Datenschlüssel für jeden Umhüllungsschlüssel im Multi-Schlüsselbund zurück. Wenn der Generator-Schlüsselbund ein [KMS-Schlüsselbund](use-kms-keyring.md) ist, generiert und verschlüsselt der Generatorschlüssel im AWS KMS Schlüsselbund den Klartext-Schlüssel. Anschließend verschlüsseln alle zusätzlichen Schlüssel AWS KMS keys im AWS KMS Schlüsselbund und alle Schlüssel in allen untergeordneten Schlüsselbunden im Mehrfachschlüsselbund denselben Klartext-Schlüssel.
Wenn Sie einen Mehrfachschlüsselbund ohne Generatorschlüsselbund erstellen, können Sie ihn eigenständig zum Entschlüsseln von Daten verwenden, aber nicht zum Verschlüsseln. Oder wenn Sie bei Verschlüsselungsvorgängen einen Mehrfachschlüsselbund ohne Generatorschlüsselbund verwenden möchten, können Sie ihn als untergeordneten Schlüsselbund in einem anderen Schlüsselbund angeben. Ein Mehrfachschlüsselbund ohne Generator-Schlüsselbund kann nicht als Generator-Schlüsselbund in einem anderen Schlüsselbund mit mehreren Schlüsseln bezeichnet werden.
Beim Entschlüsseln versucht der AWS Encryption SDK anhand der Schlüsselbunde, einen der verschlüsselten Datenschlüssel zu entschlüsseln. Die Schlüsselbunde werden in der Reihenfolge aufgerufen, in der sie im Multi-Schlüsselbund angegeben sind. Die Verarbeitung stoppt, sobald ein Schlüssel in einem Schlüsselbund einen verschlüsselten Datenschlüssel entschlüsseln kann.
[Ab Version 1.7. ](about-versions.md#version-1.7)*x*, wenn ein verschlüsselter Datenschlüssel unter einem AWS Key Management Service (AWS KMS) -Schlüsselbund (oder einem Hauptschlüsselanbieter) verschlüsselt wird, übergibt der AWS Encryption SDK immer den Schlüssel-ARN von AWS KMS key an den `KeyId` Parameter der AWS KMS [Decrypt-Operation](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html). Dies ist eine AWS KMS bewährte Methode, die sicherstellt, dass Sie den verschlüsselten Datenschlüssel mit dem Wrapping-Schlüssel entschlüsseln, den Sie verwenden möchten.
Ein funktionierendes Beispiel für einen Multi-Schlüsselbund finden Sie unter:
+ C: [multi\$1keyring.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/multi_keyring.cpp)[]()
+ [C\$1/.NET: .cs MultiKeyringExample](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/MultiKeyringExample.cs)
+ JavaScript [Node.js: multi\$1keyring.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/multi_keyring.ts)
+ JavaScript Browser: [multi\$1keyring.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/multi_keyring.ts)
+ Java [MultiKeyringExample: .java](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/keyrings/MultiKeyringExample.java)
+ Python: [multi\$1keyring\$1example.py](https://github.com/aws/aws-encryption-sdk-python/tree/master/examples/src/multi_keyring_example.py)
Zum Erstellen eines Multi-Schlüsselbunds müssen Sie zuerst die untergeordneten Schlüsselbunde instanziieren. In diesem Beispiel verwenden wir einen AWS KMS Schlüsselbund und einen Raw AES-Schlüsselbund, aber Sie können jeden unterstützten Schlüsselbund in einem Mehrfachschlüsselbund kombinieren.
------
#### [ C ]
```
/* Define an AWS KMS keyring. For details, see [string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/string.cpp) */
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(example_key);
// Define a Raw AES keyring. For details, see [raw\$1aes\$1keyring.c](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/raw_aes_keyring.c) */
struct aws_cryptosdk_keyring *aes_keyring = aws_cryptosdk_raw_aes_keyring_new(
alloc, wrapping_key_namespace, wrapping_key_name, wrapping_key, AWS_CRYPTOSDK_AES256);
```
------
#### [ C\$1 / .NET ]
```
// Define an AWS KMS keyring. For details, see [AwsKmsKeyringExample.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/AwsKmsKeyringExample.cs).
var kmsKeyring = materialProviders.CreateAwsKmsKeyring(createKmsKeyringInput);
// Define a Raw AES keyring. For details, see [RawAESKeyringExample.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/RawAESKeyringExample.cs).
var aesKeyring = materialProviders.CreateRawAesKeyring(createAesKeyringInput);
```
------
#### [ JavaScript Browser ]
[Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die Standard-Commitment-Richtlinie anzugeben.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
```
import {
KmsKeyringBrowser,
KMS,
getClient,
RawAesKeyringWebCrypto,
RawAesWrappingSuiteIdentifier,
MultiKeyringWebCrypto,
buildClient,
CommitmentPolicy,
synchronousRandomValues,
} from '@aws-crypto/client-browser'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const clientProvider = getClient(KMS, { credentials })
// Define an AWS KMS keyring. For details, see [kms\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/kms_simple.ts).
const kmsKeyring = new KmsKeyringBrowser({ generatorKeyId: exampleKey })
// Define a Raw AES keyring. For details, see [aes\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/aes_simple.ts).
const aesKeyring = new RawAesKeyringWebCrypto({ keyName, keyNamespace, wrappingSuite, masterKey })
```
------
#### [ JavaScript Node.js ]
Im folgenden Beispiel wird die `buildClient` Funktion verwendet, um die [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) anzugeben,`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`. Sie können die auch verwenden`buildClient`, um die Anzahl der verschlüsselten Datenschlüssel in einer verschlüsselten Nachricht zu begrenzen. Weitere Informationen finden Sie unter [Beschränkung verschlüsselter Datenschlüssel](configure.md#config-limit-keys).
```
import {
MultiKeyringNode,
KmsKeyringNode,
RawAesKeyringNode,
RawAesWrappingSuiteIdentifier,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
// Define an AWS KMS keyring. For details, see [kms\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_simple.ts).
const kmsKeyring = new KmsKeyringNode({ generatorKeyId: exampleKey })
// Define a Raw AES keyring. For details, see [raw\$1aes\$1keyring\$1node.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/raw-aes-keyring-node/src/raw_aes_keyring_node.ts).
const aesKeyring = new RawAesKeyringNode({ keyName, keyNamespace, wrappingSuite, unencryptedMasterKey })
```
------
#### [ Java ]
```
// Define the raw AES keyring.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateRawAesKeyringInput createRawAesKeyringInput = CreateRawAesKeyringInput.builder()
.keyName("AES_256_012")
.keyNamespace("HSM_01")
.wrappingKey(AESWrappingKey)
.wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16)
.build();
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(createRawAesKeyringInput);
// Define the AWS KMS keyring.
final CreateAwsKmsMrkMultiKeyringInput createAwsKmsMrkMultiKeyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyArn)
.build();
IKeyring awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Python ]
Im folgenden Beispiel wird der AWS Encryption SDK Client mit der [Standard-Commitment-Richtlinie](migrate-commitment-policy.md) instanziiert,. `REQUIRE_ENCRYPT_REQUIRE_DECRYPT`
```
# Create the AWS KMS keyring
kms_client = boto3.client('kms', region_name="us-west-2")
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
kms_keyring_input: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
generator=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
kms_client=kms_client
)
kms_keyring: IKeyring = mat_prov.create_aws_kms_keyring(
input=kms_keyring_input
)
# Create Raw AES keyring
key_name_space = "HSM_01"
key_name = "AES_256_012"
raw_aes_keyring_input: CreateRawAesKeyringInput = CreateRawAesKeyringInput(
key_namespace=key_name_space,
key_name=key_name,
wrapping_key=AESWrappingKey,
wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
)
raw_aes_keyring: IKeyring = mat_prov.create_raw_aes_keyring(
input=raw_aes_keyring_input
)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create the AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create an AWS KMS keyring
let kms_keyring = mpl
.create_aws_kms_keyring()
.kms_key_id(kms_key_id)
.kms_client(kms_client)
.send()
.await?;
// Create a Raw AES keyring
let key_namespace: &str = "my-key-namespace";
let key_name: &str = "my-aes-key-name";
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name(key_name)
.key_namespace(key_namespace)
.wrapping_key(aws_smithy_types::Blob::new(AESWrappingKey))
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS keyring
awsKmsKeyringInput := mpltypes.CreateAwsKmsKeyringInput{
KmsClient: kmsClient,
KmsKeyId: kmsKeyId,
}
awsKmsKeyring, err := matProv.CreateAwsKmsKeyring(context.Background(), awsKmsKeyringInput)
if err != nil {
panic(err)
}
// Create a Raw AES keyring
var keyNamespace = "my-key-namespace"
var keyName = "my-aes-key-name"
aesKeyRingInput := mpltypes.CreateRawAesKeyringInput{
KeyName: keyName,
KeyNamespace: keyNamespace,
WrappingKey: AESWrappingKey,
WrappingAlg: mpltypes.AesWrappingAlgAlgAes256GcmIv12Tag16,
}
aesKeyring, err := matProv.CreateRawAesKeyring(context.Background(), aesKeyRingInput)
```
------
Erstellen Sie als Nächstes den Multi-Schlüsselbund und geben Sie seinen Generator-Schlüsselbund an, falls vorhanden. In diesem Beispiel erstellen wir einen Mehrfachschlüsselbund, bei dem der Schlüsselbund der AWS KMS Generatorschlüsselbund und der AES-Schlüsselbund der untergeordnete Schlüsselbund ist.
------
#### [ C ]
Im Multi-Schlüsselbund-Konstruktor in C geben Sie nur den Generator-Schlüsselbund an.
```
struct aws_cryptosdk_keyring *multi_keyring = aws_cryptosdk_multi_keyring_new(alloc, kms_keyring);
```
Verwenden Sie die `aws_cryptosdk_multi_keyring_add_child`-Methode, um einen untergeordneten Schlüsselbund zu Ihrem Multi-Schlüsselbund hinzuzufügen. Sie müssen die Methode einmal für jeden untergeordneten Schlüsselbund aufrufen, den Sie hinzufügen.
```
// Add the Raw AES keyring (C only)
aws_cryptosdk_multi_keyring_add_child(multi_keyring, aes_keyring);
```
------
#### [ C\$1 / .NET ]
Mit `CreateMultiKeyringInput` dem.NET-Konstruktor können Sie einen Generator-Schlüsselbund und untergeordnete Schlüsselanhänger definieren. Das resultierende `CreateMultiKeyringInput` Objekt ist unveränderlich.
```
var createMultiKeyringInput = new CreateMultiKeyringInput
{
Generator = kmsKeyring,
ChildKeyrings = new List() {aesKeyring}
};
var multiKeyring = materialProviders.CreateMultiKeyring(createMultiKeyringInput);
```
------
#### [ JavaScript Browser ]
JavaScript Mehrfachschlüsselringe sind unveränderlich. Mit dem Konstruktor für JavaScript mehrere Schlüsselbunde können Sie den Generator-Schlüsselbund und mehrere untergeordnete Schlüsselringe angeben.
```
const clientProvider = getClient(KMS, { credentials })
const multiKeyring = new MultiKeyringWebCrypto(generator: kmsKeyring, children: [aesKeyring]);
```
------
#### [ JavaScript Node.js ]
JavaScript Schlüsselanhänger mit mehreren Schlüsseln sind unveränderlich. Mit dem Konstruktor für JavaScript mehrere Schlüsselbunde können Sie den Generator-Schlüsselbund und mehrere untergeordnete Schlüsselringe angeben.
```
const multiKeyring = new MultiKeyringNode(generator: kmsKeyring, children: [aesKeyring]);
```
------
#### [ Java ]
Mit dem `CreateMultiKeyringInput` Java-Konstruktor können Sie einen Generator-Schlüsselbund und untergeordnete Schlüsselringe definieren. Das resultierende `createMultiKeyringInput` Objekt ist unveränderlich.
```
final CreateMultiKeyringInput createMultiKeyringInput = CreateMultiKeyringInput.builder()
.generator(awsKmsMrkMultiKeyring)
.childKeyrings(Collections.singletonList(rawAesKeyring))
.build();
IKeyring multiKeyring = matProv.CreateMultiKeyring(createMultiKeyringInput);
```
------
#### [ Python ]
```
multi_keyring_input: CreateMultiKeyringInput = CreateMultiKeyringInput(
generator=kms_keyring,
child_keyrings=[raw_aes_keyring]
)
multi_keyring: IKeyring = mat_prov.create_multi_keyring(
input=multi_keyring_input
)
```
------
#### [ Rust ]
```
let multi_keyring = mpl
.create_multi_keyring()
.generator(kms_keyring.clone())
.child_keyrings(vec![raw_aes_keyring.clone()])
.send()
.await?;
```
------
#### [ Go ]
```
createMultiKeyringInput := mpltypes.CreateMultiKeyringInput{
Generator: awsKmsKeyring,
ChildKeyrings: []mpltypes.IKeyring{rawAESKeyring},
}
multiKeyring, err := matProv.CreateMultiKeyring(context.Background(), createMultiKeyringInput)
if err != nil {
panic(err)
}
```
------
Jetzt können Sie mit dem Multi-Schlüsselbund Daten ver- und entschlüsseln.