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.
# Migrieren Sie Ihre AWS Encryption SDK
Das AWS Encryption SDK unterstützt mehrere interoperable [Programmiersprachenimplementierungen](programming-languages.md), von denen jede in einem Open-Source-Repository am entwickelt wurde. GitHub Als [bewährte Methode](best-practices.md) empfehlen wir, dass Sie AWS Encryption SDK für jede Sprache die neueste Version von verwenden.
Sie können problemlos ein Upgrade von Version 2.0 durchführen. *x* oder höher von AWS Encryption SDK auf die neueste Version. Allerdings die 2.0. Die *X-Version* von AWS Encryption SDK führt wichtige neue Sicherheitsfunktionen ein, von denen einige grundlegende Änderungen darstellen. Um ein Upgrade von Versionen vor 1.7 durchzuführen. *x* auf Versionen 2.0. *x* und höher, Sie müssen zuerst auf die neueste Version 1 aktualisieren. *x-Version*. Die Themen in diesem Abschnitt sollen Ihnen helfen, die Änderungen zu verstehen, die richtige Version für Ihre Anwendung auszuwählen und sicher und erfolgreich auf die neuesten Versionen von zu migrieren AWS Encryption SDK.
Informationen zu wichtigen Versionen von finden Sie unter[Versionen von AWS Encryption SDK](about-versions.md). AWS Encryption SDK
**Wichtig**
Führen Sie kein direktes Upgrade von einer Version vor 1.7 durch. *x* auf Version 2.0. *x* oder höher, ohne zuerst auf die neueste Version 1 aktualisiert zu haben. *x-Version*. Wenn Sie direkt auf Version 2.0 aktualisieren. *x* oder höher und alle neuen Funktionen sofort aktivieren, können Chiffretext, der unter älteren Versionen von verschlüsselt wurde, AWS Encryption SDK nicht entschlüsseln. AWS Encryption SDK
**Anmerkung**
Die früheste Version von AWS Encryption SDK für .NET ist Version 3.0. *x.* Alle Versionen von AWS Encryption SDK für .NET unterstützen die in 2.0 eingeführten bewährten Sicherheitsmethoden. *x* der AWS Encryption SDK. Sie können sicher auf die neueste Version aktualisieren, ohne Code- oder Datenänderungen vornehmen zu müssen.
AWS Verschlüsselungs-CLI: Verwenden Sie beim Lesen dieses Migrationshandbuchs die Version 1.7. *x* Migrationsanweisungen für AWS Encryption CLI 1.8. *x* und verwende 2.0. *x* Migrationsanweisungen für AWS Encryption CLI 2.1. *x.* Details hierzu finden Sie unter [Versionen der AWS Encryption CLI](crypto-cli-versions.md).
Neue Sicherheitsfunktionen wurden ursprünglich in den AWS Encryption CLI Versionen 1.7 veröffentlicht. *x* und 2.0. *x.* Allerdings AWS Encryption CLI Version 1.8. *x* ersetzt Version 1.7. *x* und AWS Encryption CLI 2.1. *x* ersetzt 2.0. *x.* Einzelheiten finden Sie in der entsprechenden [Sicherheitsempfehlung](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) im [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)Repository unter GitHub.
**Neuer Benutzer**
Wenn Sie mit dem noch nicht vertraut sind AWS Encryption SDK, installieren Sie die neueste Version von AWS Encryption SDK für Ihre Programmiersprache. Die Standardwerte aktivieren alle Sicherheitsfunktionen von AWS Encryption SDK, einschließlich Verschlüsselung mit Signierung, Schlüsselableitung und [Schlüsselzusage](concepts.md#key-commitment). des AWS Encryption SDK
**Aktuelle Benutzer**
Wir empfehlen Ihnen, so bald wie möglich ein Upgrade von Ihrer aktuellen Version auf die neueste verfügbare Version durchzuführen. Alles 1. *X-Versionen* von AWS Encryption SDK befinden sich in der [end-of-support Phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), ebenso wie spätere Versionen in einigen Programmiersprachen. Einzelheiten zum Support- und Wartungsstatus von AWS Encryption SDK in Ihrer Programmiersprache finden Sie unter[Support und Wartung](introduction.md#support).
AWS Encryption SDK Versionen 2.0. *x* und höher bieten neue Sicherheitsfunktionen zum Schutz Ihrer Daten. AWS Encryption SDK Version 2.0 jedoch. *x* beinhaltet grundlegende Änderungen, die nicht abwärtskompatibel sind. Um einen sicheren Übergang zu gewährleisten, sollten Sie zunächst von Ihrer aktuellen Version auf die neueste Version 1 migrieren. *x* in Ihrer Programmiersprache. Wann dein letzter 1. Die *x-Version* ist vollständig implementiert und funktioniert erfolgreich. Sie können sicher auf die Versionen 2.0 migrieren. *x* und später. Dieser [zweistufige Prozess](migration-guide.md) ist besonders für verteilte Anwendungen von entscheidender Bedeutung.
*Weitere Informationen zu den AWS Encryption SDK Sicherheitsfunktionen, die diesen Änderungen zugrunde liegen, finden Sie im [Sicherheitsblog unter Verbesserte clientseitige Verschlüsselung: Explizite KeyIds und zentrale Verpflichtung](https://aws.amazon.com/blogs/security/improved-client-side-encryption-explicit-keyids-and-key-commitment/).AWS *
Benötigen Sie Hilfe bei der Verwendung von mit dem? AWS-Verschlüsselungs-SDK for Java AWS SDK for Java 2.x Siehe [Voraussetzungen](java.md#java-prerequisites).
**Topics**
+ [Wie migriert und implementiert man AWS Encryption SDK](migration-guide.md)
+ [Aktualisierung der AWS KMS Hauptschlüsselanbieter](migrate-mkps-v2.md)
+ [AWS KMS Schlüsselanhänger aktualisieren](migrate-keyrings-v2.md)
+ [Festlegung Ihrer Verpflichtungspolitik](migrate-commitment-policy.md)
+ [Fehlerbehebung bei der Migration auf die neuesten Versionen](troubleshooting-migration.md)
# Wie migriert und implementiert man AWS Encryption SDK
Bei der Migration von einer AWS Encryption SDK Version vor 1.7. *x* auf Version 2.0. *x* oder höher, Sie müssen sicher auf Verschlüsselung mit [Schlüsselbindung](concepts.md#key-commitment) umsteigen. Andernfalls wird Ihre Anwendung auf Chiffretexte stoßen, die sie nicht entschlüsseln kann. Wenn Sie AWS KMS Hauptschlüsselanbieter verwenden, müssen Sie auf neue Konstruktoren aktualisieren, die Hauptschlüsselanbieter im strikten Modus oder im Discovery-Modus erstellen.
**Anmerkung**
Dieses Thema richtet sich an Benutzer, die von früheren Versionen von AWS Encryption SDK auf Version 2.0 migrieren. *x* oder höher. Wenn Sie mit dem noch nicht vertraut sind AWS Encryption SDK, können Sie sofort damit beginnen, die neueste verfügbare Version mit den Standardeinstellungen zu verwenden.
Um eine kritische Situation zu vermeiden, in der Sie den Chiffretext, den Sie lesen müssen, nicht entschlüsseln können, empfehlen wir, die Migration und Bereitstellung in mehreren verschiedenen Phasen durchzuführen. Stellen Sie sicher, dass jede Phase abgeschlossen und vollständig bereitgestellt ist, bevor Sie mit der nächsten Phase beginnen. Dies ist besonders wichtig für verteilte Anwendungen mit mehreren Hosts.
## Phase 1: Aktualisieren Sie Ihre Anwendung auf die neueste Version 1. *x-Version*
Auf die neueste Version aktualisieren 1. *x-Version* für Ihre Programmiersprache. Testen Sie sorgfältig, implementieren Sie Ihre Änderungen und stellen Sie sicher, dass das Update auf alle Zielhosts übertragen wurde, bevor Sie mit Phase 2 beginnen.
**Wichtig**
Vergewissern Sie sich, dass Ihre neueste Version 1 *x-Version* ist Version 1.7. *x* oder höher von AWS Encryption SDK.
Das letzte 1. *x-Versionen* von AWS Encryption SDK sind abwärtskompatibel mit älteren Versionen von AWS Encryption SDK und aufwärtskompatibel mit Versionen 2.0. *x* und später. Sie enthalten die neuen Funktionen, die in Version 2.0 enthalten sind. *x*, enthalten jedoch sichere Standardeinstellungen, die für diese Migration entwickelt wurden. Sie ermöglichen es Ihnen, Ihre AWS KMS Hauptschlüsselanbieter bei Bedarf zu aktualisieren und die vollständige Implementierung mit Algorithmus-Suiten durchzuführen, die Chiffretext mit Schlüsselbindung entschlüsseln können.
+ Ersetzen Sie veraltete Elemente, einschließlich Konstruktoren für ältere Hauptschlüsselanbieter. AWS KMS Stellen Sie in [Python](https://docs.python.org/3/library/warnings.html) sicher, dass Sie Verfallswarnungen aktivieren. Codeelemente, die in der neuesten Version veraltet sind. *x-Versionen* wurden aus den Versionen 2.0 entfernt. *x* und später.
+ Legen Sie Ihre Verpflichtungspolitik ausdrücklich auf fest`ForbidEncryptAllowDecrypt`. Dies ist zwar der einzig gültige Wert in der letzten Version 1. *X-Versionen*, diese Einstellung ist erforderlich, wenn Sie die in dieser Version APIs eingeführten verwenden. Dadurch wird verhindert, dass Ihre Anwendung bei der Migration auf Version 2.0 verschlüsselten Chiffretext zurückweist, der ohne Schlüsselzuweisung verschlüsselt wurde. *x* und höher. Details hierzu finden Sie unter [Festlegung Ihrer Verpflichtungspolitik](migrate-commitment-policy.md).
+ Wenn Sie AWS KMS Hauptschlüsselanbieter verwenden, müssen Sie Ihre älteren Hauptschlüsselanbieter auf Masterschlüsselanbieter aktualisieren, die den *strikten Modus und den* *Erkennungsmodus* unterstützen. Dieses Update ist für die AWS-Verschlüsselungs-SDK for Java AWS-Verschlüsselungs-SDK for Python, und die AWS Encryption CLI erforderlich. Wenn Sie Master-Key-Anbieter im Discovery-Modus verwenden, empfehlen wir Ihnen, den Discovery-Filter zu implementieren, der die verwendeten Wrapping-Schlüssel auf diese beschränkt AWS-Konten. Dieses Update ist optional, aber es ist eine [bewährte Methode](best-practices.md), die wir empfehlen. Details hierzu finden Sie unter [Aktualisierung der AWS KMS Hauptschlüsselanbieter](migrate-mkps-v2.md).
+ Wenn Sie [AWS KMS Erkennungsschlüsselringe](use-kms-keyring.md#kms-keyring-discovery) verwenden, empfehlen wir Ihnen, einen Erkennungsfilter einzubauen, der die bei der Entschlüsselung verwendeten Wrapping-Schlüssel auf bestimmte Schlüssel beschränkt. AWS-Konten Dieses Update ist optional, aber es ist eine [bewährte Methode](best-practices.md), die wir empfehlen. Details hierzu finden Sie unter [AWS KMS Schlüsselanhänger aktualisieren](migrate-keyrings-v2.md).
## Phase 2: Aktualisieren Sie Ihre Anwendung auf die neueste Version
Nach der Bereitstellung der neuesten Version 1. Die *x-Version* wurde erfolgreich auf allen Hosts installiert. Sie können ein Upgrade auf die Versionen 2.0 durchführen. *x* und später. Version 2.0. *x* enthält wichtige Änderungen für alle früheren Versionen von AWS Encryption SDK. Wenn Sie jedoch die in Phase 1 empfohlenen Codeänderungen vornehmen, können Sie Fehler bei der Migration zur neuesten Version vermeiden.
Stellen Sie vor dem Update auf die neueste Version sicher, dass Ihre Verpflichtungsrichtlinie durchgängig auf eingestellt ist`ForbidEncryptAllowDecrypt`. Abhängig von Ihrer Datenkonfiguration können Sie dann in Ihrem eigenen Tempo zur Standardeinstellung migrieren `RequireEncryptAllowDecrypt` und dann zur Standardeinstellung`RequireEncryptRequireDecrypt`. Wir empfehlen eine Reihe von Übergangsschritten wie das folgende Muster.
1. Beginnen Sie mit Ihrer [Verpflichtungspolitik](migrate-commitment-policy.md), die auf eingestellt ist`ForbidEncryptAllowDecrypt`. Der AWS Encryption SDK kann Nachrichten mit Key Commitment entschlüsseln, verschlüsselt aber noch nicht mit Key Commitment.
1. Wenn Sie bereit sind, aktualisieren Sie Ihre Verpflichtungsrichtlinie auf. `RequireEncryptAllowDecrypt` Das AWS Encryption SDK beginnt mit der Verschlüsselung Ihrer Daten mit [Schlüsselverpflichtung](concepts.md#key-commitment). Es kann Chiffretext mit und ohne Schlüsselbindung entschlüsseln.
Bevor Sie Ihre Verpflichtungsrichtlinie auf aktualisieren, vergewissern Sie sich`RequireEncryptAllowDecrypt`, dass Ihre neueste Version 1. Die *X-Version* wird auf allen Hosts bereitgestellt, einschließlich der Hosts aller Anwendungen, die den von Ihnen erstellten Chiffretext entschlüsseln. Versionen der Vorgängerversion AWS Encryption SDK vor Version 1.7. *x* kann Nachrichten, die mit Key Commitment verschlüsselt wurden, nicht entschlüsseln.
Dies ist auch ein guter Zeitpunkt, um Ihrer Anwendung Metriken hinzuzufügen, mit denen Sie messen können, ob Sie immer noch Chiffretext ohne Schlüsselbindung verarbeiten. Auf diese Weise können Sie feststellen, wann es sicher ist, Ihre Richtlinieneinstellung für Verpflichtungen zu aktualisieren. `RequireEncryptRequireDecrypt` Für einige Anwendungen, z. B. solche, die Nachrichten in einer Amazon SQS SQS-Warteschlange verschlüsseln, kann dies bedeuten, dass lange genug gewartet wird, bis der gesamte in alten Versionen verschlüsselte Chiffretext erneut verschlüsselt oder gelöscht wurde. Für andere Anwendungen, wie z. B. verschlüsselte S3-Objekte, müssen Sie möglicherweise alle Objekte herunterladen, erneut verschlüsseln und erneut hochladen.
1. Wenn Sie sicher sind, dass Sie keine Nachrichten ohne Schlüsselbindung verschlüsselt haben, können Sie Ihre Verpflichtungsrichtlinie auf aktualisieren. `RequireEncryptRequireDecrypt` Dieser Wert stellt sicher, dass Ihre Daten immer mit Schlüsselbindung ver- und entschlüsselt werden. Diese Einstellung ist die Standardeinstellung, sodass Sie sie nicht explizit festlegen müssen. Wir empfehlen sie jedoch. Eine explizite Einstellung erleichtert das [Debuggen](troubleshooting-migration.md) und mögliche Rollbacks, die erforderlich sein könnten, wenn Ihre Anwendung auf Chiffretext stößt, der ohne Schlüsselbindung verschlüsselt wurde.
# Aktualisierung der AWS KMS Hauptschlüsselanbieter
Um auf die neueste Version zu migrieren 1. *x-Version* von AWS Encryption SDK und dann auf Version 2.0. *x* oder höher, Sie müssen ältere AWS KMS Hauptschlüsselanbieter durch Hauptschlüsselanbieter ersetzen, die explizit im [*strikten Modus* oder *Discovery-Modus*](about-versions.md#changes-to-mkps) erstellt wurden. Ältere Hauptschlüsselanbieter sind in Version 1.7 veraltet. *x* und wurde in Version 2.0 entfernt. *x.* Diese Änderung ist für Anwendungen und Skripts erforderlich, die die [AWS-Verschlüsselungs-SDK for Java[AWS-Verschlüsselungs-SDK for Python](python.md)](java.md), und die [AWS Encryption CLI](crypto-cli.md) verwenden. Die Beispiele in diesem Abschnitt zeigen Ihnen, wie Sie Ihren Code aktualisieren.
**Anmerkung**
[Schalten Sie in Python Verfallswarnungen ein.](https://docs.python.org/3/library/warnings.html) Auf diese Weise können Sie die Teile Ihres Codes identifizieren, die Sie aktualisieren müssen.
Wenn Sie einen AWS KMS Hauptschlüssel (keinen Hauptschlüsselanbieter) verwenden, können Sie diesen Schritt überspringen. AWS KMS Hauptschlüssel sind nicht veraltet oder wurden nicht entfernt. Sie verschlüsseln und entschlüsseln nur mit den von Ihnen angegebenen Wrapping-Schlüsseln.
Die Beispiele in diesem Abschnitt konzentrieren sich auf die Elemente Ihres Codes, die Sie ändern müssen. Ein vollständiges Beispiel für den aktualisierten Code finden Sie im Abschnitt Beispiele des GitHub Repositorys für Ihre [Programmiersprache](programming-languages.md). Außerdem verwenden diese Beispiele in der Regel Schlüssel ARNs zur Darstellung AWS KMS keys. Wenn Sie einen Hauptschlüsselanbieter für die Verschlüsselung erstellen, können Sie einen beliebigen gültigen AWS KMS [Schlüsselbezeichner](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) verwenden, um einen AWS KMS key darzustellen. Wenn Sie einen Hauptschlüsselanbieter für die Entschlüsselung erstellen, müssen Sie einen Schlüssel-ARN verwenden.
**Erfahren Sie mehr über Migration**
Informationen zur Einrichtung Ihrer Verpflichtungsrichtlinie finden Sie für alle AWS Encryption SDK Benutzer unter[Festlegung Ihrer Verpflichtungspolitik](migrate-commitment-policy.md).
Für AWS-Verschlüsselungs-SDK for JavaScript Benutzer AWS-Verschlüsselungs-SDK for C und Benutzer finden Sie weitere Informationen zu einem optionalen Update für Schlüsselanhänger in[AWS KMS Schlüsselanhänger aktualisieren](migrate-keyrings-v2.md).
**Topics**
+ [Umstellung auf den strikten Modus](#migrate-mkp-strict-mode)
+ [In den Discovery-Modus migrieren](#migrate-mkp-discovery-mode)
## Umstellung auf den strikten Modus
Nach dem Update auf die neueste Version 1. *x-Version* von AWS Encryption SDK, ersetzen Sie Ihre alten Hauptschlüsselanbieter durch Hauptschlüsselanbieter im strikten Modus. Im strikten Modus müssen Sie die Wrapping-Schlüssel angeben, die beim Verschlüsseln und Entschlüsseln verwendet werden sollen. Der AWS Encryption SDK verwendet nur die von Ihnen angegebenen Wrapping-Schlüssel. Veraltete Hauptschlüsselanbieter können Daten mit jedem entschlüsseln AWS KMS key , der einen Datenschlüssel verschlüsselt hat, auch AWS KMS keys in verschiedenen AWS-Konten Regionen.
Master-Key-Anbieter im strikten Modus wurden in Version 1.7 eingeführt. AWS Encryption SDK *x.* Sie ersetzen ältere Master-Key-Anbieter, die in 1.7 veraltet sind. *x* und in 2.0 entfernt. *x.* Die Verwendung von Master-Key-Anbietern im strikten Modus ist eine AWS Encryption SDK [bewährte Methode](best-practices.md).
Der folgende Code erstellt einen Hauptschlüsselanbieter im strikten Modus, den Sie zum Verschlüsseln und Entschlüsseln verwenden können.
------
#### [ Java ]
Dieses Beispiel stellt Code in einer Anwendung dar, die die Version 1.6.2 oder früher von verwendet. AWS-Verschlüsselungs-SDK for Java
In diesem Code wird die `KmsMasterKeyProvider.builder()` Methode verwendet, um einen AWS KMS Hauptschlüsselanbieter zu instanziieren, der einen AWS KMS key als Umschließungsschlüssel verwendet.
```
// Create a master key provider
// Replace the example key ARN with a valid one
String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
KmsMasterKeyProvider masterKeyProvider = KmsMasterKeyProvider.builder()
.withKeysForEncryption(awsKmsKey)
.build();
```
Dieses Beispiel stellt Code in einer Anwendung dar, die Version 1.7 verwendet. *x* oder höher von AWS-Verschlüsselungs-SDK for Java . Ein vollständiges Beispiel finden Sie unter [BasicEncryptionExample.java.](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/v2/BasicEncryptionExample.java)
Die im vorherigen Beispiel verwendeten `Builder.withKeysForEncryption()` Methoden `Builder.build()` und sind in Version 1.7 veraltet. *x* und wurden aus Version 2.0 entfernt. *x.*
Um auf einen Master-Key-Anbieter im strikten Modus zu aktualisieren, ersetzt dieser Code Aufrufe veralteter Methoden durch einen Aufruf der neuen `Builder.buildStrict()` Methode. In diesem Beispiel wird eine AWS KMS key als Schlüssel für den Zeilenumbruch angegeben, aber die `Builder.buildStrict()` Methode kann auch eine Liste mit mehreren verwenden. AWS KMS keys
```
// Create a master key provider in strict mode
// Replace the example key ARN with a valid one from your AWS-Konto.
String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
KmsMasterKeyProvider masterKeyProvider = KmsMasterKeyProvider.builder()
.buildStrict(awsKmsKey);
```
------
#### [ Python ]
Dieses Beispiel stellt Code in einer Anwendung dar, die Version 1.4.1 von verwendet. AWS-Verschlüsselungs-SDK for Python Dieser Code verwendet`KMSMasterKeyProvider`, was in Version 1.7 veraltet ist. *x* und wurde aus Version 2.0 entfernt. *x.* Bei der Entschlüsselung wird jeder verwendet, der einen Datenschlüssel verschlüsselt hat AWS KMS key , unabhängig von dem, was AWS KMS keys Sie angeben.
Beachten Sie, dass dies nicht veraltet `KMSMasterKey` ist oder entfernt wurde. Beim Verschlüsseln und Entschlüsseln werden nur die von Ihnen angegebenen verwendet. AWS KMS key
```
# Create a master key provider
# Replace the example key ARN with a valid one
key_1 = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
key_2 = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
aws_kms_master_key_provider = KMSMasterKeyProvider(
key_ids=[key_1, key_2]
)
```
Dieses Beispiel stellt Code in einer Anwendung dar, die Version 1.7 verwendet. *x* von AWS-Verschlüsselungs-SDK for Python. Ein vollständiges Beispiel finden Sie unter [basic\$1encryption.py](https://github.com/aws/aws-encryption-sdk-python/blob/master/examples/src/legacy/basic_encryption.py).
Um auf einen Master-Key-Anbieter im strikten Modus zu aktualisieren, ersetzt dieser Code den Aufruf von `KMSMasterKeyProvider()` durch einen Aufruf von`StrictAwsKmsMasterKeyProvider()`.
```
# Create a master key provider in strict mode
# Replace the example key ARNs with valid values from your AWS-Konto
key_1 = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
key_2 = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
aws_kms_master_key_provider = StrictAwsKmsMasterKeyProvider(
key_ids=[key_1, key_2]
)
```
------
#### [ AWS Encryption CLI ]
Dieses Beispiel zeigt, wie mit der AWS Encryption CLI Version 1.1.7 oder früher ver- und entschlüsselt wird.
In Version 1.1.7 und früher geben Sie beim Verschlüsseln einen oder mehrere Hauptschlüssel (oder *Wrapping-Schlüssel) an, z. B.* einen. AWS KMS key Beim Entschlüsseln können Sie keine Umschließungsschlüssel angeben, es sei denn, Sie verwenden einen benutzerdefinierten Hauptschlüsselanbieter. Die AWS Encryption CLI kann jeden Wrapping-Schlüssel verwenden, der einen Datenschlüssel verschlüsselt hat.
```
\\ Replace the example key ARN with a valid one
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
\\ Encrypt your plaintext data
$ aws-encryption-cli --encrypt \
--input hello.txt \
--master-keys key=$keyArn \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--output .
\\ Decrypt your ciphertext
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--output .
```
Dieses Beispiel zeigt, wie mit der AWS Encryption CLI Version 1.7 ver- und entschlüsselt wird. *x oder höher*. Vollständige Beispiele finden Sie unter[Beispiele für die AWS Encryption CLI](crypto-cli-examples.md).
Der `--master-keys` Parameter ist in Version 1.7 veraltet. *x* und wurde in Version 2.0 entfernt. *x.* Er wurde durch den `--wrapping-keys` Parameter by ersetzt, der für Befehle zum Verschlüsseln und Entschlüsseln erforderlich ist. Dieser Parameter unterstützt den strikten Modus und den Erkennungsmodus. Der strikte Modus ist eine AWS Encryption SDK bewährte Methode, mit der sichergestellt wird, dass Sie den gewünschten Umbruchschlüssel verwenden.
Um auf den *strikten Modus umzusteigen*, verwenden Sie das **Schlüsselattribut** des `--wrapping-keys` Parameters, um beim Verschlüsseln und Entschlüsseln einen Umschließungsschlüssel anzugeben.
```
\\ Replace the example key ARN with a valid value
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
\\ Encrypt your plaintext data
$ aws-encryption-cli --encrypt \
--input hello.txt \
--wrapping-keys key=$keyArn \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--output .
\\ Decrypt your ciphertext
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys key=$keyArn \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--output .
```
------
## In den Discovery-Modus migrieren
Ab Version 1.7. *x*[, es hat sich bewährt AWS Encryption SDK , den *strikten Modus* für AWS KMS Hauptschlüsselanbieter zu verwenden, d. h., beim Verschlüsseln und Entschlüsseln anzugeben, dass Schlüssel eingeschlossen werden.](best-practices.md) Sie müssen beim Verschlüsseln immer Wrapping-Schlüssel angeben. Es gibt jedoch Situationen, in denen die Angabe ARNs des Schlüssels AWS KMS keys für die Entschlüsselung nicht praktikabel ist. Wenn Sie beispielsweise AWS KMS keys beim Verschlüsseln Aliase zur Identifizierung verwenden, verlieren Sie den Vorteil von Aliasen, wenn Sie beim Entschlüsseln den Schlüssel angeben müssen. ARNs Da sich Hauptschlüsselanbieter im Erkennungsmodus wie die ursprünglichen Hauptschlüsselanbieter verhalten, können Sie sie außerdem vorübergehend als Teil Ihrer Migrationsstrategie verwenden und später im strikten Modus auf Hauptschlüsselanbieter umsteigen.
In solchen Fällen können Sie Hauptschlüsselanbieter im *Erkennungsmodus* verwenden. Bei diesen Hauptschlüsselanbietern können Sie keine Schlüssel angeben, sodass Sie sie nicht zum Verschlüsseln verwenden können. Bei der Entschlüsselung können sie jeden beliebigen Umschließungsschlüssel verwenden, mit dem ein Datenschlüssel verschlüsselt wurde. Im Gegensatz zu älteren Hauptschlüsselanbietern, die sich genauso verhalten, werden sie jedoch explizit im Discovery-Modus erstellt. Wenn Sie Master-Key-Anbieter im Discovery-Modus verwenden, können Sie die Anzahl der Wrapping-Schlüssel, die verwendet werden können, auf bestimmte Schlüssel beschränken AWS-Konten. Dieser Erkennungsfilter ist optional, aber es handelt sich um eine bewährte Methode, die wir empfehlen. Informationen zu AWS Partitionen und Konten finden Sie unter [Amazon Resource Names](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arns-syntax) in der *Allgemeine AWS-Referenz*.
In den folgenden Beispielen werden ein AWS KMS Master-Key-Provider im Strict-Modus für die Verschlüsselung und ein AWS KMS Master-Key-Provider im Discovery-Modus für die Entschlüsselung erstellt. Der Hauptschlüsselanbieter im Erkennungsmodus verwendet einen Erkennungsfilter, um die für die Entschlüsselung verwendeten Schlüssel auf die `aws` Partition und auf ein bestimmtes Beispiel zu beschränken. AWS-Konten Obwohl der Kontofilter in diesem sehr einfachen Beispiel nicht erforderlich ist, ist er eine bewährte Methode, die sehr nützlich ist, wenn eine Anwendung Daten verschlüsselt und eine andere Anwendung die Daten entschlüsselt.
------
#### [ Java ]
Dieses Beispiel stellt Code in einer Anwendung dar, die Version 1.7 verwendet. *x* oder höher von AWS-Verschlüsselungs-SDK for Java. Ein vollständiges Beispiel finden Sie unter [DiscoveryDecryptionExample.java.](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/)
Um einen Hauptschlüsselanbieter im strikten Modus für die Verschlüsselung zu instanziieren, verwendet dieses Beispiel die Methode. `Builder.buildStrict()` Um einen Hauptschlüsselanbieter im Discovery-Modus für die Entschlüsselung zu instanziieren, wird die Methode verwendet. `Builder.buildDiscovery()` Die `Builder.buildDiscovery()` Methode verwendet eine, `DiscoveryFilter` die den Wert AWS Encryption SDK auf AWS KMS keys in der angegebenen AWS Partition und den angegebenen Konten begrenzt.
```
// Create a master key provider in strict mode for encrypting
// Replace the example alias ARN with a valid one from your AWS-Konto.
String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias";
KmsMasterKeyProvider encryptingKeyProvider = KmsMasterKeyProvider.builder()
.buildStrict(awsKmsKey);
// Create a master key provider in discovery mode for decrypting
// Replace the example account IDs with valid values.
DiscoveryFilter accounts = new DiscoveryFilter("aws", Arrays.asList("111122223333", "444455556666"));
KmsMasterKeyProvider decryptingKeyProvider = KmsMasterKeyProvider.builder()
.buildDiscovery(accounts);
```
------
#### [ Python ]
Dieses Beispiel stellt Code in einer Anwendung dar, die Version 1.7 verwendet. *x* oder höher von AWS-Verschlüsselungs-SDK for Python . Ein vollständiges Beispiel finden Sie unter [discovery\$1kms\$1provider.py](https://github.com/aws/aws-encryption-sdk-python/blob/master/examples/src/legacy/discovery_kms_provider.py).
Um einen Hauptschlüsselanbieter im strikten Modus für die Verschlüsselung zu erstellen, verwendet `StrictAwsKmsMasterKeyProvider` dieses Beispiel. Um einen Hauptschlüsselanbieter im Discovery-Modus für die Entschlüsselung zu erstellen, wird `DiscoveryAwsKmsMasterKeyProvider` with a verwendet, `DiscoveryFilter` das den Wert AWS Encryption SDK auf AWS KMS keys in der angegebenen AWS Partition und den angegebenen Konten begrenzt.
```
# Create a master key provider in strict mode
# Replace the example key ARN and alias ARNs with valid values from your AWS-Konto.
key_1 = "arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias"
key_2 = "arn:aws:kms:us-west-2:444455556666:key/1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d"
aws_kms_master_key_provider = StrictAwsKmsMasterKeyProvider(
key_ids=[key_1, key_2]
)
# Create a master key provider in discovery mode for decrypting
# Replace the example account IDs with valid values
accounts = DiscoveryFilter(
partition="aws",
account_ids=["111122223333", "444455556666"]
)
aws_kms_master_key_provider = DiscoveryAwsKmsMasterKeyProvider(
discovery_filter=accounts
)
```
------
#### [ AWS Encryption CLI ]
Dieses Beispiel zeigt, wie mit der AWS Encryption CLI Version 1.7 ver- und entschlüsselt wird. *x oder höher*. Ab Version 1.7. *x*, der `--wrapping-keys` Parameter ist beim Verschlüsseln und Entschlüsseln erforderlich. Der `--wrapping-keys` Parameter unterstützt den Strict-Modus und den Discovery-Modus. Vollständige Beispiele finden Sie unter[Beispiele für die AWS Encryption CLI](crypto-cli-examples.md).
Bei der Verschlüsselung gibt dieses Beispiel einen Umschließungsschlüssel an, der erforderlich ist. Beim Entschlüsseln wird explizit der *Erkennungsmodus* ausgewählt, indem das `discovery` Attribut des `--wrapping-keys` Parameters mit dem Wert von verwendet wird. `true`
Um die Anzahl der Schlüssel, die im Discovery-Modus verwendet werden AWS Encryption SDK können, auf bestimmte Schlüssel zu beschränken AWS-Konten, werden in diesem Beispiel die `discovery-account` Attribute `discovery-partition` und des `--wrapping-keys` Parameters verwendet. Diese optionalen Attribute sind nur gültig, wenn das `discovery` Attribut auf gesetzt ist`true`. Sie müssen die `discovery-account` Attribute `discovery-partition` und zusammen verwenden. Keines der Attribute ist alleine gültig.
```
\\ Replace the example key ARN with a valid value
$ keyAlias=arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias
\\ Encrypt your plaintext data
$ aws-encryption-cli --encrypt \
--input hello.txt \
--wrapping-keys key=$keyAlias \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--output .
\\ Decrypt your ciphertext
\\ Replace the example account IDs with valid values
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys discovery=true \
discovery-partition=aws \
discovery-account=111122223333 \
discovery-account=444455556666 \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--output .
```
------
# AWS KMS Schlüsselanhänger aktualisieren
Die AWS KMS Schlüsselbunde im [AWS-Verschlüsselungs-SDK for C](c-language.md), im [AWS Encryption SDK für.NET](dot-net.md) und im [AWS-Verschlüsselungs-SDK for JavaScript](javascript.md)unterstützen [bewährte Methoden](best-practices.md), da Sie beim Verschlüsseln und Entschlüsseln angeben können, dass Schlüssel umschlossen werden. Wenn Sie einen [AWS KMS Discovery-Schlüsselbund erstellen, tun](use-kms-keyring.md#kms-keyring-discovery) Sie dies explizit.
**Anmerkung**
Die früheste Version von AWS Encryption SDK für .NET ist Version 3.0. *x.* Alle Versionen von AWS Encryption SDK für .NET unterstützen die in 2.0 eingeführten bewährten Sicherheitsmethoden. *x* der AWS Encryption SDK. Sie können sicher auf die neueste Version aktualisieren, ohne Code- oder Datenänderungen vornehmen zu müssen.
Wenn Sie auf die neueste Version aktualisieren 1. *X-Version* von AWS Encryption SDK, Sie können einen [Erkennungsfilter](use-kms-keyring.md#kms-keyring-discovery) verwenden, um die Anzahl der Schlüssel, die ein [AWS KMS Discovery-Schlüsselbund](use-kms-keyring.md#kms-keyring-discovery) oder ein [AWS KMS regionaler Discovery-Schlüsselbund](use-kms-keyring.md#kms-keyring-regional) beim Entschlüsseln verwendet, auf bestimmte Schlüssel zu beschränken. AWS-Konten[Das Filtern eines Discovery-Schlüsselbunds ist eine bewährte Methode. AWS Encryption SDK](best-practices.md)
Die Beispiele in diesem Abschnitt zeigen Ihnen, wie Sie den Discovery-Filter zu einem AWS KMS regionalen Discovery-Schlüsselbund hinzufügen.
**Erfahren Sie mehr über Migration**
Informationen zur Einrichtung Ihrer Verpflichtungsrichtlinie finden Sie für alle AWS Encryption SDK Benutzer unter[Festlegung Ihrer Verpflichtungspolitik](migrate-commitment-policy.md).
Informationen zu einem erforderlichen Update für AWS-Verschlüsselungs-SDK for Java Master-Key-Anbieter finden Sie für Benutzer von, und AWS Encryption CLI unter[Aktualisierung der AWS KMS Hauptschlüsselanbieter](migrate-mkps-v2.md). AWS-Verschlüsselungs-SDK for Python
Möglicherweise haben Sie Code wie den folgenden in Ihrer Anwendung. In diesem Beispiel wird ein AWS KMS regionaler Discovery-Schlüsselbund erstellt, für den nur Schlüssel in der Region USA West (Oregon) (us-west-2) verwendet werden können. Dieses Beispiel stellt Code in AWS Encryption SDK Versionen vor 1.7 dar. *x.* In den Versionen 1.7 ist es jedoch weiterhin gültig. *x* und später.
------
#### [ C ]
```
struct aws_cryptosdk_keyring *kms_regional_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
.WithKmsClient(create_kms_client(Aws::Region::US_WEST_2)).BuildDiscovery());
```
------
#### [ JavaScript Browser ]
```
const clientProvider = getClient(KMS, { credentials })
const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringBrowser({ clientProvider, discovery })
```
------
#### [ JavaScript Node.js ]
```
const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringNode({ clientProvider, discovery })
```
------
Ab Version 1.7. *x*, Sie können jedem Discovery-Schlüsselbund einen AWS KMS Discovery-Filter hinzufügen. Dieser Erkennungsfilter beschränkt den Wert AWS KMS keys , den er für die Entschlüsselung verwenden AWS Encryption SDK kann, auf diejenigen in der angegebenen Partition und den angegebenen Konten. Bevor Sie diesen Code verwenden, ändern Sie gegebenenfalls die Partition und ersetzen Sie das Beispielkonto IDs durch ein gültiges Konto.
------
#### [ 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")
.AddAccount("444455556666")
.Build());
struct aws_cryptosdk_keyring *kms_regional_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
.WithKmsClient(create_kms_client(Aws::Region::US_WEST_2)).BuildDiscovery(discovery_filter));
```
------
#### [ JavaScript Browser ]
```
const clientProvider = getClient(KMS, { credentials })
const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringBrowser(clientProvider, {
discovery,
discoveryFilter: { accountIDs: ['111122223333', '444455556666'], partition: 'aws' }
})
```
------
#### [ JavaScript Node.js ]
Ein vollständiges Beispiel finden Sie unter [kms\$1filtered\$1discovery.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_filtered_discovery.ts).
```
const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringNode({
clientProvider,
discovery,
discoveryFilter: { accountIDs: ['111122223333', '444455556666'], partition: 'aws' }
})
```
------
# Festlegung Ihrer Verpflichtungspolitik
[Key Commitment](concepts.md#key-commitment) stellt sicher, dass Ihre verschlüsselten Daten immer im gleichen Klartext entschlüsselt werden. Um diese Sicherheitseigenschaft ab Version 1.7 bereitzustellen. *x* AWS Encryption SDK verwendet neue [Algorithmus-Suiten](supported-algorithms.md) mit hohem Engagement. Um festzustellen, ob Ihre Daten mit Key Commitment ver- und entschlüsselt werden, verwenden Sie die Konfigurationseinstellung der [Commitment-Richtlinie](concepts.md#commitment-policy). [Das Verschlüsseln und Entschlüsseln von Daten mit Key Commitment ist eine AWS Encryption SDK bewährte Methode.](best-practices.md)
Die Festlegung einer verbindlichen Richtlinie ist ein wichtiger Bestandteil des zweiten Schritts im Migrationsprozess — der Migration von der letzten Version 1. *x* Versionen der beiden AWS Encryption SDK Versionen 2.0. *x* und später. Nachdem Sie Ihre Verpflichtungsrichtlinie festgelegt und geändert haben, sollten Sie Ihre Anwendung gründlich testen, bevor Sie sie in der Produktion einsetzen. Hinweise zur Migration finden Sie unter[Wie migriert und implementiert man AWS Encryption SDK](migration-guide.md).
Die Richtlinieneinstellung „Commitment“ hat in den Versionen 2.0 drei gültige Werte. *x* und später. In der letzten 1. *x-Versionen* (beginnend mit Version 1.7. *x*), `ForbidEncryptAllowDecrypt` ist nur gültig.
+ `ForbidEncryptAllowDecrypt`— Sie AWS Encryption SDK können nicht mit Schlüsselzusage verschlüsseln. Es kann Chiffretexte entschlüsseln, die mit oder ohne Schlüsselbindung verschlüsselt wurden.
In der letzten Version 1. *x-Versionen*, dies ist der einzig gültige Wert. Es stellt sicher, dass Sie erst dann mit Key Commitment verschlüsseln, wenn Sie vollständig bereit sind, mit Key Commitment zu entschlüsseln. Wenn Sie den Wert explizit festlegen, wird verhindert, dass sich Ihre Verpflichtungsrichtlinie automatisch ändert, `require-encrypt-require-decrypt` wenn Sie auf Version 2.0 aktualisieren. *x* oder später. Stattdessen können Sie [Ihre Verpflichtungspolitik schrittweise migrieren](#migrate-commitment-policy).
+ `RequireEncryptAllowDecrypt`— Das verschlüsselt AWS Encryption SDK immer mit Schlüsselzusage. Es kann Chiffretexte entschlüsseln, die mit oder ohne Schlüsselbindung verschlüsselt wurden. Dieser Wert wurde in Version 2.0 hinzugefügt. *x.*
+ `RequireEncryptRequireDecrypt`— Der verschlüsselt und entschlüsselt AWS Encryption SDK immer mit Schlüsselbindung. Dieser Wert wurde in Version 2.0 hinzugefügt. *x.* Dies ist der Standardwert in den Versionen 2.0. *x* und später.
In der letzten 1. *x-Versionen*, der einzig gültige Wert der Verpflichtungspolice ist`ForbidEncryptAllowDecrypt`. Nach der Migration auf Version 2.0. *x* oder später können Sie [Ihre Verpflichtungsrichtlinie schrittweise ändern](migration-guide.md), sobald Sie bereit sind. Aktualisieren Sie Ihre Verpflichtungsrichtlinie `RequireEncryptRequireDecrypt` erst, wenn Sie sicher sind, dass Sie keine Nachrichten ohne Schlüsselbindung verschlüsselt haben.
Diese Beispiele zeigen Ihnen, wie Sie Ihre Verpflichtungsrichtlinie in der neuesten Version festlegen. *x-Versionen* und in den Versionen 2.0. *x* und später. Die Technik hängt von Ihrer Programmiersprache ab.
**Erfahren Sie mehr über Migration**
Informationen zu AWS-Verschlüsselungs-SDK for Java den erforderlichen Änderungen an den AWS Hauptschlüsselanbietern finden Sie unter, und die Encryption CLI[Aktualisierung der AWS KMS Hauptschlüsselanbieter](migrate-mkps-v2.md). AWS-Verschlüsselungs-SDK for Python
Informationen zu einem optionalen Update für AWS-Verschlüsselungs-SDK for C Schlüsselanhänger finden Sie unter[AWS KMS Schlüsselanhänger aktualisieren](migrate-keyrings-v2.md). AWS-Verschlüsselungs-SDK for JavaScript
## Wie legen Sie Ihre Verpflichtungsrichtlinie fest
Die Methode, mit der Sie Ihre Verpflichtungspolitik festlegen, unterscheidet sich je nach Sprachimplementierung geringfügig. Diese Beispiele zeigen Ihnen, wie das geht. Bevor Sie Ihre Verpflichtungspolitik ändern, überprüfen Sie den mehrstufigen Ansatz unter[Wie migriert und implementiert man](migration-guide.md).
------
#### [ C ]
Ab Version 1.7. *x* von AWS-Verschlüsselungs-SDK for C, Sie verwenden die `aws_cryptosdk_session_set_commitment_policy` Funktion, um die Verpflichtungsrichtlinie für Ihre Verschlüsselungs- und Entschlüsselungssitzungen festzulegen. Die von Ihnen festgelegte Commitment-Richtlinie gilt für alle Verschlüsselungs- und Entschlüsselungsvorgänge, die in dieser Sitzung aufgerufen werden.
Die `aws_cryptosdk_session_new_from_cmm` Funktionen `aws_cryptosdk_session_new_from_keyring` und sind in Version 1.7 veraltet. *x* und in Version 2.0 entfernt. *x.* Diese Funktionen werden durch `aws_cryptosdk_session_new_from_cmm_2` Funktionen `aws_cryptosdk_session_new_from_keyring_2` und ersetzt, die eine Sitzung zurückgeben.
Wenn Sie das `aws_cryptosdk_session_new_from_keyring_2` und `aws_cryptosdk_session_new_from_cmm_2` in der letzten Version verwenden 1. *x-Versionen*, Sie müssen die `aws_cryptosdk_session_set_commitment_policy` Funktion mit dem `COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT` Commitment-Policy-Wert aufrufen. In den Versionen 2.0. *x* und höher ist der Aufruf dieser Funktion optional und akzeptiert alle gültigen Werte. Die Standard-Commitment-Richtlinie für Versionen 2.0. *x* und höher ist`COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
Ein vollständiges Beispiel finden Sie unter [string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/string.cpp).
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Create an AWS KMS keyring */
const char * key_arn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
/* Create an encrypt session with a CommitmentPolicy setting */
struct aws_cryptosdk_session *encrypt_session = aws_cryptosdk_session_new_from_keyring_2(
alloc, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
aws_cryptosdk_session_set_commitment_policy(encrypt_session,
COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT);
...
/* Encrypt your data */
size_t plaintext_consumed_output;
aws_cryptosdk_session_process(encrypt_session,
ciphertext_output,
ciphertext_buf_sz_output,
ciphertext_len_output,
plaintext_input,
plaintext_len_input,
&plaintext_consumed_output)
...
/* Create a decrypt session with a CommitmentPolicy setting */
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
struct aws_cryptosdk_session *decrypt_session = *aws_cryptosdk_session_new_from_keyring_2(
alloc, AWS_CRYPTOSDK_DECRYPT, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
aws_cryptosdk_session_set_commitment_policy(decrypt_session,
COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT);
/* Decrypt your ciphertext */
size_t ciphertext_consumed_output;
aws_cryptosdk_session_process(decrypt_session,
plaintext_output,
plaintext_buf_sz_output,
plaintext_len_output,
ciphertext_input,
ciphertext_len_input,
&ciphertext_consumed_output)
```
------
#### [ C\$1 / .NET ]
Der `require-encrypt-require-decrypt` Wert ist die Standard-Commitment-Richtlinie in allen Versionen von AWS Encryption SDK für.NET. Sie können es als bewährte Methode explizit festlegen, dies ist jedoch nicht erforderlich. Wenn Sie jedoch AWS Encryption SDK for .NET verwenden, um Chiffretext zu entschlüsseln, der mit einer anderen Sprachimplementierung von AWS Encryption SDK Without Key Commitment verschlüsselt wurde, müssen Sie den Wert der Commitment-Richtlinie auf oder ändern. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` Andernfalls schlagen Versuche, den Chiffretext zu entschlüsseln, fehl.
Im AWS Encryption SDK für.NET legen Sie die Commitment-Richtlinie für eine Instanz von fest. AWS Encryption SDK Instanziieren Sie ein `AwsEncryptionSdkConfig` Objekt mit einem `CommitmentPolicy` Parameter und verwenden Sie das Konfigurationsobjekt, um die Instanz zu erstellen. AWS Encryption SDK Rufen Sie dann die `Decrypt()` Methoden `Encrypt()` und der konfigurierten AWS Encryption SDK Instanz auf.
In diesem Beispiel wird die Commitment-Richtlinie auf festgelegt`require-encrypt-allow-decrypt`.
```
// Instantiate the material providers
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
// Configure the commitment policy on the AWS Encryption SDK instance
var config = new AwsEncryptionSdkConfig
{
CommitmentPolicy = CommitmentPolicy.REQUIRE_ENCRYPT_ALLOW_DECRYPT
};
var encryptionSdk = AwsEncryptionSdkFactory.CreateAwsEncryptionSdk(config);
string keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
var encryptionContext = new Dictionary()
{
{"purpose", "test"}encryptionSdk
};
var createKeyringInput = new CreateAwsKmsKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = keyArn
};
var keyring = materialProviders.CreateAwsKmsKeyring(createKeyringInput);
// Encrypt your plaintext data
var encryptInput = new EncryptInput
{
Plaintext = plaintext,
Keyring = keyring,
EncryptionContext = encryptionContext
};
var encryptOutput = encryptionSdk.Encrypt(encryptInput);
// Decrypt your ciphertext
var decryptInput = new DecryptInput
{
Ciphertext = ciphertext,
Keyring = keyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
```
------
#### [ AWS Encryption CLI ]
Verwenden Sie den `--commitment-policy` Parameter, um eine Commitment-Richtlinie in der AWS Encryption CLI festzulegen. Dieser Parameter wurde in Version 1.8 eingeführt. *x.*
In der letzten 1. *X-Version*, wenn Sie den `--wrapping-keys` Parameter in einem `--encrypt` `--decrypt` OR-Befehl verwenden, ist ein `--commitment-policy` Parameter mit dem `forbid-encrypt-allow-decrypt` Wert erforderlich. Andernfalls ist der `--commitment-policy` Parameter ungültig.
In den Versionen 2.1. *x* und höher ist der `--commitment-policy` Parameter optional und hat standardmäßig den `require-encrypt-require-decrypt` Wert, der keinen Chiffretext ver- oder entschlüsselt, der ohne Schlüsselzuweisung verschlüsselt wurde. Wir empfehlen jedoch, dass Sie die Commitment-Richtlinie explizit für alle Verschlüsselungs- und Entschlüsselungsanfragen festlegen, um die Wartung und Fehlerbehebung zu erleichtern.
In diesem Beispiel wird die Commitment-Richtlinie festgelegt. Außerdem wird der `--wrapping-keys` Parameter verwendet, der den `--master-keys` Parameter ab Version 1.8 ersetzt. *x.* Details hierzu finden Sie unter [Aktualisierung der AWS KMS Hauptschlüsselanbieter](migrate-mkps-v2.md). Vollständige Beispiele finden Sie unter[Beispiele für die AWS Encryption CLI](crypto-cli-examples.md).
```
\\ To run this example, replace the fictitious key ARN with a valid value.
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
\\ Encrypt your plaintext data - no change to algorithm suite used
$ aws-encryption-cli --encrypt \
--input hello.txt \
--wrapping-keys key=$keyArn \
--commitment-policy forbid-encrypt-allow-decrypt \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--output .
\\ Decrypt your ciphertext - supports key commitment on 1.7 and later
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys key=$keyArn \
--commitment-policy forbid-encrypt-allow-decrypt \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--output .
```
------
#### [ Java ]
Ab Version 1.7. *x* von AWS-Verschlüsselungs-SDK for Java, Sie legen die Commitment-Richtlinie für Ihre Instanz von fest`AwsCrypto`, dem Objekt, das den AWS Encryption SDK Client darstellt. Diese Commitment-Richtlinieneinstellung gilt für alle Verschlüsselungs- und Entschlüsselungsvorgänge, die auf diesem Client aufgerufen werden.
Der `AwsCrypto()` Konstruktor ist in der neuesten Version 1 veraltet. *x-Versionen* von AWS-Verschlüsselungs-SDK for Java und wurden in Version 2.0 entfernt. *x.* Es wird durch eine neue `Builder` Klasse, eine `Builder.withCommitmentPolicy()` Methode und den `CommitmentPolicy` Aufzählungstyp ersetzt.
In der letzten 1. *x-Versionen*, die `Builder` Klasse benötigt die `Builder.withCommitmentPolicy()` Methode und das `CommitmentPolicy.ForbidEncryptAllowDecrypt` Argument. Ab Version 2.0. *x*, die `Builder.withCommitmentPolicy()` Methode ist optional; der Standardwert ist`CommitmentPolicy.RequireEncryptRequireDecrypt`.
Ein vollständiges Beispiel finden Sie unter [SetCommitmentPolicyExample.java.](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/v2/SetCommitmentPolicyExample.java)
```
// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.ForbidEncryptAllowDecrypt)
.build();
// Create a master key provider in strict mode
String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
KmsMasterKeyProvider masterKeyProvider = KmsMasterKeyProvider.builder()
.buildStrict(awsKmsKey);
// Encrypt your plaintext data
CryptoResult encryptResult = crypto.encryptData(
masterKeyProvider,
sourcePlaintext,
encryptionContext);
byte[] ciphertext = encryptResult.getResult();
// Decrypt your ciphertext
CryptoResult decryptResult = crypto.decryptData(
masterKeyProvider,
ciphertext);
byte[] decrypted = decryptResult.getResult();
```
------
#### [ JavaScript ]
Ab Version 1.7. *x* von AWS-Verschlüsselungs-SDK for JavaScript, Sie können die Commitment-Richtlinie festlegen, wenn Sie die neue `buildClient` Funktion aufrufen, die einen AWS Encryption SDK Client instanziiert. Die `buildClient` Funktion verwendet einen Aufzählungswert, der Ihre Commitment-Richtlinie darstellt. Sie gibt aktualisierte `decrypt` Funktionen `encrypt` und Funktionen zurück, die Ihre Verpflichtungsrichtlinie beim Verschlüsseln und Entschlüsseln durchsetzen.
In der letzten Version 1. *x-Versionen*, die `buildClient` Funktion benötigt das `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT` Argument. Ab Version 2.0. *x*, das Argument der Commitment-Richtlinie ist optional und der Standardwert ist`CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
Der Code für Node.js und der Browser sind für diesen Zweck identisch, außer dass der Browser eine Anweisung benötigt, um Anmeldeinformationen festzulegen.
Im folgenden Beispiel werden Daten mit einem AWS KMS Schlüsselbund verschlüsselt. Die neue `buildClient` Funktion setzt die Commitment-Richtlinie auf`FORBID_ENCRYPT_ALLOW_DECRYPT`, den Standardwert in der letzten Version 1. *x* Versionen. Das Upgrade `encrypt` und die `decrypt` Funktionen, die `buildClient` zurückgegeben werden, setzen die von Ihnen festgelegte Verpflichtungsrichtlinie durch.
```
import { buildClient } from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT)
// Create an AWS KMS keyring
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias'
const keyIds = ['arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab']
const keyring = new KmsKeyringNode({ generatorKeyId, keyIds })
// Encrypt your plaintext data
const { ciphertext } = await encrypt(keyring, plaintext, { encryptionContext: context })
// Decrypt your ciphertext
const { decrypted, messageHeader } = await decrypt(keyring, ciphertext)
```
------
#### [ Python ]
Ab Version 1.7. *x* von AWS-Verschlüsselungs-SDK for Python, Sie legen die Commitment-Richtlinie für Ihre Instanz von fest`EncryptionSDKClient`, einem neuen Objekt, das den AWS Encryption SDK Client darstellt. Die von Ihnen festgelegte Commitment-Richtlinie gilt für alle `decrypt` Aufrufe `encrypt` und Aufrufe, die diese Instanz des Clients verwenden.
In der letzten Version 1. *X-Versionen*, der `EncryptionSDKClient` Konstruktor benötigt den `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT` Aufzählungswert. Ab Version 2.0. *x*, das Argument der Commitment-Richtlinie ist optional und der Standardwert ist`CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
In diesem Beispiel wird der neue `EncryptionSDKClient` Konstruktor verwendet und die Commitment-Richtlinie auf 1.7 gesetzt. *x* Standardwert. Der Konstruktor instanziiert einen Client, der den darstellt. AWS Encryption SDK Wenn Sie die `stream` Methoden `encrypt``decrypt`, oder auf diesem Client aufrufen, setzen sie die von Ihnen festgelegte Commitment-Richtlinie durch. In diesem Beispiel wird auch der neue Konstruktor für die `StrictAwsKmsMasterKeyProvider` Klasse verwendet, der festlegt, AWS KMS keys wann verschlüsselt und entschlüsselt werden soll.
[Ein vollständiges Beispiel finden Sie unter set\$1commitment.py.](https://github.com/aws/aws-encryption-sdk-python/blob/master/examples/src/legacy/set_commitment.py)
```
# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT)
// Create a master key provider in strict mode
aws_kms_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
aws_kms_strict_master_key_provider = StrictAwsKmsMasterKeyProvider(
key_ids=[aws_kms_key]
)
# Encrypt your plaintext data
ciphertext, encrypt_header = client.encrypt(
source=source_plaintext,
encryption_context=encryption_context,
master_key_provider=aws_kms_strict_master_key_provider
)
# Decrypt your ciphertext
decrypted, decrypt_header = client.decrypt(
source=ciphertext,
master_key_provider=aws_kms_strict_master_key_provider
)
```
------
#### [ Rust ]
Der `require-encrypt-require-decrypt` Wert ist die Standard-Commitment-Richtlinie in allen Versionen von AWS Encryption SDK for Rust. Sie können es als bewährte Methode explizit festlegen, aber es ist nicht erforderlich. Wenn Sie jedoch AWS Encryption SDK for Rust verwenden, um Chiffretext zu entschlüsseln, der mit einer Implementierung von AWS Encryption SDK Without Key Commitment in einer anderen Sprache verschlüsselt wurde, müssen Sie den Richtlinienwert Commitment auf oder ändern. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` Andernfalls schlagen Versuche, den Chiffretext zu entschlüsseln, fehl.
In der AWS Encryption SDK für Rust legen Sie die Commitment-Richtlinie für eine Instanz von fest. AWS Encryption SDK Instanziieren Sie ein `AwsEncryptionSdkConfig` Objekt mit einem `comitment_policy` Parameter und verwenden Sie das Konfigurationsobjekt, um die Instanz zu erstellen. AWS Encryption SDK Rufen Sie dann die `Decrypt()` Methoden `Encrypt()` und der konfigurierten AWS Encryption SDK Instanz auf.
In diesem Beispiel wird die Commitment-Richtlinie auf festgelegt`forbid-encrypt-allow-decrypt`.
```
// Configure the commitment policy on the AWS Encryption SDK instance
let esdk_config = AwsEncryptionSdkConfig::builder()
.commitment_policy(ForbidEncryptAllowDecrypt)
.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);
// 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()),
]);
// 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?;
// Encrypt your plaintext data
let plaintext = example_data.as_bytes();
let encryption_response = esdk_client.encrypt()
.plaintext(plaintext)
.keyring(kms_keyring.clone())
.encryption_context(encryption_context.clone())
.send()
.await?;
// Decrypt your ciphertext
let decryption_response = esdk_client.decrypt()
.ciphertext(ciphertext)
.keyring(kms_keyring)
// Provide the encryption context that was supplied to the encrypt method
.encryption_context(encryption_context)
.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
commitPolicyForbidEncryptAllowDecrypt := mpltypes.ESDKCommitmentPolicyForbidEncryptAllowDecrypt
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{CommitmentPolicy: &commitPolicyForbidEncryptAllowDecrypt})
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 an AWS KMS keyring
awsKmsKeyringInput := mpltypes.CreateAwsKmsKeyringInput{
KmsClient: kmsClient,
KmsKeyId: kmsKeyId,
}
awsKmsKeyring, err := matProv.CreateAwsKmsKeyring(context.Background(), awsKmsKeyringInput)
if err != nil {
panic(err)
}
// Encrypt your plaintext data
res, err := forbidEncryptClient.Encrypt(context.Background(), esdktypes.EncryptInput{
Plaintext: []byte(exampleText),
EncryptionContext: encryptionContext,
Keyring: awsKmsKeyring,
})
if err != nil {
panic(err)
}
// Decrypt your ciphertext
decryptOutput, err := forbidEncryptClient.Decrypt(context.Background(), esdktypes.DecryptInput{
Ciphertext: res.Ciphertext,
EncryptionContext: encryptionContext,
Keyring: awsKmsKeyring,
})
if err != nil {
panic(err)
}
```
------
# Fehlerbehebung bei der Migration auf die neuesten Versionen
Bevor Sie Ihre Anwendung auf Version 2.0 aktualisieren. *x* oder höher von AWS Encryption SDK, aktualisieren Sie auf die neueste Version 1. *x-Version* von AWS Encryption SDK und stellen Sie sie vollständig bereit. Auf diese Weise können Sie die meisten Fehler vermeiden, die beim Update auf Version 2.0 auftreten können. *x* und später. Eine ausführliche Anleitung, einschließlich Beispielen, finden Sie unter[Migrieren Sie Ihre AWS Encryption SDK](migration.md).
**Wichtig**
Vergewissern Sie sich, dass Ihr neuestes 1. *x-Version* ist Version 1.7. *x* oder höher von AWS Encryption SDK.
**Anmerkung**
**AWS Encryption CLI**: Verweise in diesem Handbuch auf Version 1.7. *x* der Angaben AWS Encryption SDK beziehen sich auf Version 1.8. *x* der AWS Encryption CLI. Verweise in diesem Handbuch auf Version 2.0. *x* davon AWS Encryption SDK gelten für 2.1. *x* der AWS Encryption CLI.
Neue Sicherheitsfunktionen wurden ursprünglich in den AWS Encryption CLI Versionen 1.7 veröffentlicht. *x* und 2.0. *x.* Allerdings AWS Encryption CLI Version 1.8. *x* ersetzt Version 1.7. *x* und AWS Encryption CLI 2.1. *x* ersetzt 2.0. *x.* Einzelheiten finden Sie in der entsprechenden [Sicherheitsempfehlung](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) im [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)Repository unter GitHub.
Dieses Thema soll Ihnen helfen, die häufigsten Fehler zu erkennen und zu beheben, auf die Sie möglicherweise stoßen.
**Topics**
+ [Veraltete oder entfernte Objekte](#deprecated-removed)
+ [Konfigurationskonflikt: Verpflichtungsrichtlinie und Algorithmus-Suite](#configuration-conflict_1)
+ [Konfigurationskonflikt: Verpflichtungsrichtlinie und Chiffretext](#configuration-conflict_2)
+ [Die Überprüfung der Schlüsselzusage ist fehlgeschlagen](#commitment-failed)
+ [Andere Verschlüsselungsfehler](#encrypt-failed)
+ [Andere Fehler bei der Entschlüsselung](#decrypt-failed)
+ [Überlegungen zum Rollback](#migration-rollback)
## Veraltete oder entfernte Objekte
Version 2.0. *x* enthält mehrere grundlegende Änderungen, darunter das Entfernen älterer Konstruktoren, Methoden, Funktionen und Klassen, die in Version 1.7 veraltet waren. *x.* Um Compilerfehler, Importfehler, Syntaxfehler und Fehler, dass das Symbol nicht gefunden wurde (abhängig von Ihrer Programmiersprache) zu vermeiden, aktualisieren Sie zuerst auf die neueste Version 1. *x-Version* von AWS Encryption SDK für Ihre Programmiersprache. (Dies muss Version 1.7 sein. *x* oder später.) Bei Verwendung der neuesten Version 1. In der *X-Version* können Sie beginnen, die Ersatzelemente zu verwenden, bevor die ursprünglichen Symbole entfernt werden.
Wenn Sie auf Version 2.0 aktualisieren müssen. *x* oder später, [konsultieren Sie sofort das Changelog](about-versions.md) für Ihre Programmiersprache und ersetzen Sie die alten Symbole durch die Symbole, die im Changelog empfohlen werden.
## Konfigurationskonflikt: Verpflichtungsrichtlinie und Algorithmus-Suite
Wenn Sie eine Algorithmus-Suite angeben, die mit Ihrer [Commitment-Richtlinie in](concepts.md#commitment-policy) Konflikt steht, schlägt der Verschlüsselungsaufruf mit einem *Konfigurationskonfliktfehler* fehl.
Um diese Art von Fehler zu vermeiden, geben Sie keine Algorithmus-Suite an. Standardmäßig AWS Encryption SDK wählt der den sichersten Algorithmus aus, der mit Ihrer Verpflichtungspolitik kompatibel ist. Wenn Sie jedoch eine Algorithmus-Suite angeben müssen, z. B. eine Suite ohne Signatur, stellen Sie sicher, dass Sie eine Algorithmus-Suite wählen, die mit Ihrer Commitment-Richtlinie kompatibel ist.
| Verpflichtungspolitik | Kompatible Algorithmus-Suiten |
| --- | --- |
| ForbidEncryptAllowDecrypt | Jede Algorithmus-Suite *ohne* Schlüsselbindung, wie zum Beispiel:AES\$1256\$1GCM\$1IV12\$1TAG16\$1HKDF\$1SHA384\$1ECDSA\$1P384([03 78](algorithms-reference.md)) (mit Signatur) `AES_256_GCM_IV12_TAG16_HKDF_SHA256`([01 78](algorithms-reference.md)) (ohne Unterschrift) |
| RequireEncryptAllowDecryptRequireEncryptRequireDecrypt | Jede Algorithmus-Suite *mit* Schlüsselverpflichtung, wie zum Beispiel:AES\$1256\$1GCM\$1HKDF\$1SHA512\$1COMMIT\$1KEY\$1ECDSA\$1P384([05 78](algorithms-reference.md)) (mit Signatur) `AES_256_GCM_HKDF_SHA512_COMMIT_KEY`([04 78](algorithms-reference.md)) (ohne Unterschrift) |
Wenn dieser Fehler auftritt, obwohl Sie keine Algorithmus-Suite angegeben haben, wurde die Algorithmus-Suite, die den Konflikt verursacht, möglicherweise von Ihrem [Cryptographic Materials Manager](concepts.md#crypt-materials-manager) (CMM) ausgewählt. Das Standard-CMM wählt keine widersprüchliche Algorithmus-Suite aus, wohl aber ein benutzerdefiniertes CMM. Hilfe finden Sie in der Dokumentation zu Ihrem benutzerdefinierten CMM.
## Konfigurationskonflikt: Verpflichtungsrichtlinie und Chiffretext
[Die `RequireEncryptRequireDecrypt`[Commitment-Richtlinie erlaubt es nicht, eine Nachricht AWS Encryption SDK zu entschlüsseln, die ohne Schlüsselzusage](concepts.md#commitment-policy) verschlüsselt wurde.](concepts.md#key-commitment) Wenn Sie den bitten, eine Nachricht ohne Schlüsselübergabe AWS Encryption SDK zu entschlüsseln, wird ein *Konfigurationskonfliktfehler* zurückgegeben.
Um diesen Fehler zu vermeiden, sollten Sie vor der `RequireEncryptRequireDecrypt` Festlegung der Commitment-Richtlinie sicherstellen, dass alle Chiffretexte, die ohne Schlüsselzuweisung verschlüsselt wurden, mit Key Commitment entschlüsselt und erneut verschlüsselt werden oder von einer anderen Anwendung verarbeitet werden. Wenn Sie auf diesen Fehler stoßen, können Sie einen Fehler für den widersprüchlichen Chiffretext zurückgeben oder Ihre Verpflichtungsrichtlinie vorübergehend auf ändern. `RequireEncryptAllowDecrypt`
Wenn dieser Fehler auftritt, weil Sie auf Version 2.0 aktualisiert haben. *x* oder höher von einer Version vor 1.7. *x* ohne vorher auf die neueste Version aktualisiert zu haben 1. *x-Version* (Version 1.7). *x* oder höher), erwägen Sie[, auf die neueste Version 1 zurückzukehren](#migration-rollback). *x-Version* und Bereitstellung dieser Version auf allen Hosts vor dem Upgrade auf Version 2.0. *x* oder höher. Weitere Informationen dazu finden Sie unter [Wie migriert und implementiert man AWS Encryption SDK](migration-guide.md).
## Die Überprüfung der Schlüsselzusage ist fehlgeschlagen
Wenn Sie Nachrichten entschlüsseln, die mit Key Commitment verschlüsselt wurden, erhalten Sie möglicherweise die Fehlermeldung *Key Commitment Validation failed*. Dies weist darauf hin, dass der Entschlüsselungsaufruf fehlgeschlagen ist, weil ein Datenschlüssel in einer [verschlüsselten Nachricht](concepts.md#DEK) nicht mit dem eindeutigen Datenschlüssel für die Nachricht identisch ist. Durch die Überprüfung des Datenschlüssels während der Entschlüsselung schützt Sie die [Schlüsselzusage](concepts.md#key-commitment) davor, eine Nachricht zu entschlüsseln, die zu mehr als einem Klartext führen könnte.
Dieser Fehler weist darauf hin, dass die verschlüsselte Nachricht, die Sie zu entschlüsseln versuchten, nicht von der zurückgegeben wurde. AWS Encryption SDK Es kann sich um eine manuell erstellte Nachricht oder um das Ergebnis einer Datenbeschädigung handeln. Wenn dieser Fehler auftritt, kann Ihre Anwendung die Nachricht zurückweisen und die Verarbeitung neuer Nachrichten fortsetzen oder beenden.
## Andere Verschlüsselungsfehler
Die Verschlüsselung kann aus mehreren Gründen fehlschlagen. Sie können einen [AWS KMS Discovery-Schlüsselbund](use-kms-keyring.md#kms-keyring-discovery) oder einen [Hauptschlüsselanbieter im Discovery-Modus](migrate-mkps-v2.md) nicht verwenden, um eine Nachricht zu verschlüsseln.
Stellen Sie sicher, dass Sie einen Schlüsselbund oder einen Hauptschlüsselanbieter angeben, der Schlüssel umschließt, den Sie für die [Verschlüsselung verwenden dürfen](use-kms-keyring.md#kms-keyring-permissions). Hilfe zu Berechtigungen für finden Sie unter [Schlüsselrichtlinie anzeigen](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-viewing.html) und [Zugriff auf eine bestimmen AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/determining-access.html) im *AWS Key Management Service Entwicklerhandbuch*. AWS KMS keys
## Andere Fehler bei der Entschlüsselung
Wenn Ihr Versuch, eine verschlüsselte Nachricht zu entschlüsseln, fehlschlägt, bedeutet dies, dass Sie keinen der verschlüsselten Datenschlüssel in der Nachricht entschlüsseln AWS Encryption SDK konnten (oder wollten).
Wenn Sie einen Schlüsselbund oder einen Hauptschlüsselanbieter verwendet haben, der Wrapping Keys spezifiziert, AWS Encryption SDK verwendet dieser nur die von Ihnen angegebenen Wrapping-Schlüssel. Vergewissern Sie sich, dass Sie die beabsichtigten Umschließungsschlüssel verwenden und dass Sie für mindestens einen der Umschließungsschlüssel `kms:Decrypt` berechtigt sind. Wenn Sie die Nachricht als Fallback verwenden AWS KMS keys, können Sie versuchen, die Nachricht mit einem [AWS KMS Discovery-Schlüsselbund oder einem [Hauptschlüsselanbieter im](migrate-mkps-v2.md) Discovery-Modus](use-kms-keyring.md#kms-keyring-discovery) zu entschlüsseln. Wenn der Vorgang erfolgreich ist, überprüfen Sie vor der Rückgabe des Klartextes, ob der Schlüssel, der zum Entschlüsseln der Nachricht verwendet wurde, vertrauenswürdig ist.
## Überlegungen zum Rollback
[Wenn Ihre Anwendung Daten nicht ver- oder entschlüsseln kann, können Sie das Problem in der Regel beheben, indem Sie die Codesymbole, Schlüsselringe, Hauptschlüsselanbieter oder die Verpflichtungsrichtlinie aktualisieren.](concepts.md#commitment-policy) In einigen Fällen können Sie jedoch entscheiden, dass es am besten ist, Ihre Anwendung auf eine frühere Version von zurückzusetzen. AWS Encryption SDK
Wenn Sie ein Rollback durchführen müssen, tun Sie dies mit Vorsicht. Versionen AWS Encryption SDK vor 1.7. *x* [kann Chiffretext, der mit Key Commitment verschlüsselt wurde, nicht entschlüsseln.](concepts.md#key-commitment)
+ Ein Rollback von der neuesten Version wird rückgängig gemacht 1. Die *X-Version* auf eine frühere Version von AWS Encryption SDK ist im Allgemeinen sicher. Möglicherweise müssen Sie Änderungen, die Sie an Ihrem Code vorgenommen haben, rückgängig machen, um Symbole und Objekte zu verwenden, die in früheren Versionen nicht unterstützt wurden.
+ Sobald Sie in Version 2.0 mit der Verschlüsselung mit Key Commitment begonnen haben (indem Sie Ihre Commitment-Richtlinie auf einstellen`RequireEncryptAllowDecrypt`). *x* oder höher können Sie zu Version 1.7 zurückkehren. *x*, aber nicht zu einer früheren Version. Versionen der AWS Encryption SDK Vorgängerversionen vor 1.7. *x* [kann Chiffretext, der mit Key Commitment verschlüsselt wurde, nicht entschlüsseln.](concepts.md#key-commitment)
Wenn Sie versehentlich die Verschlüsselung mit Schlüsselzusage aktivieren, bevor alle Hosts mit Schlüsselzusage entschlüsseln können, ist es möglicherweise am besten, mit dem Rollout fortzufahren, anstatt ein Rollback durchzuführen. Wenn Nachrichten vorübergehend sind oder gefahrlos gelöscht werden können, sollten Sie ein Rollback mit Verlust von Nachrichten in Betracht ziehen. Wenn ein Rollback erforderlich ist, sollten Sie in Betracht ziehen, ein Tool zu schreiben, das alle Nachrichten entschlüsselt und erneut verschlüsselt.